static void
empathy_mic_menu_add_microphone (EmpathyMicMenu *self,
const gchar *name,
const gchar *description,
guint source_idx,
gboolean is_monitor)
{
EmpathyMicMenuPrivate *priv = self->priv;
GtkRadioAction *action;
GSList *group;
action = gtk_radio_action_new (name, description, NULL, NULL, source_idx);
gtk_action_group_add_action_with_accel (priv->action_group,
GTK_ACTION (action), NULL);
/* Set MONITOR_KEY on the action to non-NULL if it's a monitor
* because we don't want to show monitors if we can help it. */
if (is_monitor)
{
g_object_set_data (G_OBJECT (action), MONITOR_KEY,
GUINT_TO_POINTER (TRUE));
}
group = gtk_radio_action_get_group (GTK_RADIO_ACTION (priv->anchor_action));
gtk_radio_action_set_group (GTK_RADIO_ACTION (action), group);
g_queue_push_tail (priv->microphones, action);
g_signal_connect (action, "activate",
G_CALLBACK (empathy_mic_menu_activate_cb), self);
}
static GtkAction*
add_action (const GaleonEncodingInfo *info, GaleonEncodingMenu *menu)
{
GtkAction *action;
char name[128], *tooltip;
g_snprintf (name, sizeof (name), "Encoding%s", info->encoding);
tooltip = g_strdup_printf (_("Display the page using the \"%s\" encoding"),
info->encoding);
action = g_object_new (GTK_TYPE_RADIO_ACTION,
"name", name,
"label", _(info->title),
"tooltip", tooltip,
NULL);
gtk_radio_action_set_group (GTK_RADIO_ACTION (action),
menu->priv->encodings_radio_group);
menu->priv->encodings_radio_group = gtk_radio_action_get_group
(GTK_RADIO_ACTION (action));
g_signal_connect (action, "activate",
G_CALLBACK (encoding_activate_cb),
menu);
gtk_action_group_add_action (menu->priv->action_group, action);
g_object_unref (action);
g_free (tooltip);
return action;
}
Actions::Actions(Window *window):
m_window(window)
{
m_actionGroup = gtk_action_group_new("actions");
gtk_action_group_set_translation_domain(m_actionGroup, NULL);
gtk_action_group_add_actions(m_actionGroup,
actionEntries,
N_ACTIONS,
window);
for (int i = 0; i < N_ACTIONS; ++i)
m_actions[i] = gtk_action_group_get_action(m_actionGroup,
actionEntries[i].name);
gtk_action_group_add_toggle_actions(m_actionGroup,
toggleActionEntries,
N_TOGGLE_ACTIONS,
m_window);
for (int i = 0; i < N_TOGGLE_ACTIONS; ++i)
m_toggleActions[i] = GTK_TOGGLE_ACTION(
gtk_action_group_get_action(m_actionGroup,
toggleActionEntries[i].name));
gtk_action_group_add_radio_actions(m_actionGroup,
windowLayoutEntries,
2,
Window::LAYOUT_TOOLS_PANE_RIGHT,
G_CALLBACK(changeWindowLayout),
m_window);
m_radioActionGroups[RADIO_ACTION_GROUP_WINDOW_LAYOUT] = GTK_RADIO_ACTION(
gtk_action_group_get_action(m_actionGroup,
windowLayoutEntries[0].name));
}
static void
gam_app_view_mixers_cb (GtkAction *action, GtkRadioAction *current, GamApp *gam_app)
{
GamAppPrivate *priv;
priv = GAM_APP_GET_PRIVATE (gam_app);
GamMixer *gam_mixer=gam_app_get_current_mixer(gam_app);
if(priv->view_mixers_cb_active){
int playback=TRUE;
int capture=TRUE;
switch(gtk_radio_action_get_current_value(GTK_RADIO_ACTION (action))){
case VIEW_PLAYBACK:
capture=FALSE;
break;
case VIEW_CAPTURE:
playback=FALSE;
break;
};
gam_mixer_set_capture_playback(gam_mixer, playback, capture);
}
gam_mixer_update_visibility(gam_mixer);
}
static void
activate_radio_action(GtkAction *action, GtkRadioAction *current,
gpointer data)
{
WordListWindow *window;
gboolean active;
guint value;
window = WORD_LIST_WINDOW(data);
active = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(current));
value = gtk_radio_action_get_current_value(GTK_RADIO_ACTION(current));
if (active) {
if (value != window->dictionary_type) {
GtkWidget *newwin;
newwin = word_list_window_new(value);
/* quit */
if (WORD_LIST_VIEW(WORD_LIST_WINDOW(newwin)->word_list)->dict == NULL) {
gtk_main_quit();
}
g_signal_handlers_disconnect_by_func(G_OBJECT(window),
(gpointer)(uintptr_t)dict_window_destroy_cb,
NULL);
gtk_widget_destroy(GTK_WIDGET(window));
g_signal_connect(G_OBJECT(newwin), "destroy",
G_CALLBACK(dict_window_destroy_cb), NULL);
gtk_widget_show(newwin);
}
}
}
static void annum_shell_window_change_view_cb (GtkAction *action, GtkRadioAction *current, AnnumShellWindow *self)
{
AnnumShellWindowPrivate *priv = self->priv;
const char *view_id = NULL;
switch (gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action))) {
case ANNUM_VIEW_TODAY:
annum_shell_view_goto_today (priv->shell_view);
return;
case ANNUM_VIEW_DAY:
view_id = "Day_View";
return;
case ANNUM_VIEW_WEEK:
view_id = "Week_View";
break;
case ANNUM_VIEW_MONTH:
view_id = "Month_View";
break;
default:
g_warning ("Unknown view asked for!");
break;
}
if (view_id == NULL)
return;
/* See annum-shell-backend.c's class init for the view name */
g_object_set (priv->shell_view, "view-id", view_id, NULL);
}
static void
shell_window_init_switcher_style (EShellWindow *shell_window)
{
GtkAction *action;
GSettings *settings;
GtkToolbarStyle style;
gchar *string;
settings = e_util_ref_settings ("org.gnome.evolution.shell");
action = ACTION (SWITCHER_STYLE_ICONS);
string = g_settings_get_string (settings, "buttons-style");
g_object_unref (settings);
if (string != NULL) {
if (strcmp (string, "icons") == 0)
style = GTK_TOOLBAR_ICONS;
else if (strcmp (string, "text") == 0)
style = GTK_TOOLBAR_TEXT;
else if (strcmp (string, "both") == 0)
style = GTK_TOOLBAR_BOTH_HORIZ;
else
style = -1;
gtk_radio_action_set_current_value (
GTK_RADIO_ACTION (action), style);
g_free (string);
}
g_signal_connect (
action, "changed",
G_CALLBACK (shell_window_save_switcher_style_cb),
shell_window);
}
void
liferea_shell_set_view_mode (nodeViewType newMode)
{
GtkRadioAction *action;
action = GTK_RADIO_ACTION (gtk_action_group_get_action (shell->priv->generalActions, "NormalView"));
gtk_radio_action_set_current_value (action, newMode);
}
void
block_priority_changed_handlers(ProcData *data, bool block)
{
gint i;
if (block) {
for (i = 0; i != G_N_ELEMENTS(priority_menu_entries); ++i) {
GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(data->action_group,
priority_menu_entries[i].name));
g_signal_handlers_block_by_func(action, (gpointer)cb_renice, data);
}
} else {
for (i = 0; i != G_N_ELEMENTS(priority_menu_entries); ++i) {
GtkRadioAction *action = GTK_RADIO_ACTION(gtk_action_group_get_action(data->action_group,
priority_menu_entries[i].name));
g_signal_handlers_unblock_by_func(action, (gpointer)cb_renice, data);
}
}
}
static VALUE
rbgtk_rval2gtkradioactiongslist_body(VALUE value)
{
long i;
struct rbgtk_rval2gtkradioactiongslist_args *args = (struct rbgtk_rval2gtkradioactiongslist_args *)value;
for (i = 0; i < args->n; i++)
args->result = g_slist_append(args->result, GTK_RADIO_ACTION(RVAL2GOBJ(RARRAY_PTR(args->ary)[i])));
return Qnil;
}
static void
on_document_toggled (GtkAction* action,
AnjutaDocman* docman)
{
gint n;
if (gtk_toggle_action_get_active (GTK_TOGGLE_ACTION(action)) == FALSE)
return;
n = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
gtk_notebook_set_current_page (GTK_NOTEBOOK (docman), n);
}
void
text_tool_direction_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpTextTool *text_tool = GIMP_TEXT_TOOL (data);
gint value;
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
g_object_set (text_tool->proxy,
"base-direction", (GimpTextDirection) value,
NULL);
}
static VALUE
raction_set_group(VALUE self, VALUE rbgroup)
{
GtkRadioAction *action = _SELF(self);
/* TODO: This might leak. Use gtk_radio_action_join_group() in 3.0. */
if (TYPE(rbgroup) == T_ARRAY)
gtk_radio_action_set_group(action, RVAL2GTKRADIOACTIONGSLIST(rbgroup));
else if (NIL_P(rbgroup))
gtk_radio_action_set_group(action, NULL);
else
gtk_radio_action_set_group(action,
gtk_radio_action_get_group(GTK_RADIO_ACTION(RVAL2GOBJ(rbgroup))));
return self;
}
void
quick_mask_invert_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpImage *image;
gint value;
return_if_no_image (image, data);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (value != gimp_image_get_quick_mask_inverted (image))
{
gimp_image_quick_mask_invert (image);
gimp_image_flush (image);
}
}
static void
window_actions_display_closed (GdkDisplay *display,
gboolean is_error,
GimpActionGroup *group)
{
const gchar *group_name;
gint n_screens;
gint i;
group_name = gtk_action_group_get_name (GTK_ACTION_GROUP (group));
n_screens = gdk_display_get_n_screens (display);
for (i = 0; i < n_screens; i++)
{
GdkScreen *screen = gdk_display_get_screen (display, i);
GtkAction *action;
gchar *screen_name;
gchar *action_name;
screen_name = gdk_screen_make_display_name (screen);
action_name = g_strdup_printf ("%s-move-to-screen-%s",
group_name, screen_name);
g_free (screen_name);
action = gtk_action_group_get_action (GTK_ACTION_GROUP (group),
action_name);
if (action)
{
GSList *radio_group;
radio_group = gtk_radio_action_get_group (GTK_RADIO_ACTION (action));
if (radio_group->data == (gpointer) action)
radio_group = radio_group->next;
gtk_action_group_remove_action (GTK_ACTION_GROUP (group), action);
g_object_set_data (G_OBJECT (group), "change-to-screen-radio-group",
radio_group);
}
g_free (action_name);
}
}
static void rc_plugin_tag_edit_menu_cb()
{
GtkTreeIter iter;
gchar *uri = NULL;
GtkAction *action;
action = gtk_ui_manager_get_action(rc_gui_get_ui_manager(),
"/RCMenuBar/ViewMenu/ViewPlaylist");
gtk_radio_action_set_current_value(GTK_RADIO_ACTION(action), table_id+3);
if(rc_gui_list2_get_cursor(&iter))
{
gtk_tree_model_get(rc_gui_list2_get_model(), &iter,
PLIST2_URI, &uri, -1);
if(uri!=NULL)
{
rc_plugin_tag_read_uri(uri);
g_free(uri);
}
}
}
void
nemo_window_update_show_hide_menu_items (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkAction *action;
guint current_value;
action_group = nemo_window_get_main_action_group (window);
action = gtk_action_group_get_action (action_group,
NEMO_ACTION_SHOW_HIDE_EXTRA_PANE);
gtk_toggle_action_set_active (GTK_TOGGLE_ACTION (action),
nemo_window_split_view_showing (window));
nemo_window_update_split_view_actions_sensitivity (window);
action = gtk_action_group_get_action (action_group,
"Sidebar Places");
current_value = sidebar_id_to_value (window->details->sidebar_id);
gtk_radio_action_set_current_value (GTK_RADIO_ACTION (action), current_value);
}
void
view_zoom_explicit_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpDisplayShell *shell;
gint value;
return_if_no_shell (shell, data);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (value != 0 /* not Other... */)
{
if (fabs (value - gimp_zoom_model_get_factor (shell->zoom)) > 0.0001)
gimp_display_shell_scale (shell,
GIMP_ZOOM_TO,
(gdouble) value / 10000,
GIMP_ZOOM_FOCUS_RETAIN_CENTERING_ELSE_BEST_GUESS);
}
}
static void _get_current_debug(GtkRadioAction *action)
{
static int debug_level = 0;
static slurm_ctl_conf_info_msg_t *slurm_ctl_conf_ptr = NULL;
static GtkAction *debug_action = NULL;
int err_code = get_new_info_config(&slurm_ctl_conf_ptr);
if (err_code != SLURM_ERROR)
debug_level = slurm_ctl_conf_ptr->slurmctld_debug;
if (!debug_action)
debug_action = gtk_action_group_get_action(
menu_action_group, "debug_quiet");
/* Since this is the inital value we don't signal anything
changed so we need to make it happen here */
if (debug_level == 0)
debug_inited = 1;
sview_radio_action_set_current_value(GTK_RADIO_ACTION(debug_action),
debug_level);
}
static void date_changed_cb (AnnumShellWindow *self,
GnomeCalendarViewType view,
AnnumShellView *shell_view)
{
const char *view_id;
ECalendar *date_navigator;
GDate *today;
GDate start;
GDate end;
if (view != GNOME_CAL_DAY_VIEW)
return;
/* Week_View also uses GNOME_CAL_DAY_VIEW, so make sure */
view_id = e_shell_view_get_view_id (E_SHELL_VIEW (shell_view));
if (!g_strcmp0 (view_id, "Week_View"))
return;
/* DAY_VIEW is treated specially, because we only want to have
* the button toggled if we are showing today, not any other
* day
*/
date_navigator = annum_shell_sidebar_get_date_navigator (ANNUM_SHELL_SIDEBAR (self->priv->sidebar));
today = g_date_new ();
g_date_set_time_t (today, time (NULL));
e_calendar_item_get_selection (date_navigator->calitem,
&start, &end);
if (g_date_compare (today, &start) || g_date_compare (&start, &end)) {
GtkAction *action = gtk_action_group_get_action (self->priv->action_group,
"ShowDay");
gtk_radio_action_set_current_value (GTK_RADIO_ACTION (action),
ANNUM_VIEW_DAY);
}
g_date_free (today);
}
/* gtk_radio_action_set_current_value() replacement for GTK+ < 2.10 */
void radio_action_set_current_value(GtkRadioAction *action, gint current_value)
{
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_radio_action_set_current_value(action, current_value);
#else
GSList *group;
gint value;
group = gtk_radio_action_get_group(action);
while (group)
{
action = GTK_RADIO_ACTION(group->data);
g_object_get(G_OBJECT(action), "value", &value, NULL);
if (value == current_value)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(action), TRUE);
return;
}
group = g_slist_next(group);
}
#endif
}
void
view_softproof_intent_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpDisplayShell *shell;
GimpColorConfig *color_config;
GimpColorRenderingIntent value;
return_if_no_shell (shell, data);
color_config = gimp_display_shell_get_color_config (shell);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (value != gimp_color_config_get_simulation_intent (color_config))
{
g_object_set (color_config,
"simulation-rendering-intent", value,
NULL);
shell->color_config_set = TRUE;
}
}
void
gradient_editor_right_color_type_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (data);
GimpGradient *gradient;
gint value;
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (gradient && value >= 0)
{
GimpGradientColor color_type = value;
GimpRGB color;
gimp_gradient_get_color_at (gradient,
GIMP_DATA_EDITOR (editor)->context,
editor->control_sel_r,
editor->control_sel_r->right, FALSE,
&color);
gimp_data_freeze (GIMP_DATA (gradient));
gimp_gradient_segment_set_right_color_type (gradient,
editor->control_sel_r,
color_type);
if (color_type == GIMP_GRADIENT_COLOR_FIXED)
gimp_gradient_segment_set_right_color (gradient,
editor->control_sel_r,
&color);
gimp_data_thaw (GIMP_DATA (gradient));
}
}
void
gradient_editor_coloring_type_cmd_callback (GtkAction *action,
GtkAction *current,
gpointer data)
{
GimpGradientEditor *editor = GIMP_GRADIENT_EDITOR (data);
GimpGradient *gradient;
gint value;
gradient = GIMP_GRADIENT (GIMP_DATA_EDITOR (editor)->data);
value = gtk_radio_action_get_current_value (GTK_RADIO_ACTION (action));
if (gradient && value >= 0)
{
GimpGradientSegmentColor color = value;
gimp_gradient_segment_range_set_coloring_type (gradient,
editor->control_sel_l,
editor->control_sel_r,
color);
}
}
void
cb_row_selected (GtkTreeSelection *selection, gpointer data)
{
ProcData * const procdata = static_cast<ProcData*>(data);
procdata->selection = selection;
procdata->selected_process = NULL;
/* get the most recent selected process and determine if there are
** no selected processes
*/
gtk_tree_selection_selected_foreach (procdata->selection, get_last_selected,
&procdata->selected_process);
if (procdata->selected_process) {
gint value;
gint nice = procdata->selected_process->nice;
if (nice < -7)
value = VERY_HIGH_PRIORITY;
else if (nice < -2)
value = HIGH_PRIORITY;
else if (nice < 3)
value = NORMAL_PRIORITY;
else if (nice < 7)
value = LOW_PRIORITY;
else
value = VERY_LOW_PRIORITY;
GtkRadioAction* normal = GTK_RADIO_ACTION(gtk_action_group_get_action(procdata->action_group, "Normal"));
block_priority_changed_handlers(procdata, TRUE);
gtk_radio_action_set_current_value(normal, value);
block_priority_changed_handlers(procdata, FALSE);
}
update_sensitivity(procdata);
}
GtkWidget* create_tool_item( GtkAction* action )
{
GtkWidget* item = 0;
if ( IS_EGE_SELECT_ONE_ACTION(action) && EGE_SELECT_ONE_ACTION(action)->private_data->model )
{
EgeSelectOneAction* act = EGE_SELECT_ONE_ACTION(action);
item = GTK_WIDGET( gtk_tool_item_new() );
if ( act->private_data->appearanceMode == APPEARANCE_FULL ) {
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget* holder = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_set_homogeneous(GTK_BOX(holder), FALSE);
#else
GtkWidget* holder = gtk_hbox_new( FALSE, 0 );
#endif
GtkRadioAction* ract = 0;
GSList* group = 0;
GtkTreeIter iter;
gboolean valid = FALSE;
gint index = 0;
{
gchar* sss = 0;
g_object_get( G_OBJECT(action), "short_label", &sss, NULL );
// If short_label not defined, g_object_get will return label.
// This hack allows a label to be used with a drop-down menu when
// no label is used with a set of icons that are self-explanatory.
if (sss && strcmp( sss, "NotUsed" ) != 0 ) {
GtkWidget* lbl = gtk_label_new(sss);
gtk_box_pack_start( GTK_BOX(holder), lbl, FALSE, FALSE, 4 );
}
g_free( sss );
sss = 0;
}
valid = gtk_tree_model_get_iter_first( act->private_data->model, &iter );
while ( valid ) {
gchar* str = 0;
gchar* tip = 0;
gchar* iconId = 0;
gboolean sens = true;
/*
gint size = 0;
*/
gtk_tree_model_get( act->private_data->model, &iter,
act->private_data->labelColumn, &str,
-1 );
if ( act->private_data->iconColumn >= 0 ) {
gtk_tree_model_get( act->private_data->model, &iter,
act->private_data->iconColumn, &iconId,
-1 );
}
if ( act->private_data->tooltipColumn >= 0 ) {
gtk_tree_model_get( act->private_data->model, &iter,
act->private_data->tooltipColumn, &tip,
-1 );
}
if ( act->private_data->sensitiveColumn >= 0 ) {
gtk_tree_model_get( act->private_data->model, &iter,
act->private_data->sensitiveColumn, &sens,
-1 );
}
if ( act->private_data->radioActionType ) {
void* obj = g_object_new( act->private_data->radioActionType,
"name", "Name 1",
"label", str,
"tooltip", tip,
"value", index,
/*
"iconId", iconId,
"iconSize", size,
*/
NULL );
if ( iconId ) {
g_object_set( G_OBJECT(obj), act->private_data->iconProperty, iconId, NULL );
}
if ( act->private_data->iconProperty ) {
/* TODO get this string to be set instead of hardcoded */
if ( act->private_data->iconSize >= 0 ) {
g_object_set( G_OBJECT(obj), "iconSize", act->private_data->iconSize, NULL );
}
}
ract = GTK_RADIO_ACTION(obj);
} else {
ract = gtk_radio_action_new( "Name 1", str, tip, iconId, index );
}
if ( act->private_data->sensitiveColumn >= 0 ) {
gtk_action_set_sensitive( GTK_ACTION(ract), sens );
}
gtk_radio_action_set_group( ract, group );
group = gtk_radio_action_get_group( ract );
if ( index == act->private_data->active ) {
gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(ract), TRUE );
}
g_signal_connect( G_OBJECT(ract), "changed", G_CALLBACK( proxy_action_chagned_cb ), act );
GtkWidget* sub = gtk_action_create_tool_item( GTK_ACTION(ract) );
gtk_activatable_set_related_action( GTK_ACTIVATABLE (sub), GTK_ACTION(ract) );
gtk_tool_item_set_tooltip_text( GTK_TOOL_ITEM(sub), tip );
gtk_box_pack_start( GTK_BOX(holder), sub, FALSE, FALSE, 0 );
g_free( str );
g_free( tip );
g_free( iconId );
index++;
valid = gtk_tree_model_iter_next( act->private_data->model, &iter );
}
g_object_set_data( G_OBJECT(holder), "ege-proxy_action-group", group );
gtk_container_add( GTK_CONTAINER(item), holder );
} else {
#if GTK_CHECK_VERSION(3,0,0)
GtkWidget* holder = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_set_homogeneous(GTK_BOX(holder), FALSE);
#else
GtkWidget *holder = gtk_hbox_new( FALSE, 4 );
#endif
GtkEntry *entry = 0;
GtkWidget *normal;
if (act->private_data->selectionMode == SELECTION_OPEN) {
normal = gtk_combo_box_new_with_model_and_entry (act->private_data->model);
gtk_combo_box_set_entry_text_column (GTK_COMBO_BOX (normal), act->private_data->labelColumn);
GtkWidget *child = gtk_bin_get_child( GTK_BIN(normal) );
if (GTK_IS_ENTRY(child)) {
int maxUsed = scan_max_width( act->private_data->model, act->private_data->labelColumn );
GtkEntryCompletion *complete = 0;
entry = GTK_ENTRY(child);
gtk_entry_set_width_chars(entry, maxUsed); /* replace with property */
complete = gtk_entry_completion_new();
gtk_entry_completion_set_model( complete, act->private_data->model );
gtk_entry_completion_set_text_column( complete, act->private_data->labelColumn );
gtk_entry_completion_set_inline_completion( complete, FALSE );
gtk_entry_completion_set_inline_selection( complete, FALSE );
gtk_entry_completion_set_popup_completion( complete, TRUE );
gtk_entry_completion_set_popup_set_width( complete, FALSE );
gtk_entry_set_completion( entry, complete );
g_signal_connect( G_OBJECT(child), "activate", G_CALLBACK(combo_entry_changed_cb), act );
g_signal_connect( G_OBJECT(child), "focus-out-event", G_CALLBACK(combo_entry_focus_lost_cb), act );
}
}
else {
GtkCellRenderer * renderer = NULL;
normal = gtk_combo_box_new_with_model( act->private_data->model );
if ( act->private_data->iconColumn >= 0 ) {
renderer = gtk_cell_renderer_pixbuf_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(normal), renderer, TRUE );
/* "icon-name" */
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(normal), renderer, "stock-id", act->private_data->iconColumn );
}
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start( GTK_CELL_LAYOUT(normal), renderer, TRUE );
gtk_cell_layout_add_attribute( GTK_CELL_LAYOUT(normal), renderer, "text", act->private_data->labelColumn );
}
gtk_combo_box_set_active( GTK_COMBO_BOX(normal), act->private_data->active );
if ( entry && (act->private_data->active == -1) ) {
gtk_entry_set_text( entry, act->private_data->activeText );
}
g_signal_connect( G_OBJECT(normal), "changed", G_CALLBACK(combo_changed_cb), action );
g_object_set_data( G_OBJECT(holder), "ege-combo-box", normal );
g_object_set_data( G_OBJECT(act), "ege-combo-box", normal );
if (act->private_data->appearanceMode == APPEARANCE_COMPACT) {
gchar* sss = 0;
g_object_get( G_OBJECT(action), "short_label", &sss, NULL );
if (sss) {
GtkWidget* lbl = gtk_label_new(sss);
gtk_box_pack_start( GTK_BOX(holder), lbl, FALSE, FALSE, 4 );
g_free( sss );
sss = 0;
}
}
gtk_box_pack_start( GTK_BOX(holder), normal, FALSE, FALSE, 0 );
{
#if GTK_CHECK_VERSION(3,0,0)
gtk_widget_set_halign(holder, GTK_ALIGN_START);
gtk_container_add(GTK_CONTAINER(item), holder);
#else
GtkWidget *align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add( GTK_CONTAINER(align), holder);
gtk_container_add( GTK_CONTAINER(item), align );
#endif
}
}
gtk_widget_show_all( item );
} else {
item = GTK_ACTION_CLASS(ege_select_one_action_parent_class)->create_tool_item( action );
}
return item;
}
void
gtkhtml_editor_private_constructed (GtkhtmlEditor *editor)
{
GtkhtmlEditorPrivate *priv = editor->priv;
GtkHTML *html;
GtkWidget *widget;
GtkToolbar *toolbar;
GtkToolItem *tool_item;
/* Construct main window widgets. */
widget = gtkhtml_editor_get_managed_widget (editor, "/main-menu");
gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0);
priv->main_menu = g_object_ref (widget);
gtk_widget_show (widget);
widget = gtkhtml_editor_get_managed_widget (editor, "/main-toolbar");
gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0);
priv->main_toolbar = g_object_ref (widget);
gtk_widget_show (widget);
widget = gtkhtml_editor_get_managed_widget (editor, "/edit-toolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (widget), GTK_TOOLBAR_BOTH_HORIZ);
gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0);
priv->edit_toolbar = g_object_ref (widget);
gtk_widget_show (widget);
widget = gtkhtml_editor_get_managed_widget (editor, "/html-toolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (widget), GTK_TOOLBAR_BOTH_HORIZ);
gtk_box_pack_start (GTK_BOX (editor->vbox), widget, FALSE, FALSE, 0);
priv->html_toolbar = g_object_ref (widget);
gtk_widget_show (widget);
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (
GTK_SCROLLED_WINDOW (widget), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (editor->vbox), widget, TRUE, TRUE, 0);
priv->scrolled_window = g_object_ref (widget);
gtk_widget_show (widget);
widget = GTK_WIDGET (gtkhtml_editor_get_html (editor));
gtk_container_add (GTK_CONTAINER (priv->scrolled_window), widget);
gtk_widget_show (widget);
/* Add some combo boxes to the "edit" toolbar. */
toolbar = GTK_TOOLBAR (priv->edit_toolbar);
tool_item = gtk_tool_item_new ();
widget = gtkhtml_combo_box_new_with_action (
GTK_RADIO_ACTION (ACTION (STYLE_NORMAL)));
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), FALSE);
gtk_container_add (GTK_CONTAINER (tool_item), widget);
gtk_widget_set_tooltip_text (widget, _("Paragraph Style"));
gtk_toolbar_insert (toolbar, tool_item, 0);
priv->style_combo_box = g_object_ref (widget);
gtk_widget_show_all (GTK_WIDGET (tool_item));
tool_item = gtk_separator_tool_item_new ();
gtk_toolbar_insert (toolbar, tool_item, 0);
gtk_widget_show_all (GTK_WIDGET (tool_item));
tool_item = gtk_tool_item_new ();
widget = gtkhtml_combo_box_new_with_action (
GTK_RADIO_ACTION (ACTION (MODE_HTML)));
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), FALSE);
gtk_container_add (GTK_CONTAINER (tool_item), widget);
gtk_widget_set_tooltip_text (widget, _("Editing Mode"));
gtk_toolbar_insert (toolbar, tool_item, 0);
priv->mode_combo_box = g_object_ref (widget);
gtk_widget_show_all (GTK_WIDGET (tool_item));
/* Add some combo boxes to the "html" toolbar. */
toolbar = GTK_TOOLBAR (priv->html_toolbar);
tool_item = gtk_tool_item_new ();
widget = gtkhtml_color_combo_new ();
gtk_container_add (GTK_CONTAINER (tool_item), widget);
gtk_widget_set_tooltip_text (widget, _("Font Color"));
gtk_toolbar_insert (toolbar, tool_item, 0);
priv->color_combo_box = g_object_ref (widget);
gtk_widget_show_all (GTK_WIDGET (tool_item));
tool_item = gtk_tool_item_new ();
widget = gtkhtml_combo_box_new_with_action (
GTK_RADIO_ACTION (ACTION (SIZE_PLUS_ZERO)));
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (widget), FALSE);
gtk_container_add (GTK_CONTAINER (tool_item), widget);
gtk_widget_set_tooltip_text (widget, _("Font Size"));
gtk_toolbar_insert (toolbar, tool_item, 0);
priv->size_combo_box = g_object_ref (widget);
gtk_widget_show_all (GTK_WIDGET (tool_item));
/* Initialize painters (requires "edit_area"). */
html = gtkhtml_editor_get_html (editor);
gtk_widget_ensure_style (GTK_WIDGET (html));
priv->html_painter = g_object_ref (html->engine->painter);
priv->plain_painter = html_plain_painter_new (priv->edit_area, TRUE);
/* Add input methods to the context menu. */
widget = gtkhtml_editor_get_managed_widget (
editor, "/context-menu/context-input-methods-menu");
widget = gtk_menu_item_get_submenu (GTK_MENU_ITEM (widget));
gtk_im_multicontext_append_menuitems (
GTK_IM_MULTICONTEXT (html->priv->im_context),
GTK_MENU_SHELL (widget));
/* Configure color stuff. */
priv->palette = gtkhtml_color_palette_new ();
priv->text_color = gtkhtml_color_state_new ();
gtkhtml_color_state_set_default_label (
priv->text_color, _("Automatic"));
gtkhtml_color_state_set_palette (
priv->text_color, priv->palette);
/* Text color widgets share state. */
widget = priv->color_combo_box;
gtkhtml_color_combo_set_state (
GTKHTML_COLOR_COMBO (widget), priv->text_color);
widget = WIDGET (TEXT_PROPERTIES_COLOR_COMBO);
gtkhtml_color_combo_set_state (
GTKHTML_COLOR_COMBO (widget), priv->text_color);
/* These color widgets share a custom color palette. */
widget = WIDGET (CELL_PROPERTIES_COLOR_COMBO);
gtkhtml_color_combo_set_palette (
GTKHTML_COLOR_COMBO (widget), priv->palette);
widget = WIDGET (PAGE_PROPERTIES_BACKGROUND_COLOR_COMBO);
gtkhtml_color_combo_set_palette (
GTKHTML_COLOR_COMBO (widget), priv->palette);
widget = WIDGET (PAGE_PROPERTIES_LINK_COLOR_COMBO);
gtkhtml_color_combo_set_palette (
GTKHTML_COLOR_COMBO (widget), priv->palette);
widget = WIDGET (TABLE_PROPERTIES_COLOR_COMBO);
gtkhtml_color_combo_set_palette (
GTKHTML_COLOR_COMBO (widget), priv->palette);
}
void
e_task_shell_view_update_search_filter (ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EActionComboBox *combo_box;
GtkActionGroup *action_group;
GtkRadioAction *radio_action;
GList *list, *iter;
GSList *group;
gint ii;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
action_group = ACTION_GROUP (TASKS_FILTER);
e_action_group_remove_all_actions (action_group);
/* Add the standard filter actions. No callback is needed
* because changes in the EActionComboBox are detected and
* handled by EShellSearchbar. */
gtk_action_group_add_radio_actions (
action_group, task_filter_entries,
G_N_ELEMENTS (task_filter_entries),
TASK_FILTER_ANY_CATEGORY, NULL, NULL);
/* Retrieve the radio group from an action we just added. */
list = gtk_action_group_list_actions (action_group);
radio_action = GTK_RADIO_ACTION (list->data);
group = gtk_radio_action_get_group (radio_action);
g_list_free (list);
/* Build the category actions. */
list = e_util_dup_searchable_categories ();
for (iter = list, ii = 0; iter != NULL; iter = iter->next, ii++) {
const gchar *category_name = iter->data;
gchar *filename;
GtkAction *action;
gchar *action_name;
action_name = g_strdup_printf (
"task-filter-category-%d", ii);
radio_action = gtk_radio_action_new (
action_name, category_name, NULL, NULL, ii);
g_free (action_name);
/* Convert the category icon file to a themed icon name. */
filename = e_categories_dup_icon_file_for (category_name);
if (filename != NULL && *filename != '\0') {
gchar *basename;
gchar *cp;
basename = g_path_get_basename (filename);
/* Lose the file extension. */
if ((cp = strrchr (basename, '.')) != NULL)
*cp = '\0';
g_object_set (
radio_action, "icon-name", basename, NULL);
g_free (basename);
}
g_free (filename);
gtk_radio_action_set_group (radio_action, group);
group = gtk_radio_action_get_group (radio_action);
/* The action group takes ownership of the action. */
action = GTK_ACTION (radio_action);
gtk_action_group_add_action (action_group, action);
g_object_unref (radio_action);
}
g_list_free_full (list, g_free);
task_shell_content = task_shell_view->priv->task_shell_content;
searchbar = e_task_shell_content_get_searchbar (task_shell_content);
combo_box = e_shell_searchbar_get_filter_combo_box (searchbar);
e_shell_view_block_execute_search (shell_view);
/* Use any action in the group; doesn't matter which. */
e_action_combo_box_set_action (combo_box, radio_action);
ii = TASK_FILTER_UNMATCHED;
e_action_combo_box_add_separator_after (combo_box, ii);
ii = TASK_FILTER_TASKS_WITH_ATTACHMENTS;
e_action_combo_box_add_separator_after (combo_box, ii);
e_shell_view_unblock_execute_search (shell_view);
}
void
e_task_shell_view_actions_init (ETaskShellView *task_shell_view)
{
ETaskShellContent *task_shell_content;
EShellView *shell_view;
EShellWindow *shell_window;
EShellSearchbar *searchbar;
EPreviewPane *preview_pane;
EWebView *web_view;
GtkActionGroup *action_group;
GSettings *settings;
GtkAction *action;
shell_view = E_SHELL_VIEW (task_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
task_shell_content = task_shell_view->priv->task_shell_content;
searchbar = e_task_shell_content_get_searchbar (task_shell_content);
preview_pane = e_task_shell_content_get_preview_pane (task_shell_content);
web_view = e_preview_pane_get_web_view (preview_pane);
/* Task Actions */
action_group = ACTION_GROUP (TASKS);
gtk_action_group_add_actions (
action_group, task_entries,
G_N_ELEMENTS (task_entries), task_shell_view);
e_action_group_add_popup_actions (
action_group, task_popup_entries,
G_N_ELEMENTS (task_popup_entries));
gtk_action_group_add_toggle_actions (
action_group, task_toggle_entries,
G_N_ELEMENTS (task_toggle_entries), task_shell_view);
gtk_action_group_add_radio_actions (
action_group, task_view_entries,
G_N_ELEMENTS (task_view_entries), -1,
G_CALLBACK (action_task_view_cb), task_shell_view);
gtk_action_group_add_radio_actions (
action_group, task_search_entries,
G_N_ELEMENTS (task_search_entries),
-1, NULL, NULL);
/* Advanced Search Action */
action = ACTION (TASK_SEARCH_ADVANCED_HIDDEN);
gtk_action_set_visible (action, FALSE);
e_shell_searchbar_set_search_option (
searchbar, GTK_RADIO_ACTION (action));
/* Lockdown Printing Actions */
action_group = ACTION_GROUP (LOCKDOWN_PRINTING);
gtk_action_group_add_actions (
action_group, lockdown_printing_entries,
G_N_ELEMENTS (lockdown_printing_entries),
task_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_printing_popup_entries,
G_N_ELEMENTS (lockdown_printing_popup_entries));
/* Lockdown Save-to-Disk Actions */
action_group = ACTION_GROUP (LOCKDOWN_SAVE_TO_DISK);
gtk_action_group_add_actions (
action_group, lockdown_save_to_disk_entries,
G_N_ELEMENTS (lockdown_save_to_disk_entries),
task_shell_view);
e_action_group_add_popup_actions (
action_group, lockdown_save_to_disk_popup_entries,
G_N_ELEMENTS (lockdown_save_to_disk_popup_entries));
/* Bind GObject properties to settings keys. */
settings = g_settings_new ("org.gnome.evolution.calendar");
g_settings_bind (
settings, "show-task-preview",
ACTION (TASK_PREVIEW), "active",
G_SETTINGS_BIND_DEFAULT);
g_settings_bind (
settings, "task-layout",
ACTION (TASK_VIEW_VERTICAL), "current-value",
G_SETTINGS_BIND_DEFAULT);
g_object_unref (settings);
/* Fine tuning. */
g_object_bind_property (
ACTION (TASK_PREVIEW), "active",
ACTION (TASK_VIEW_CLASSIC), "sensitive",
G_BINDING_SYNC_CREATE);
g_object_bind_property (
ACTION (TASK_PREVIEW), "active",
ACTION (TASK_VIEW_VERTICAL), "sensitive",
G_BINDING_SYNC_CREATE);
e_web_view_set_open_proxy (web_view, ACTION (TASK_OPEN));
e_web_view_set_print_proxy (web_view, ACTION (TASK_PRINT));
e_web_view_set_save_as_proxy (web_view, ACTION (TASK_SAVE_AS));
}
void
nezet_menu(GtkAction *action, gint melyik, gpointer data)
{
gtk_notebook_set_current_page(GTK_NOTEBOOK(book), gtk_radio_action_get_current_value(GTK_RADIO_ACTION(action)) - 1);
}
