void ComponentDiagramView::displayContextMenu(guint button, guint32 acttime, gpointer /*data*/) { GtkMenu *menu = Builder::getBuilder()->getMenu("DrawComponentPopupMenu"); GtkCheckMenuItem *implicitItem = GTK_CHECK_MENU_ITEM( Builder::getBuilder()->getWidget("ShowImplicitRelationsMenuitem")); ComponentDrawOptions opts = getDrawOptions(); gtk_check_menu_item_set_active(implicitItem, opts.drawImplicitRelations); gtk_menu_popup(menu, nullptr, nullptr, nullptr, nullptr, button, acttime); }
void gui_set_view(const enum gui_view_e view) { switch (view) { case GUI_VIEW_FILE: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM( gui.radiomenuitem_file), true); break; case GUI_VIEW_TEXT: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM( gui.radiomenuitem_text), true); break; case GUI_VIEW_FILE_LIST: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM( gui.radiomenuitem_file_list), true); break; default: g_assert_not_reached(); } }
/**************************************************************************************************** * the events of the main window * used to keep the "fullscreen"-checkbox up-to-date ****************************************************************************************************/ static gboolean window_event_cb(GtkWidget *window, GdkEventWindowState *event, gpointer menubar_p) { Menu * menubar = GOSM_MENU(menubar_p); if ((event -> changed_mask & GDK_WINDOW_STATE_FULLSCREEN) != 0){ gboolean fullscreened = (gdk_window_get_state(GTK_WIDGET(menubar -> main_window) -> window) & GDK_WINDOW_STATE_FULLSCREEN) != 0; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menubar -> menu_view_fullscreen), fullscreened); } }
void change_show_enemy(GtkWidget * button, gpointer user_data) { GtkWidget *checkmenuitem = g_object_get_data(G_OBJECT(button), "checkmenu"); g_object_set_data(G_OBJECT(checkmenuitem), "dirty", GINT_TO_POINTER(TRUE)); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(checkmenuitem), GPOINTER_TO_INT(user_data)); cbt_info.show_enemy = GPOINTER_TO_INT(user_data); }
void hide_status_bar() { gtk_widget_hide(status_bar); bshow_status_bar = 0; save_preference(); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(display_statusbar), bshow_status_bar); }
/** * nma_utils_setup_password_storage: * @passwd_entry: password #GtkEntry which the icon is attached to * @initial_flags: initial secret flags to setup password menu from * @setting: #NMSetting containing the password, or NULL * @password_flags_name: name of the secret flags (like psk-flags), or NULL * @with_not_required: whether to include "Not required" menu item * @ask_mode: %TRUE if the entrie is shown in ASK mode. That means, * while prompting for a password, contrary to being inside the * editor mode. * If %TRUE, the entry should be sensivive on selected "always-ask" * icon (this is e.f. for nm-applet asking for password), otherwise * not. * If %TRUE, it shall not be possible to select a different storage, * because we only prompt for a password, we cannot change the password * location. * * Adds a secondary icon and creates a popup menu for password entry. * The active menu item is set up according to initial_flags, or * from @setting/@password_flags_name (if they are not NULL). * If the @setting/@password_flags_name are not NULL, secret flags will * be automatically updated in the setting when menu is changed. */ void nma_utils_setup_password_storage (GtkWidget *passwd_entry, NMSettingSecretFlags initial_flags, NMSetting *setting, const char *password_flags_name, gboolean with_not_required, gboolean ask_mode) { GtkWidget *popup_menu; GtkWidget *item[4]; GSList *group; MenuItem idx; NMSettingSecretFlags secret_flags; /* Whether entry should be sensitive if "always-ask" is active " */ g_object_set_data (G_OBJECT (passwd_entry), ASK_MODE_TAG, GUINT_TO_POINTER (ask_mode)); popup_menu = gtk_menu_new (); g_object_set_data (G_OBJECT (popup_menu), PASSWORD_STORAGE_MENU_TAG, GUINT_TO_POINTER (TRUE)); g_object_set_data (G_OBJECT (popup_menu), MENU_WITH_NOT_REQUIRED_TAG, GUINT_TO_POINTER (with_not_required)); group = NULL; item[0] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[0])); group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item[0])); item[1] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[1])); item[2] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[2])); if (with_not_required) item[3] = gtk_radio_menu_item_new_with_label (group, gettext (icon_desc_table[3])); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[0]); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[1]); gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[2]); if (with_not_required) gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item[3]); popup_menu_item_info_register (item[0], setting, password_flags_name, ITEM_STORAGE_USER, passwd_entry); popup_menu_item_info_register (item[1], setting, password_flags_name, ITEM_STORAGE_SYSTEM, passwd_entry); popup_menu_item_info_register (item[2], setting, password_flags_name, ITEM_STORAGE_ASK, passwd_entry); if (with_not_required) popup_menu_item_info_register (item[3], setting, password_flags_name, ITEM_STORAGE_UNUSED, passwd_entry); g_signal_connect (passwd_entry, "icon-release", G_CALLBACK (icon_release_cb), popup_menu); gtk_entry_set_icon_activatable (GTK_ENTRY (passwd_entry), GTK_ENTRY_ICON_SECONDARY, !ask_mode); gtk_menu_attach_to_widget (GTK_MENU (popup_menu), passwd_entry, NULL); /* Initialize active item for password-storage popup menu */ if (setting && password_flags_name) nm_setting_get_secret_flags (setting, password_flags_name, &secret_flags, NULL); else secret_flags = initial_flags; idx = secret_flags_to_menu_item (secret_flags, with_not_required); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item[idx]), TRUE); change_password_storage_icon (passwd_entry, idx); }
static void on_select_no_event_handlers_activate (GtkMenuItem *mi, void *user_data) { Viewer *self = (Viewer*) user_data; for (unsigned int eidx = 0; eidx < g_ptr_array_size(self->event_handlers); eidx++) { EventHandler *ehandler = g_ptr_array_index(self->event_handlers, eidx); ehandler->enabled = 0; gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(ehandler->cmi), ehandler->enabled); } }
static bool_t watch_cb (PluginHandle * plugin, GtkCheckMenuItem * item) { bool_t enabled = aud_plugin_get_enabled (plugin); gtk_check_menu_item_set_active (item, enabled); GtkWidget * settings = g_object_get_data ((GObject *) item, "settings"); if (settings != NULL) gtk_widget_set_sensitive (settings, enabled); return TRUE; }
void GuiMenuItem_check (GuiObject menuItem, bool check) { Melder_assert (menuItem != NULL); gulong handlerId = (gulong) g_object_get_data (G_OBJECT (menuItem), "handlerId"); void (*commandCallback) (GuiObject, XtPointer, XtPointer) = (void (*)(GtkWidget*, void*, void*))g_object_get_data (G_OBJECT (menuItem), "commandCallback"); void *commandClosure = g_object_get_data (G_OBJECT (menuItem), "commandClosure"); //Melder_casual ("GuiMenuItem_check %ld %ld %ld", handlerId, commandCallback, commandClosure); g_signal_handler_disconnect (G_OBJECT (menuItem), handlerId); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuItem), check); handlerId = g_signal_connect (G_OBJECT (menuItem), "toggled", G_CALLBACK (commandCallback), (gpointer) commandClosure); g_object_set_data (G_OBJECT (menuItem), "handlerId", (gpointer) handlerId); }
static void _display_mode_osd_changed_cb (OlConfigProxy *config, const gchar *key, gpointer data) { gboolean osd_enabled = ol_config_proxy_get_bool (config, key); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu.switch_osd), osd_enabled); gtk_widget_set_visible(menu.lock, osd_enabled); gtk_widget_set_visible(menu.hide, osd_enabled); }
static void _locked_changed_cb (OlConfigProxy *config, const gchar *key, gpointer data) { gboolean locked = ol_config_proxy_get_bool (config, key); if (menu.lock != NULL && locked != gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu.lock))) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu.lock), locked); }
static void _visible_changed_cb (OlConfigProxy *config, const gchar *key, gpointer data) { gboolean visible = ol_config_proxy_get_bool (config, key); if (menu.hide && visible == gtk_check_menu_item_get_active (GTK_CHECK_MENU_ITEM (menu.hide))) gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menu.hide), !visible); }
// Set the check state of a menu item. // We have to be careful not to change the activation state. void rtk_menuitem_check(rtk_menuitem_t *item, int check) { int tmp; if (!item->menu->canvas->destroyed) { tmp = item->activated; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item->item), check); item->activated = tmp; } }
void MenuCallback(::GtkMenuItem* nativeItem, gpointer data) { GtkMenuItem* item = static_cast<GtkMenuItem*>(data); if (item->IsCheck()) { GtkMenuItem::BlockSignal(nativeItem, item); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(nativeItem), item->GetState()); GtkMenuItem::UnblockSignal(nativeItem, item); } item->HandleClickEvent(0); }
GtkWidget *menu_item_add_check(GtkWidget *menu, const gchar *label, gboolean active, GCallback func, gpointer data) { GtkWidget *item; item = gtk_check_menu_item_new_with_mnemonic(label); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), active); menu_item_finish(menu, item, func, data); return item; }
int main (int argc, char *argv[]) { GtkWidget *window; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *viewmenu; GtkWidget *view; GtkWidget *tog_stat; GtkWidget *statusbar; gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); gtk_window_set_default_size(GTK_WINDOW(window), 250, 200); gtk_window_set_title(GTK_WINDOW(window), "view statusbar"); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); menubar = gtk_menu_bar_new(); viewmenu = gtk_menu_new(); view = gtk_menu_item_new_with_label("View"); // check menu item tog_stat = gtk_check_menu_item_new_with_label ("View Statusbar"); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE); gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu); gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat); gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3); statusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1); g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(tog_stat), "activate", G_CALLBACK(toggle_statusbar), statusbar); gtk_widget_show_all(window); gtk_main(); return 0; }
GtkWidget *menu_toggle_item(char *label, GtkWidget *menu, void *callback, void *userdata, int state) { GtkWidget *item; item = gtk_check_menu_item_new_with_mnemonic(label); gtk_check_menu_item_set_active((GtkCheckMenuItem *) item, state); gtk_menu_shell_append(GTK_MENU_SHELL(menu), item); g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(callback), userdata); gtk_widget_show(item); return item; }
bool _HYModelWindow::_ProcessMenuSelection (long msel) { if (_HYTWindow::_ProcessMenuSelection(msel)) { return true; } switch (msel) { case HY_WINDOW_MENU_ID_FILE+1: // save menu case HY_WINDOW_MENU_ID_FILE+3: { // save as menu DoSave (msel-HY_WINDOW_MENU_ID_FILE-2); return true; } case HY_WINDOW_MENU_ID_FILE+2: { // print _HYTable* t = (_HYTable*)GetCellObject (MODEL_MATRIX_ROW,4); t->_PrintTable((_HYTable*)GetCellObject (MODEL_MATRIX_ROW-1,4)); return true; } case HY_WINDOW_MENU_ID_EDIT+1: { // copy DoCopyCell (); return true; } case HY_WINDOW_MENU_ID_EDIT+3: { // paste DoPasteToCells(); return true; } case HY_WINDOW_MENU_ID_EDIT+5: { // select all DoSelectAll(); return true; } case HY_MDL_WIN32_MENU_BASE: { // model menu DoEditModelName (); return true; } default: { // rate menu msel -= HY_MDL_WIN32_MENU_BASE+100; if (msel >=0 && gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_widget_by_action(menu_items,HY_MDL_WIN32_MENU_BASE+100+msel)))) if (msel!=rateChoice) { gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_widget_by_action(menu_items,HY_MDL_WIN32_MENU_BASE+100+rateChoice)),false); rateChoice = msel; taint = true; } return true; } } return false; }
/* callback to show and hide the curves pane */ G_MODULE_EXPORT void on_view_curves (GtkObject *object, gpointer user_data) { GtkWidget *divider_w, *menu_w, *btn_w, *visnote_w; GtkAllocation vis_alloc; int position, vis_width; static int saved_div_position = 0; divider_w = get_widget("graph_divider"); menu_w = get_widget("m_view_curves"); btn_w = get_widget("view_metrics_btn"); visnote_w = get_widget("visualisation_notebook"); g_signal_handlers_block_by_func(G_OBJECT(object), G_CALLBACK(on_view_curves), NULL); position = gtk_paned_get_position(GTK_PANED(divider_w)); gtk_widget_get_allocation(visnote_w, &vis_alloc); vis_width = vis_alloc.width; /* if the divider is set to have a very small gap to the right hand * edge then it is assumed that the curves are hidden to all intents. * The gap is measured against the edge of the visualisation_notebook */ if (position + 50 < vis_width) { /* hide by setting the position to 9999 */ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_w), FALSE); gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btn_w), FALSE); gtk_paned_set_position(GTK_PANED(divider_w), 9999); saved_div_position = position; } else { /* show curve list by restoring the previous divider position */ gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menu_w), TRUE); gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(btn_w), TRUE); gtk_paned_set_position(GTK_PANED(divider_w), saved_div_position); } g_signal_handlers_unblock_by_func(G_OBJECT(object), G_CALLBACK(on_view_curves), NULL); }
gboolean on_GOP_window_delete_event (GtkWidget *widget, GdkEvent *event, gpointer user_data) { GtkWidget *menuitem; menuitem = GTK_WIDGET(lookup_widget(GTK_WIDGET(main_window), "menu_info_window")); gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(menuitem), FALSE ); gtk_widget_hide(GOP_window); return TRUE; }
static void on_select_no_renderers_activate (GtkMenuItem *mi, void *user_data) { Viewer *self = (Viewer*) user_data; for (unsigned int ridx = 0; ridx < g_ptr_array_size(self->renderers); ridx++) { Renderer *renderer = g_ptr_array_index(self->renderers, ridx); renderer->enabled = 0; gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(renderer->cmi), renderer->enabled); } }
void switcher_button_update_icon(SwitcherButton *self) { if (self->priv->model == N800 || self->priv->model == N810) self->priv->current = gconf_client_get_int(self->priv->gconfClient, GCONF_CURRENT_2008, 0); else if (self->priv->model == N770) self->priv->current = gconf_client_get_bool(self->priv->gconfClient, GCONF_CURRENT_2006, 0) ? 0 : 1; self->priv->locked = gconf_client_get_bool(self->priv->gconfClient, GCONF_LOCK_ENTRY, 0) ? 1 : 0; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(self->priv->menuItemBlock), self->priv->locked != 0); gtk_widget_queue_draw(GTK_WIDGET(self)); }
/******************************************************* * OnDeleteReferenceWindow関数 * * 参考用画像表示ウィンドウ破棄時に呼び出される * * 引数 * * window : 参考用画像表示ウィンドウウィジェット * * reference : 参考用画像表示ウィンドウの情報 * *******************************************************/ static void OnDestroyReferenceWindow(GtkWidget* window, REFERENCE_WINDOW* reference) { if(reference->data != NULL) { reference->app->flags |= APPLICATION_IN_DELETE_EVENT; gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(reference->menu_item), FALSE); reference->app->flags &= ~(APPLICATION_IN_DELETE_EVENT); MEM_FREE_FUNC(reference->data); reference->data = NULL; } }
static void on_document_activate(G_GNUC_UNUSED GObject *obj, GeanyDocument *doc, G_GNUC_UNUSED gpointer gdata) { ScintillaObject *sci = doc->editor->sci; plugin_internal_callback = TRUE; column_mode = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sci), "column_mode")); gtk_check_menu_item_set_active(column_mode_item, column_mode); plugin_internal_callback = FALSE; select_anchor = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sci), "select_anchor")); select_space = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(sci), "select_space")); }
void msgwin_show_hide(gboolean show) { ui_prefs.msgwindow_visible = show; ignore_callback = TRUE; gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM(ui_lookup_widget(main_widgets.window, "menu_show_messages_window1")), show); ignore_callback = FALSE; ui_widget_show_hide(main_widgets.message_window_notebook, show); /* set the input focus back to the editor */ keybindings_send_command(GEANY_KEY_GROUP_FOCUS, GEANY_KEYS_FOCUS_EDITOR); }
JNIEXPORT void JNICALL Java_gnu_java_awt_peer_gtk_GtkCheckboxMenuItemPeer_setState (JNIEnv *env, jobject obj, jboolean state) { void *ptr; ptr = NSA_GET_PTR (env, obj); gdk_threads_enter (); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ptr), state); gdk_threads_leave (); }
/** \brief Manage toggling of Ground Track. * \param item The menu item that was toggled. * \param data Pointer to the GtkPolarView structure. * */ static void track_toggled(GtkCheckMenuItem * item, gpointer data) { GtkPolarView *pv = GTK_POLAR_VIEW(data); sat_obj_t *obj = NULL; sat_t *sat; /* qth_t *qth; Unused */ gint *catnum; /* get satellite object */ obj = SAT_OBJ(g_object_get_data(G_OBJECT(item), "obj")); sat = SAT(g_object_get_data(G_OBJECT(item), "sat")); /*qth = (qth_t *)(g_object_get_data (G_OBJECT (item), "qth")); */ if (obj == NULL) { sat_log_log(SAT_LOG_LEVEL_ERROR, _("%s:%d: Failed to get satellite object."), __FILE__, __LINE__); return; } /* toggle flag */ obj->showtrack = !obj->showtrack; gtk_check_menu_item_set_active(item, obj->showtrack); catnum = g_new0(gint, 1); *catnum = sat->tle.catnr; if (obj->showtrack) { /* add sky track */ /* add it to the storage structure */ g_hash_table_insert(pv->showtracks_on, catnum, NULL); /* remove it from the don't show */ g_hash_table_remove(pv->showtracks_off, catnum); gtk_polar_view_create_track(pv, obj, sat); } else { /* add it to the hide */ g_hash_table_insert(pv->showtracks_off, catnum, NULL); /* remove it from the show */ g_hash_table_remove(pv->showtracks_on, catnum); /* delete sky track */ gtk_polar_view_delete_track(pv, obj, sat); } }
static void w_pltbrowser_initmenu (struct ddb_gtkui_widget_s *w, GtkWidget *menu) { GtkWidget *item; item = gtk_check_menu_item_new_with_mnemonic (_("Show Column Headers")); gtk_widget_show (item); int showheaders = deadbeef->conf_get_int ("gtkui.pltbrowser.show_headers", 1); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), showheaders); gtk_container_add (GTK_CONTAINER (menu), item); g_signal_connect ((gpointer) item, "toggled", G_CALLBACK (on_pltbrowser_showheaders_toggled), w); }
void tray_menu_enable_mute_button (gboolean enable) { if (tray_menu) { g_signal_handler_block (mute_menuitem, mute_menuitem_toggled_cb_id); gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mute_menuitem), enable); g_signal_handler_unblock (mute_menuitem, mute_menuitem_toggled_cb_id); } }
static gboolean add_item_cb (PluginHandle * plugin, IfaceMenuAddState * state) { GtkWidget * item = gtk_radio_menu_item_new_with_label (state->group, aud_plugin_get_name (plugin)); state->group = gtk_radio_menu_item_get_group ((GtkRadioMenuItem *) item); if (aud_plugin_get_enabled (plugin)) gtk_check_menu_item_set_active ((GtkCheckMenuItem *) item, TRUE); gtk_menu_shell_append ((GtkMenuShell *) state->menu, item); g_signal_connect (item, "activate", (GCallback) switch_cb, plugin); gtk_widget_show (item); return TRUE; }