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;
}
