void make_toolbar(Viewer *viewer, GtkWidget *parent)
{
GtkWidget *toolbar = gtk_toolbar_new();
gtk_box_pack_start(GTK_BOX(parent), toolbar, FALSE, FALSE, 0);
// add a recording button to the toolbar
viewer->record_button = GTK_WIDGET(
gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_RECORD));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (viewer->record_button),
TRUE);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (viewer->record_button),
viewer->tips,
"Record an AVI of the viewport, saved in the current directory",
NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (viewer->record_button), 0);
gtk_widget_show (viewer->record_button);
g_signal_connect (G_OBJECT (viewer->record_button), "toggled",
G_CALLBACK (on_record_toggled), viewer);
// screenshot button
GtkToolItem *ssbt = gtk_tool_button_new_from_stock (GTK_STOCK_FLOPPY);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (ssbt), "Screenshot");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (ssbt), TRUE);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (ssbt), viewer->tips,
"Save a PPM screenshot of the viewport to the current directory",
NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), ssbt, 1);
gtk_widget_show (GTK_WIDGET (ssbt));
g_signal_connect (G_OBJECT (ssbt), "clicked",
G_CALLBACK (on_screenshot_clicked), viewer);
// quit button
GtkToolItem *quitbt = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (quitbt), viewer->tips,
"Quit", NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), quitbt, 2);
gtk_widget_show (GTK_WIDGET (quitbt));
g_signal_connect (G_OBJECT (quitbt), "clicked", gtk_main_quit, NULL);
GtkToolItem * sep = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (sep));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), sep, 3);
GtkWidget * hbox = gtk_hbox_new (FALSE, 5);
GtkWidget * label = gtk_label_new ("Record FPS");
gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
viewer->fps_spin = gtk_spin_button_new_with_range (0.1, 120.0, 1.0);
gtk_spin_button_set_digits (GTK_SPIN_BUTTON (viewer->fps_spin), 1);
gtk_spin_button_set_value (GTK_SPIN_BUTTON (viewer->fps_spin), 30);
gtk_box_pack_start (GTK_BOX (hbox), viewer->fps_spin, FALSE, FALSE, 0);
GtkToolItem * toolitem = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (toolitem), hbox);
gtk_widget_show_all (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 4);
viewer->toolbar = GTK_TOOLBAR (toolbar);
}
static void
page_holder_app_add_browser_cb (MidoriApp* app,
MidoriBrowser* browser,
MidoriExtension* extension)
{
GtkWidget* panel;
GtkWidget* notebook;
GtkWidget* toolbar;
GtkToolItem* toolitem;
panel = katze_object_get_object (browser, "panel");
notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_RIGHT);
gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE);
gtk_widget_show (notebook);
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON);
gtk_widget_show (toolbar);
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_JUMP_TO);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (page_holder_button_jump_to_clicked_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
toolitem = gtk_separator_tool_item_new ();
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE);
gtk_tool_item_set_expand (toolitem, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
gtk_widget_show (GTK_WIDGET (toolitem));
toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD);
gtk_tool_item_set_is_important (toolitem, TRUE);
g_signal_connect (toolitem, "clicked",
G_CALLBACK (page_holder_button_add_clicked_cb), notebook);
gtk_widget_show (GTK_WIDGET (toolitem));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1);
midori_panel_append_widget (MIDORI_PANEL (panel), notebook,
/* i18n: A panel showing a user specified web page */
STOCK_PAGE_HOLDER, _("Pageholder"), toolbar);
g_signal_connect (extension, "deactivate",
G_CALLBACK (page_holder_deactivate_cb), notebook);
g_object_unref (panel);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkToolItem_gtk_1tool_1item_1set_1is_1important
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _isImportant
)
{
GtkToolItem* self;
gboolean isImportant;
// convert parameter self
self = (GtkToolItem*) _self;
// convert parameter isImportant
isImportant = (gboolean) _isImportant;
// call function
gtk_tool_item_set_is_important(self, isImportant);
// cleanup parameter self
// cleanup parameter isImportant
}
static void
gtk_tool_item_update (GtkActivatable *activatable,
GtkAction *action,
const gchar *property_name)
{
if (strcmp (property_name, "visible") == 0)
{
if (gtk_action_is_visible (action))
gtk_widget_show (GTK_WIDGET (activatable));
else
gtk_widget_hide (GTK_WIDGET (activatable));
}
else if (strcmp (property_name, "sensitive") == 0)
gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));
else if (strcmp (property_name, "tooltip") == 0)
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (activatable),
gtk_action_get_tooltip (action));
else if (strcmp (property_name, "visible-horizontal") == 0)
gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (activatable),
gtk_action_get_visible_horizontal (action));
else if (strcmp (property_name, "visible-vertical") == 0)
gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (activatable),
gtk_action_get_visible_vertical (action));
else if (strcmp (property_name, "is-important") == 0)
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (activatable),
gtk_action_get_is_important (action));
}
static void
gtk_tool_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (object);
switch (prop_id)
{
case PROP_VISIBLE_HORIZONTAL:
gtk_tool_item_set_visible_horizontal (toolitem, g_value_get_boolean (value));
break;
case PROP_VISIBLE_VERTICAL:
gtk_tool_item_set_visible_vertical (toolitem, g_value_get_boolean (value));
break;
case PROP_IS_IMPORTANT:
gtk_tool_item_set_is_important (toolitem, g_value_get_boolean (value));
break;
case PROP_ACTIVATABLE_RELATED_ACTION:
gtk_tool_item_set_related_action (toolitem, g_value_get_object (value));
break;
case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE:
gtk_tool_item_set_use_action_appearance (toolitem, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_tool_item_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gboolean visible_horz, visible_vert, is_important;
visible_horz = gb_widget_input_bool (data, VisibleHorz);
if (data->apply)
{
gtk_object_set_data (GTK_OBJECT (widget), VisibleHorz,
visible_horz ? NULL : "FALSE");
}
visible_vert = gb_widget_input_bool (data, VisibleVert);
if (data->apply)
{
gtk_object_set_data (GTK_OBJECT (widget), VisibleVert,
visible_vert ? NULL : "FALSE");
}
is_important = gb_widget_input_bool (data, IsImportant);
if (data->apply)
{
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (widget), is_important);
}
}
GtkWidget *
gtk_utils_append_toolbar_button (GtkToolbar *toolbar,
GtkUtilsToolbarEntry *entry,
GtkUtilsToolbarButtonFlags flags,
gpointer user_data)
{
#if GTK_2_4_OR_LATER
GtkToolItem *button;
g_return_val_if_fail (entry, NULL);
button = gtk_tool_button_new ((gtk_image_new_from_stock
(entry->icon_stock_id,
gtk_toolbar_get_icon_size (toolbar))),
(entry->label_text
? _(entry->label_text) : NULL));
if (entry->tooltip_text) {
gtk_tool_item_set_tooltip (button, toolbar->tooltips,
_(entry->tooltip_text), NULL);
}
gtk_tool_item_set_homogeneous (button, ((flags & GTK_UTILS_HOMOGENEOUS)
? TRUE : FALSE));
gtk_tool_item_set_is_important (button, ((flags & GTK_UTILS_IS_IMPORTANT)
? TRUE : FALSE));
g_signal_connect (button, "clicked",
G_CALLBACK (invoke_toolbar_button_callback), user_data);
gtk_toolbar_insert (toolbar, button, -1);
#else
GtkWidget *button;
g_return_val_if_fail (entry, NULL);
UNUSED (flags);
button = (gtk_toolbar_append_item
(toolbar, (entry->label_text ? _(entry->label_text) : NULL),
_(entry->tooltip_text), NULL,
gtk_image_new_from_stock (entry->icon_stock_id,
gtk_toolbar_get_icon_size (toolbar)),
(GtkSignalFunc) invoke_toolbar_button_callback, user_data));
#endif
if (!toolbar_button_entry_quark) {
toolbar_button_entry_quark
= g_quark_from_static_string ("quarry-toolbar-button-entry");
}
g_object_set_qdata (G_OBJECT (button), toolbar_button_entry_quark, entry);
/* For GTK+ 2.4 and up. It is certainly a widget. */
return (GtkWidget *) button;
}
void
edit_metadata__gth_browser_construct_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
g_return_if_fail (GTH_IS_BROWSER (browser));
data = g_new0 (BrowserData, 1);
data->browser = browser;
data->actions = gtk_action_group_new ("Edit Metadata Actions");
gtk_action_group_set_translation_domain (data->actions, NULL);
gtk_action_group_add_actions (data->actions,
edit_metadata_action_entries,
G_N_ELEMENTS (edit_metadata_action_entries),
browser);
gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->actions, 0);
if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) {
g_message ("building menus failed: %s", error->message);
g_error_free (error);
}
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/Fullscreen_ToolBar/Edit_Actions/Edit_Metadata")), TRUE);
g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free);
}
static void cm_create_toolbar(CookieManagerPage *cmp)
{
CookieManagerPagePrivate *priv = cmp->priv;
GtkWidget *toolbar;
GtkToolItem *toolitem;
priv->toolbar = toolbar = gtk_toolbar_new();
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
gtk_tool_item_set_is_important(toolitem, TRUE);
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_button_delete_clicked_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->delete_button = GTK_WIDGET(toolitem);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE);
gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("Delete All"));
gtk_tool_item_set_tooltip_text(toolitem,
_("Deletes all shown cookies. "
"If a filter is set, only those cookies are deleted which match the filter."));
gtk_tool_item_set_is_important(toolitem, TRUE);
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_button_delete_all_clicked_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->delete_all_button = GTK_WIDGET(toolitem);
toolitem = gtk_separator_tool_item_new();
gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE);
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_widget_show(GTK_WIDGET(toolitem));
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_ADD);
gtk_tool_item_set_tooltip_text(toolitem, _("Expand All"));
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_tree_popup_expand_activate_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->expand_buttons[0] = GTK_WIDGET(toolitem);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_REMOVE);
gtk_tool_item_set_tooltip_text(toolitem, _("Collapse All"));
g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_tree_popup_collapse_activate_cb), cmp);
gtk_widget_show(GTK_WIDGET(toolitem));
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
priv->expand_buttons[1] = GTK_WIDGET(toolitem);
}
static void
load_stock_items (GtkToolPalette *palette)
{
GtkWidget *group_af = gtk_tool_item_group_new ("Stock Icons (A-F)");
GtkWidget *group_gn = gtk_tool_item_group_new ("Stock Icons (G-N)");
GtkWidget *group_or = gtk_tool_item_group_new ("Stock Icons (O-R)");
GtkWidget *group_sz = gtk_tool_item_group_new ("Stock Icons (S-Z)");
GtkWidget *group = NULL;
GtkToolItem *item;
GSList *stock_ids;
GSList *iter;
stock_ids = gtk_stock_list_ids ();
stock_ids = g_slist_sort (stock_ids, (GCompareFunc) strcmp);
gtk_container_add (GTK_CONTAINER (palette), group_af);
gtk_container_add (GTK_CONTAINER (palette), group_gn);
gtk_container_add (GTK_CONTAINER (palette), group_or);
gtk_container_add (GTK_CONTAINER (palette), group_sz);
for (iter = stock_ids; iter; iter = g_slist_next (iter))
{
GtkStockItem stock_item;
gchar *id = iter->data;
switch (id[4])
{
case 'a':
group = group_af;
break;
case 'g':
group = group_gn;
break;
case 'o':
group = group_or;
break;
case 's':
group = group_sz;
break;
}
item = gtk_tool_button_new_from_stock (id);
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (item), TRUE);
gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
if (!gtk_stock_lookup (id, &stock_item) || !stock_item.label)
gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), id);
g_free (id);
}
g_slist_free (stock_ids);
}
void
edit_metadata__gth_browser_set_current_page_cb (GthBrowser *browser)
{
BrowserData *data;
GError *error = NULL;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
g_return_if_fail (data != NULL);
switch (gth_window_get_current_page (GTH_WINDOW (browser))) {
case GTH_BROWSER_PAGE_BROWSER:
if (data->viewer_ui_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->viewer_ui_merge_id);
data->viewer_ui_merge_id = 0;
}
if (data->browser_ui_merge_id != 0)
return;
data->browser_ui_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), browser_ui_info, -1, &error);
if (data->browser_ui_merge_id == 0) {
g_warning ("ui building failed: %s", error->message);
g_clear_error (&error);
}
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/ToolBar/Edit_Actions/Edit_Metadata")), TRUE);
break;
case GTH_BROWSER_PAGE_VIEWER:
if (data->browser_ui_merge_id != 0) {
gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->browser_ui_merge_id);
data->browser_ui_merge_id = 0;
}
if (data->viewer_ui_merge_id != 0)
return;
data->viewer_ui_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), viewer_ui_info, -1, &error);
if (data->viewer_ui_merge_id == 0) {
g_warning ("ui building failed: %s", error->message);
g_clear_error (&error);
}
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/ViewerToolBar/Edit_Actions/Edit_Metadata")), TRUE);
break;
default:
break;
}
}
static void add_button(gpointer compose)
{
GtkWidget *toolbar;
PrefsCommon *prefs;
gint n = 0;
GtkToolItem *item;
GtkWidget *icon;
GdkPixbuf *pixbuf;
if (!config.enable_autoenc) {
debug_print("autoenc: autoenc is disabled\n");
return;
}
toolbar = syl_plugin_compose_get_toolbar(compose);
//n = gtk_toolbar_get_n_items(GTK_TOOLBAR(toolbar));
prefs = prefs_common_get();
if (prefs->compose_toolbar_setting) {
gint i;
gchar **namev;
namev = g_strsplit(prefs->compose_toolbar_setting, ",", -1);
for (i = 0; namev[i] != NULL; i++) {
if (!strcmp(namev[i], "send")) {
debug_print("send pos: %d\n", i);
n = i + 1;
break;
}
}
g_strfreev(namev);
} else {
/* send,send-later,draft,... */
n = 1;
}
//icon = stock_pixbuf_widget_for_toolbar(STOCK_PIXMAP_MAIL_SEND);
pixbuf = gdk_pixbuf_new_from_inline(sizeof(send_enc), send_enc,
FALSE, NULL);
icon = gtk_image_new_from_pixbuf(pixbuf);
item = gtk_tool_button_new(icon, _("Send with encryption"));
gtk_tool_item_set_is_important(item, TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, n);
//gtk_widget_show_all(GTK_WIDGET(toolbar));
gtk_widget_show_all(GTK_WIDGET(item));
g_object_set_data(G_OBJECT(toolbar), "send-enc-button", item);
g_signal_connect(G_OBJECT(item), "clicked",
G_CALLBACK(send_encryption_clicked), compose);
change_button_sensitive(compose, GTK_WIDGET(item));
}
GtkWidget *hwidget_get_toggle_toolbar(HviewWidgetsT *w)
{
GtkWidget *bar;
GtkToolItem *but;
bar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(bar), GTK_TOOLBAR_BOTH_HORIZ);
but = hwidget_get_tool_button("message_log.png", "Messages", NULL,
hview_toggled_call, w,
HWIDGET_TOGGLE_TOOL_BUTTON);
gtk_tool_item_set_is_important(GTK_TOOL_ITEM(but), TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(bar), but, -1);
but = hwidget_get_tool_button("event_log.png", "Events", NULL,
hview_toggled_call, w,
HWIDGET_TOGGLE_TOOL_BUTTON);
gtk_tool_item_set_is_important(GTK_TOOL_ITEM(but), TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(bar), but, -1);
return bar;
}
static void
important_toggled(GtkCellRendererToggle *cell, const gchar *path_str,
GtkTreeModel *model)
{
GtkTreePath *path;
GtkTreeIter iter;
GtkToolItem *tool_item;
path = gtk_tree_path_new_from_string (path_str);
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, 0, &tool_item, -1);
gtk_tool_item_set_is_important (tool_item, !gtk_tool_item_get_is_important (tool_item));
g_object_unref (tool_item);
gtk_tree_model_row_changed (model, path, &iter);
gtk_tree_path_free (path);
}
void
gu_textwindow_init(GuTextwindow *window) {
window->priv = G_TYPE_INSTANCE_GET_PRIVATE(window, GU_TYPE_TEXTWINDOW, GuTextwindowPrivate);
GuTextwindowPrivate *priv = window->priv;
gtk_window_set_default_size(GTK_WINDOW(window), 400, 300);
gtk_window_set_title(GTK_WINDOW(window), "Text File Viewer");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
g_signal_connect(GTK_WIDGET(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
/* Toolbar */
GtkWidget* toolbar = gtk_toolbar_new();
GtkStyleContext* style_context = gtk_widget_get_style_context(toolbar);
gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
GtkToolItem* open_btn = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN);
gtk_tool_item_set_is_important(open_btn, TRUE);
g_signal_connect( GTK_WIDGET(open_btn), "clicked", G_CALLBACK(on_open_clicked), (gpointer)window);
gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(open_btn));
/* TextView */
priv->text_view = GTK_TEXT_VIEW(gtk_text_view_new());
gtk_text_view_set_editable(priv->text_view, FALSE);
gtk_text_view_set_cursor_visible(priv->text_view, FALSE);
/* ScrollView */
GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(priv->text_view));
/* Packing */
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(box), toolbar, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(window), box);
}
GtkWidget *
create_toolbar (void)
{
GtkWidget *toolbar;
GtkToolItem *item;
toolbar = gtk_toolbar_new ();
gtk_widget_set_valign (toolbar, GTK_ALIGN_CENTER);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, NULL);
gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous");
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
item = gtk_tool_button_new (NULL, "Hello World");
gtk_tool_item_set_is_important (item, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
return toolbar;
}
static void
gtk_tool_item_sync_action_properties (GtkActivatable *activatable,
GtkAction *action)
{
if (!action)
return;
if (gtk_action_is_visible (action))
gtk_widget_show (GTK_WIDGET (activatable));
else
gtk_widget_hide (GTK_WIDGET (activatable));
gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action));
gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (activatable),
gtk_action_get_tooltip (action));
gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (activatable),
gtk_action_get_visible_horizontal (action));
gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (activatable),
gtk_action_get_visible_vertical (action));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (activatable),
gtk_action_get_is_important (action));
}
static void
gtk_tool_item_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GtkToolItem *toolitem = GTK_TOOL_ITEM (object);
switch (prop_id)
{
case PROP_VISIBLE_HORIZONTAL:
gtk_tool_item_set_visible_horizontal (toolitem, g_value_get_boolean (value));
break;
case PROP_VISIBLE_VERTICAL:
gtk_tool_item_set_visible_vertical (toolitem, g_value_get_boolean (value));
break;
case PROP_IS_IMPORTANT:
gtk_tool_item_set_is_important (toolitem, g_value_get_boolean (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gint
tm_set_tool_item_label(GtkToolItem * tool_item, const gchar * stock_id,
gboolean make_two_line)
{
gint button = get_toolbar_button_index(stock_id);
const gchar *text;
gchar *label;
if (button < 0)
return button;
text = balsa_toolbar_button_text(button);
if (balsa_app.toolbar_wrap_button_text) {
/* Make sure all buttons have the same number of lines of
* text (1 or 2), to keep icons aligned */
label = make_two_line && !strchr(text, '\n') ?
g_strconcat(text, "\n", NULL) : g_strdup(text);
} else {
gchar *p = label = g_strdup(text);
while ((p = strchr(p, '\n')))
*p++ = ' ';
}
gtk_tool_button_set_label(GTK_TOOL_BUTTON(tool_item), label);
g_free(label);
gtk_tool_item_set_is_important(tool_item,
toolbar_buttons[button].is_important);
if (strcmp(toolbar_buttons[button].pixmap_id, BALSA_PIXMAP_SEND) == 0
&& balsa_app.always_queue_sent_mail)
gtk_tool_item_set_tooltip_text(tool_item,
_("Queue this message for sending"));
return button;
}
static void
egg_find_bar_init (EggFindBar *find_bar)
{
EggFindBarPrivate *priv;
GtkWidget *label;
GtkWidget *alignment;
GtkWidget *box;
GtkToolItem *item;
GtkWidget *arrow;
/* Data */
priv = EGG_FIND_BAR_GET_PRIVATE (find_bar);
find_bar->priv = priv;
priv->search_string = NULL;
gtk_toolbar_set_style (GTK_TOOLBAR (find_bar), GTK_TOOLBAR_BOTH_HORIZ);
/* Find: |_____| */
item = gtk_tool_item_new ();
box = gtk_hbox_new (FALSE, 12);
alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2);
label = gtk_label_new_with_mnemonic (_("Find:"));
priv->find_entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (priv->find_entry), 32);
gtk_entry_set_max_length (GTK_ENTRY (priv->find_entry), 512);
gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry);
/* Prev */
arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);
priv->previous_button = gtk_tool_button_new (arrow, Q_("Find Previous"));
gtk_tool_item_set_is_important (priv->previous_button, TRUE);
gtk_tool_item_set_tooltip (priv->previous_button, GTK_TOOLBAR (find_bar)->tooltips,
_("Find previous occurrence of the search string"),
NULL);
/* Next */
arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
priv->next_button = gtk_tool_button_new (arrow, Q_("Find Next"));
gtk_tool_item_set_is_important (priv->next_button, TRUE);
gtk_tool_item_set_tooltip (priv->next_button, GTK_TOOLBAR (find_bar)->tooltips,
_("Find next occurrence of the search string"),
NULL);
/* Separator*/
priv->status_separator = gtk_separator_tool_item_new();
/* Case button */
priv->case_button = gtk_toggle_tool_button_new ();
g_object_set (G_OBJECT (priv->case_button), "label", _("C_ase Sensitive"), NULL);
gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->case_button), TRUE);
gtk_tool_item_set_is_important (priv->case_button, TRUE);
gtk_tool_item_set_tooltip (priv->case_button, GTK_TOOLBAR (find_bar)->tooltips,
_("Toggle case sensitive search"),
NULL);
/* Status */
priv->status_item = gtk_tool_item_new();
gtk_tool_item_set_expand (priv->status_item, TRUE);
priv->status_label = gtk_label_new (NULL);
gtk_label_set_ellipsize (GTK_LABEL (priv->status_label),
PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5);
g_signal_connect (priv->find_entry, "changed",
G_CALLBACK (entry_changed_callback),
find_bar);
g_signal_connect (priv->find_entry, "activate",
G_CALLBACK (entry_activate_callback),
find_bar);
g_signal_connect (priv->next_button, "clicked",
G_CALLBACK (next_clicked_callback),
find_bar);
g_signal_connect (priv->previous_button, "clicked",
G_CALLBACK (previous_clicked_callback),
find_bar);
g_signal_connect (priv->case_button, "toggled",
G_CALLBACK (case_sensitive_toggled_callback),
find_bar);
gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), priv->find_entry, TRUE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (alignment), box);
gtk_container_add (GTK_CONTAINER (item), alignment);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), item, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->previous_button, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->next_button, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->case_button, -1);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_separator, -1);
gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label);
gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_item, -1);
/* don't show status separator/label until they are set */
gtk_widget_show_all (GTK_WIDGET (item));
gtk_widget_show_all (GTK_WIDGET (priv->next_button));
gtk_widget_show_all (GTK_WIDGET (priv->previous_button));
gtk_widget_show (priv->status_label);
}
GtkWidget *
empathy_main_window_show (void)
{
EmpathyMainWindow *window;
EmpathyContactList *list_iface;
EmpathyContactMonitor *monitor;
GtkBuilder *gui;
EmpathyConf *conf;
GtkWidget *sw;
GtkToggleAction *show_offline_widget;
GtkWidget *ebox;
GtkAction *show_map_widget;
GtkToolItem *item;
gboolean show_offline;
gchar *filename;
GSList *l;
if (main_window) {
empathy_window_present (GTK_WINDOW (main_window->window));
return main_window->window;
}
main_window = g_new0 (EmpathyMainWindow, 1);
window = main_window;
/* Set up interface */
filename = empathy_file_lookup ("empathy-main-window.ui", "src");
gui = empathy_builder_get_file (filename,
"main_window", &window->window,
"main_vbox", &window->main_vbox,
"errors_vbox", &window->errors_vbox,
"ui_manager", &window->ui_manager,
"view_show_offline", &show_offline_widget,
"view_show_protocols", &window->show_protocols,
"view_sort_by_name", &window->sort_by_name,
"view_sort_by_status", &window->sort_by_status,
"view_normal_size_with_avatars", &window->normal_with_avatars,
"view_normal_size", &window->normal_size,
"view_compact_size", &window->compact_size,
"view_history", &window->view_history,
"view_show_map", &show_map_widget,
"room_join_favorites", &window->room_join_favorites,
"presence_toolbar", &window->presence_toolbar,
"roster_scrolledwindow", &sw,
NULL);
g_free (filename);
empathy_builder_connect (gui, window,
"main_window", "destroy", main_window_destroy_cb,
"main_window", "key-press-event", main_window_key_press_event_cb,
"chat_quit", "activate", main_window_chat_quit_cb,
"chat_new_message", "activate", main_window_chat_new_message_cb,
"chat_new_call", "activate", main_window_chat_new_call_cb,
"view_history", "activate", main_window_view_history_cb,
"room_join_new", "activate", main_window_room_join_new_cb,
"room_join_favorites", "activate", main_window_room_join_favorites_cb,
"room_manage_favorites", "activate", main_window_room_manage_favorites_cb,
"chat_add_contact", "activate", main_window_chat_add_contact_cb,
"view_show_ft_manager", "activate", main_window_view_show_ft_manager,
"view_show_offline", "toggled", main_window_view_show_offline_cb,
"view_show_protocols", "toggled", main_window_view_show_protocols_cb,
"view_sort_by_name", "changed", main_window_view_sort_contacts_cb,
"view_normal_size_with_avatars", "changed", main_window_view_contacts_list_size_cb,
"view_show_map", "activate", main_window_view_show_map_cb,
"edit", "activate", main_window_edit_cb,
"edit_accounts", "activate", main_window_edit_accounts_cb,
"edit_personal_information", "activate", main_window_edit_personal_information_cb,
"edit_preferences", "activate", main_window_edit_preferences_cb,
"help_about", "activate", main_window_help_about_cb,
"help_debug", "activate", main_window_help_debug_cb,
"help_contents", "activate", main_window_help_contents_cb,
NULL);
/* Set up connection related widgets. */
main_window_connection_items_setup (window, gui);
g_object_ref (window->ui_manager);
g_object_unref (gui);
#if !HAVE_LIBCHAMPLAIN
gtk_action_set_visible (show_map_widget, FALSE);
#endif
window->account_manager = tp_account_manager_dup ();
tp_account_manager_prepare_async (window->account_manager, NULL,
account_manager_prepared_cb, window);
window->errors = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
g_object_unref,
NULL);
window->status_changed_handlers = g_hash_table_new_full (g_direct_hash,
g_direct_equal,
NULL,
NULL);
/* Set up menu */
main_window_favorite_chatroom_menu_setup (window);
window->edit_context = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/edit/edit_context");
window->edit_context_separator = gtk_ui_manager_get_widget (window->ui_manager,
"/menubar/edit/edit_context_separator");
gtk_widget_hide (window->edit_context);
gtk_widget_hide (window->edit_context_separator);
/* Set up contact list. */
empathy_status_presets_get_all ();
/* Set up presence chooser */
window->presence_chooser = empathy_presence_chooser_new ();
gtk_widget_show (window->presence_chooser);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), window->presence_chooser);
gtk_tool_item_set_is_important (item, TRUE);
gtk_tool_item_set_expand (item, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1);
/* Set up the throbber */
ebox = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), FALSE);
gtk_widget_set_tooltip_text (ebox, _("Show and edit accounts"));
g_signal_connect (ebox,
"button-press-event",
G_CALLBACK (main_window_throbber_button_press_event_cb),
window);
gtk_widget_show (ebox);
window->throbber = ephy_spinner_new ();
ephy_spinner_set_size (EPHY_SPINNER (window->throbber), GTK_ICON_SIZE_LARGE_TOOLBAR);
gtk_container_add (GTK_CONTAINER (ebox), window->throbber);
gtk_widget_show (window->throbber);
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), ebox);
gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1);
gtk_widget_show (GTK_WIDGET (item));
list_iface = EMPATHY_CONTACT_LIST (empathy_contact_manager_dup_singleton ());
monitor = empathy_contact_list_get_monitor (list_iface);
window->list_store = empathy_contact_list_store_new (list_iface);
window->list_view = empathy_contact_list_view_new (window->list_store,
EMPATHY_CONTACT_LIST_FEATURE_ALL,
EMPATHY_CONTACT_FEATURE_ALL);
g_signal_connect (monitor, "contact-presence-changed",
G_CALLBACK (main_window_contact_presence_changed_cb), window);
window->butterfly_log_migration_contact_added_id = g_signal_connect (monitor, "contact-added",
G_CALLBACK (main_window_contact_added_cb), window);
g_object_unref (list_iface);
gtk_widget_show (GTK_WIDGET (window->list_view));
gtk_container_add (GTK_CONTAINER (sw),
GTK_WIDGET (window->list_view));
g_signal_connect (window->list_view, "row-activated",
G_CALLBACK (main_window_row_activated_cb),
window);
/* Load user-defined accelerators. */
main_window_accels_load ();
/* Set window size. */
empathy_geometry_bind (GTK_WINDOW (window->window), GEOMETRY_NAME);
/* Enable event handling */
window->event_manager = empathy_event_manager_dup_singleton ();
g_signal_connect (window->event_manager, "event-added",
G_CALLBACK (main_window_event_added_cb),
window);
g_signal_connect (window->event_manager, "event-removed",
G_CALLBACK (main_window_event_removed_cb),
window);
g_signal_connect (window->account_manager, "account-validity-changed",
G_CALLBACK (main_window_account_validity_changed_cb),
window);
g_signal_connect (window->account_manager, "account-removed",
G_CALLBACK (main_window_account_removed_cb),
window);
g_signal_connect (window->account_manager, "account-disabled",
G_CALLBACK (main_window_account_disabled_cb),
window);
l = empathy_event_manager_get_events (window->event_manager);
while (l) {
main_window_event_added_cb (window->event_manager,
l->data, window);
l = l->next;
}
conf = empathy_conf_get ();
/* Show offline ? */
empathy_conf_get_bool (conf,
EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE,
&show_offline);
empathy_conf_notify_add (conf,
EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE,
main_window_notify_show_offline_cb,
show_offline_widget);
gtk_toggle_action_set_active (show_offline_widget, show_offline);
/* Show protocol ? */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_SHOW_PROTOCOLS,
(EmpathyConfNotifyFunc) main_window_notify_show_protocols_cb,
window);
main_window_notify_show_protocols_cb (conf,
EMPATHY_PREFS_UI_SHOW_PROTOCOLS,
window);
/* Sort by name / by status ? */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
(EmpathyConfNotifyFunc) main_window_notify_sort_contact_cb,
window);
main_window_notify_sort_contact_cb (conf,
EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM,
window);
/* Contacts list size */
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST,
(EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb,
window);
empathy_conf_notify_add (conf,
EMPATHY_PREFS_UI_SHOW_AVATARS,
(EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb,
window);
main_window_notify_contact_list_size_cb (conf,
EMPATHY_PREFS_UI_SHOW_AVATARS,
window);
return window->window;
}
static void
ephy_find_toolbar_init (EphyFindToolbar *toolbar)
{
EphyFindToolbarPrivate *priv;
GtkToolbar *gtoolbar;
GtkToolItem *item;
GtkWidget *alignment, *arrow, *box;
GtkWidget *checkbox;
priv = toolbar->priv = EPHY_FIND_TOOLBAR_GET_PRIVATE (toolbar);
gtoolbar = GTK_TOOLBAR (toolbar);
gtk_toolbar_set_style (gtoolbar, GTK_TOOLBAR_BOTH_HORIZ);
/* Find: |_____| */
alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_add (GTK_CONTAINER (alignment), box);
priv->label = gtk_label_new (NULL);
gtk_box_pack_start (GTK_BOX (box), priv->label, FALSE, FALSE, 0);
priv->entry = gtk_entry_new ();
gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 32);
gtk_entry_set_max_length (GTK_ENTRY (priv->entry), 512);
gtk_box_pack_start (GTK_BOX (box), priv->entry, TRUE, TRUE, 0);
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), alignment);
/* gtk_tool_item_set_expand (item, TRUE); */
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_show_all (GTK_WIDGET (item));
/* Prev */
arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE);
priv->prev = gtk_tool_button_new (arrow, _("Find Previous"));
gtk_tool_item_set_is_important (priv->prev, TRUE);
gtk_tool_item_set_tooltip_text (priv->prev,
_("Find previous occurrence of the search string"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->prev, -1);
gtk_widget_show_all (GTK_WIDGET (priv->prev));
/* Next */
arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE);
priv->next = gtk_tool_button_new (arrow, _("Find Next"));
gtk_tool_item_set_is_important (priv->next, TRUE);
gtk_tool_item_set_tooltip_text (priv->next,
_("Find next occurrence of the search string"));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->next, -1);
gtk_widget_show_all (GTK_WIDGET (priv->next));
/* Case sensitivity */
checkbox = gtk_check_button_new_with_mnemonic (_("_Case sensitive"));
priv->case_sensitive = checkbox;
item = gtk_tool_item_new ();
gtk_container_add (GTK_CONTAINER (item), checkbox);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
gtk_widget_show_all (GTK_WIDGET (item));
/* Populate the overflow menu */
g_signal_connect (item, "create-menu-proxy",
G_CALLBACK (toolitem_create_menu_proxy_cb), toolbar);
priv->sep = gtk_separator_tool_item_new ();
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->sep, -1);
priv->status_item = gtk_tool_item_new ();
gtk_tool_item_set_expand (priv->status_item, TRUE);
priv->status_label = gtk_label_new ("");
gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5);
gtk_label_set_ellipsize (GTK_LABEL (priv->status_label), PANGO_ELLIPSIZE_END);
gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label);
gtk_widget_show (priv->status_label);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->status_item, -1);
/* connect signals */
g_signal_connect (priv->entry, "key-press-event",
G_CALLBACK (entry_key_press_event_cb), toolbar);
g_signal_connect_after (priv->entry, "changed",
G_CALLBACK (entry_changed_cb), toolbar);
g_signal_connect (priv->entry, "activate",
G_CALLBACK (entry_activate_cb), toolbar);
g_signal_connect_swapped (priv->next, "clicked",
G_CALLBACK (find_next_cb), toolbar);
g_signal_connect_swapped (priv->prev, "clicked",
G_CALLBACK (find_prev_cb), toolbar);
g_signal_connect (priv->case_sensitive, "toggled",
G_CALLBACK (case_sensitive_toggled_cb), toolbar);
}
void
e_mail_shell_view_update_send_receive_menus (EMailShellView *mail_shell_view)
{
EMailShellViewPrivate *priv;
EShellWindow *shell_window;
EShellView *shell_view;
GtkWidget *widget;
const gchar *widget_path;
g_return_if_fail (E_IS_MAIL_SHELL_VIEW (mail_shell_view));
priv = E_MAIL_SHELL_VIEW_GET_PRIVATE (mail_shell_view);
shell_view = E_SHELL_VIEW (mail_shell_view);
shell_window = e_shell_view_get_shell_window (shell_view);
if (!e_shell_view_is_active (shell_view)) {
if (priv->send_receive_tool_item) {
GtkWidget *toolbar;
toolbar = e_shell_window_get_managed_widget (
shell_window, "/main-toolbar");
g_return_if_fail (toolbar != NULL);
gtk_container_remove (
GTK_CONTAINER (toolbar),
GTK_WIDGET (priv->send_receive_tool_item));
gtk_container_remove (
GTK_CONTAINER (toolbar),
GTK_WIDGET (priv->send_receive_tool_separator));
priv->send_receive_tool_item = NULL;
priv->send_receive_tool_separator = NULL;
}
return;
}
widget_path =
"/main-menu/file-menu"
"/mail-send-receiver/mail-send-receive-submenu";
widget = e_shell_window_get_managed_widget (shell_window, widget_path);
if (widget != NULL)
gtk_menu_item_set_submenu (
GTK_MENU_ITEM (widget),
create_send_receive_submenu (mail_shell_view));
if (!priv->send_receive_tool_item) {
GtkWidget *toolbar;
GtkToolItem *tool_item;
gint index;
toolbar = e_shell_window_get_managed_widget (
shell_window, "/main-toolbar");
g_return_if_fail (toolbar != NULL);
widget_path =
"/main-toolbar/toolbar-actions/mail-send-receiver";
widget = e_shell_window_get_managed_widget (
shell_window, widget_path);
g_return_if_fail (widget != NULL);
index = gtk_toolbar_get_item_index (
GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (widget));
tool_item = gtk_separator_tool_item_new ();
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), tool_item, index);
gtk_widget_show (GTK_WIDGET (tool_item));
priv->send_receive_tool_separator = tool_item;
tool_item = GTK_TOOL_ITEM (
e_menu_tool_button_new (_("Send / Receive")));
gtk_tool_item_set_is_important (tool_item, TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), tool_item, index);
gtk_widget_show (GTK_WIDGET (tool_item));
priv->send_receive_tool_item = tool_item;
e_binding_bind_property (
ACTION (MAIL_SEND_RECEIVE), "sensitive",
tool_item, "sensitive",
G_BINDING_SYNC_CREATE);
}
if (priv->send_receive_tool_item)
gtk_menu_tool_button_set_menu (
GTK_MENU_TOOL_BUTTON (priv->send_receive_tool_item),
create_send_receive_submenu (mail_shell_view));
}
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
{
wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
GSList* radioGroup;
GtkWidget* bin_child;
switch ( tool->GetStyle() )
{
case wxTOOL_STYLE_BUTTON:
switch (tool->GetKind())
{
case wxITEM_CHECK:
tool->m_item = gtk_toggle_tool_button_new();
g_signal_connect(tool->m_item, "toggled",
G_CALLBACK(item_toggled), tool);
break;
case wxITEM_RADIO:
radioGroup = GetRadioGroup(pos);
if (!radioGroup)
{
// this is the first button in the radio button group,
// it will be toggled automatically by GTK so bring the
// internal flag in sync
tool->Toggle(true);
}
tool->m_item = gtk_radio_tool_button_new(radioGroup);
g_signal_connect(tool->m_item, "toggled",
G_CALLBACK(item_toggled), tool);
break;
default:
wxFAIL_MSG("unknown toolbar child type");
// fall through
case wxITEM_DROPDOWN:
case wxITEM_NORMAL:
tool->m_item = gtk_tool_button_new(NULL, "");
g_signal_connect(tool->m_item, "clicked",
G_CALLBACK(item_clicked), tool);
break;
}
if (!HasFlag(wxTB_NOICONS))
{
GtkWidget* image = gtk_image_new();
gtk_tool_button_set_icon_widget(
GTK_TOOL_BUTTON(tool->m_item), image);
tool->SetImage();
gtk_widget_show(image);
#ifdef __WXGTK3__
g_signal_connect(image, "draw",
G_CALLBACK(image_draw), tool);
#else
g_signal_connect(image, "expose_event",
G_CALLBACK(image_expose_event), tool);
#endif
}
if (!tool->GetLabel().empty())
{
gtk_tool_button_set_label(
GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel()));
// needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT
gtk_tool_item_set_is_important(tool->m_item, true);
}
if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())
{
#if GTK_CHECK_VERSION(2, 12, 0)
if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL)
{
gtk_tool_item_set_tooltip_text(tool->m_item,
wxGTK_CONV(tool->GetShortHelp()));
}
else
#endif
{
#ifndef __WXGTK3__
gtk_tool_item_set_tooltip(tool->m_item,
m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
#endif
}
}
bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item));
g_signal_connect(bin_child, "button_press_event",
G_CALLBACK(button_press_event), tool);
g_signal_connect(bin_child, "enter_notify_event",
G_CALLBACK(enter_notify_event), tool);
g_signal_connect(bin_child, "leave_notify_event",
G_CALLBACK(enter_notify_event), tool);
if (tool->GetKind() == wxITEM_DROPDOWN)
tool->CreateDropDown();
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_SEPARATOR:
tool->m_item = gtk_separator_tool_item_new();
if ( tool->IsStretchable() )
{
gtk_separator_tool_item_set_draw
(
GTK_SEPARATOR_TOOL_ITEM(tool->m_item),
FALSE
);
gtk_tool_item_set_expand(tool->m_item, TRUE);
}
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_CONTROL:
wxWindow* control = tool->GetControl();
if (gtk_widget_get_parent(control->m_widget) == NULL)
AddChildGTK(control);
tool->m_item = GTK_TOOL_ITEM(gtk_widget_get_parent(gtk_widget_get_parent(control->m_widget)));
if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))
{
g_object_ref(tool->m_item);
gtk_container_remove(
GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item));
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
g_object_unref(tool->m_item);
}
break;
}
gtk_widget_show(GTK_WIDGET(tool->m_item));
InvalidateBestSize();
return true;
}
static void remmina_main_init(RemminaMain *remminamain)
{
RemminaMainPriv *priv;
GtkWidget *vbox;
GtkWidget *menubar;
GtkWidget *hbox;
GtkWidget *quickconnect;
GtkWidget *tool_item;
GtkUIManager *uimanager;
GtkActionGroup *action_group;
GtkWidget *scrolledwindow;
GtkWidget *tree;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GError *error;
priv = g_new0(RemminaMainPriv, 1);
remminamain->priv = priv;
remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group);
/* Create main window */
g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL);
g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL);
g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0);
gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client"));
gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height);
gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER);
if (remmina_pref.main_maximize)
{
gtk_window_maximize(GTK_WINDOW(remminamain));
}
/* Create the main container */
#if GTK_VERSION == 3
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#elif GTK_VERSION == 2
vbox = gtk_vbox_new(FALSE, 0);
#endif
gtk_container_add(GTK_CONTAINER(remminamain), vbox);
gtk_widget_show(vbox);
/* Create the menubar and toolbar */
uimanager = gtk_ui_manager_new();
priv->uimanager = uimanager;
action_group = gtk_action_group_new("RemminaMainActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries),
remminamain);
gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries,
G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain);
gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries,
G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode,
G_CALLBACK(remmina_main_action_view_file_mode), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->main_group = action_group;
action_group = gtk_action_group_new("RemminaMainFileSensitiveActions");
gtk_action_group_set_translation_domain(action_group, NULL);
gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries,
G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain);
gtk_ui_manager_insert_action_group(uimanager, action_group, 0);
g_object_unref(action_group);
priv->file_sensitive_group = action_group;
error = NULL;
gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error);
if (error)
{
g_message("building menus failed: %s", error->message);
g_error_free(error);
}
remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain);
menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar");
#if GTK_VERSION == 3
gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR);
#endif
gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew");
gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE);
remmina_main_create_quick_search(remminamain);
gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager));
gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE);
/* Add a Fast Connection box */
#if GTK_VERSION == 3
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#elif GTK_VERSION == 2
hbox = gtk_hbox_new(FALSE, 0);
#endif
priv->quickconnect_protocol = gtk_combo_box_text_new();
#if GTK_VERSION == 3
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX");
gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH");
#elif GTK_VERSION == 2
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH");
#endif
gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0);
gtk_widget_show(priv->quickconnect_protocol);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0);
priv->quickconnect_server = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25);
gtk_widget_show(priv->quickconnect_server);
gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain);
quickconnect = gtk_button_new_with_label("Connect !");
gtk_widget_show(quickconnect);
gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
gtk_widget_show(hbox);
/* Create the scrolled window for the file list */
scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(scrolledwindow);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0);
/* Create the remmina file list */
tree = gtk_tree_view_new();
column = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(column, _("Name"));
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN);
renderer = gtk_cell_renderer_pixbuf_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "icon-name", PROTOCOL_COLUMN);
g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL);
renderer = gtk_cell_renderer_text_new();
gtk_tree_view_column_pack_start(column, renderer, FALSE);
gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
priv->group_column = column;
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL);
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column);
gtk_container_add(GTK_CONTAINER(scrolledwindow), tree);
gtk_widget_show(tree);
gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func,
remminamain, NULL);
g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain);
g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain);
priv->file_list = tree;
/* Create statusbar */
priv->statusbar = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0);
gtk_widget_show(priv->statusbar);
/* Prepare the data */
remmina_main_load_files(remminamain, FALSE);
/* Load the preferences */
if (remmina_pref.hide_toolbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")),
FALSE);
}
if (remmina_pref.hide_statusbar)
{
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")),
FALSE);
}
if (remmina_pref.show_quick_search)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE);
}
if (remmina_pref.small_toolbutton)
{
gtk_toggle_action_set_active(
GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE);
}
/* Drag-n-drop support */
gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL);
priv->initialized = TRUE;
remmina_widget_pool_register(GTK_WIDGET(remminamain));
}
GtkWidget*
create_dialog1 (void)
{
GtkWidget *dialog1;
GtkWidget *dialog_vbox1;
GtkWidget *vbox3b;
GtkWidget *toolbar1;
GtkIconSize tmp_toolbar_icon_size;
GtkWidget *toolbuttonOpen;
GtkWidget *toolbuttonSave;
GtkWidget *tmp_image;
GtkWidget *toolbuttonScript;
GtkWidget *toolbuttonDVD;
GtkWidget *toolbuttonHalfD1;
GtkWidget *toolbuttonSVCD;
GtkWidget *toolbuttonVCD;
GtkWidget *hbox11;
GtkWidget *frame1;
GtkWidget *alignment1;
GtkWidget *vbox2;
GtkWidget *notebook1;
GtkWidget *scrolledwindow1;
GtkWidget *treeview1;
GtkWidget *hbox5;
GtkWidget *image1;
GtkWidget *label11;
GtkWidget *scrolledwindow2;
GtkWidget *treeview2;
GtkWidget *hbox6;
GtkWidget *image2;
GtkWidget *label17;
GtkWidget *scrolledwindow3;
GtkWidget *treeview3;
GtkWidget *hbox7;
GtkWidget *image3;
GtkWidget *label18;
GtkWidget *scrolledwindow4;
GtkWidget *treeview4;
GtkWidget *hbox8;
GtkWidget *image4;
GtkWidget *label19;
GtkWidget *scrolledwindow5;
GtkWidget *treeview5;
GtkWidget *hbox9;
GtkWidget *image5;
GtkWidget *label20;
GtkWidget *scrolledwindow6;
GtkWidget *treeview6;
GtkWidget *hbox10;
GtkWidget *image6;
GtkWidget *label21;
GtkWidget *scrolledwindow7;
GtkWidget *treeview7;
GtkWidget *hbox4;
GtkWidget *image7;
GtkWidget *label22;
GtkWidget *treeview8;
GtkWidget *label28;
GtkWidget *hbox13;
GtkWidget *buttonAdd;
GtkWidget *image11;
GtkWidget *label23;
GtkWidget *frame2;
GtkWidget *alignment2;
GtkWidget *hbox1;
GtkWidget *vbox3;
GtkWidget *scrolledwindow9;
GtkWidget *treeview0;
GtkWidget *hbox14;
GtkWidget *buttonRemove;
GtkWidget *image15;
GtkWidget *buttonDown;
GtkWidget *image14;
GtkWidget *buttonUp;
GtkWidget *image13;
GtkWidget *buttonPartial;
GtkWidget *buttonProperties;
GtkWidget *alignment4;
GtkWidget *hbox16;
GtkWidget *label25;
GtkWidget *label2;
GtkWidget *dialog_action_area1;
GtkWidget *buttonPreview;
GtkWidget *alignment5;
GtkWidget *hbox17;
GtkWidget *image17;
GtkWidget *label26;
GtkWidget *buttonClose;
GtkAccelGroup *accel_group;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
dialog1 = gtk_dialog_new ();
gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6);
gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Video Filter Manager"));
gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE);
dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
gtk_box_set_spacing (GTK_BOX(dialog_vbox1), 12);
gtk_widget_show (dialog_vbox1);
vbox3b = gtk_vbox_new (FALSE, 12);
gtk_widget_show (vbox3b);
gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox3b, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox3b), 6);
toolbar1 = gtk_toolbar_new ();
gtk_widget_show (toolbar1);
gtk_box_pack_start (GTK_BOX (vbox3b), toolbar1, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH);
tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1));
toolbuttonOpen = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-open");
gtk_widget_show (toolbuttonOpen);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonOpen);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonOpen), tooltips, QT_TR_NOOP("Open filter list [Ctrl-O]"), NULL);
gtk_widget_add_accelerator (toolbuttonOpen, "clicked", accel_group,
GDK_O, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonOpen), TRUE);
toolbuttonSave = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save");
gtk_widget_show (toolbuttonSave);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSave);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonSave), tooltips, QT_TR_NOOP("Save filter list [Ctrl-S]"), NULL);
gtk_widget_add_accelerator (toolbuttonSave, "clicked", accel_group,
GDK_S, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonSave), TRUE);
tmp_image = gtk_image_new_from_stock ("gtk-save-as", tmp_toolbar_icon_size);
gtk_widget_show (tmp_image);
toolbuttonScript = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Save Script"));
gtk_widget_show (toolbuttonScript);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonScript);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonScript), tooltips, QT_TR_NOOP("Save as script [Ctrl-J]"), NULL);
gtk_widget_add_accelerator (toolbuttonScript, "clicked", accel_group,
GDK_J, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonScript), TRUE);
tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size);
gtk_widget_show (tmp_image);
toolbuttonDVD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("DVD Res"));
gtk_widget_show (toolbuttonDVD);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonDVD);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonDVD), tooltips, QT_TR_NOOP("DVD resolution [Ctrl-1]"), NULL);
gtk_widget_add_accelerator (toolbuttonDVD, "clicked", accel_group,
GDK_1, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonDVD), TRUE);
tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size);
gtk_widget_show (tmp_image);
toolbuttonHalfD1 = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Half D1 Res"));
gtk_widget_show (toolbuttonHalfD1);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonHalfD1);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonHalfD1), tooltips, QT_TR_NOOP("Half D1 resolution [Ctrl-2]"), NULL);
gtk_widget_add_accelerator (toolbuttonHalfD1, "clicked", accel_group,
GDK_2, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonHalfD1), TRUE);
tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size);
gtk_widget_show (tmp_image);
toolbuttonSVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("SVCD Res"));
gtk_widget_show (toolbuttonSVCD);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSVCD);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonSVCD), tooltips, QT_TR_NOOP("SVCD resolution [Ctrl-3]"), NULL);
gtk_widget_add_accelerator (toolbuttonSVCD, "clicked", accel_group,
GDK_3, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonSVCD), TRUE);
tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size);
gtk_widget_show (tmp_image);
toolbuttonVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("VCD Res"));
gtk_widget_show (toolbuttonVCD);
gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonVCD);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonVCD), tooltips, QT_TR_NOOP("VCD resolution [Ctrl-4]"), NULL);
gtk_widget_add_accelerator (toolbuttonVCD, "clicked", accel_group,
GDK_4, (GdkModifierType) GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonVCD), TRUE);
hbox11 = gtk_hbox_new (FALSE, 12);
gtk_widget_show (hbox11);
gtk_box_pack_start (GTK_BOX (vbox3b), hbox11, TRUE, TRUE, 0);
frame1 = gtk_frame_new (NULL);
gtk_widget_show (frame1);
gtk_box_pack_start (GTK_BOX (hbox11), frame1, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE);
alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment1);
gtk_container_add (GTK_CONTAINER (frame1), alignment1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0);
vbox2 = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (alignment1), vbox2);
notebook1 = gtk_notebook_new ();
gtk_widget_show (notebook1);
gtk_box_pack_start (GTK_BOX (vbox2), notebook1, TRUE, TRUE, 0);
gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook1), FALSE);
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook1), GTK_POS_LEFT);
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow1);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
treeview1 = gtk_tree_view_new ();
gtk_widget_show (treeview1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview1);
gtk_widget_set_size_request (treeview1, 288, 336);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview1), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview1), FALSE);
hbox5 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox5);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), hbox5);
image1 = create_pixmap (dialog1, "1.png");
gtk_widget_show (image1);
gtk_box_pack_start (GTK_BOX (hbox5), image1, FALSE, FALSE, 0);
label11 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Transform"));
gtk_widget_show (label11);
gtk_box_pack_start (GTK_BOX (hbox5), label11, FALSE, FALSE, 4);
gtk_label_set_use_markup (GTK_LABEL (label11), TRUE);
scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow2);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow2);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
treeview2 = gtk_tree_view_new ();
gtk_widget_show (treeview2);
gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview2);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview2), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview2), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview2), FALSE);
hbox6 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox6);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), hbox6);
image2 = create_pixmap (dialog1, "2.png");
gtk_widget_show (image2);
gtk_box_pack_start (GTK_BOX (hbox6), image2, FALSE, FALSE, 0);
label17 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Interlacing"));
gtk_widget_show (label17);
gtk_box_pack_start (GTK_BOX (hbox6), label17, FALSE, FALSE, 4);
scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow3);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow3);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
treeview3 = gtk_tree_view_new ();
gtk_widget_show (treeview3);
gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview3);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview3), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview3), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview3), FALSE);
hbox7 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox7);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), hbox7);
image3 = create_pixmap (dialog1, "4.png");
gtk_widget_show (image3);
gtk_box_pack_start (GTK_BOX (hbox7), image3, FALSE, FALSE, 0);
label18 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Colors"));
gtk_widget_show (label18);
gtk_box_pack_start (GTK_BOX (hbox7), label18, FALSE, FALSE, 4);
scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow4);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow4);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
treeview4 = gtk_tree_view_new ();
gtk_widget_show (treeview4);
gtk_container_add (GTK_CONTAINER (scrolledwindow4), treeview4);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview4), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview4), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview4), FALSE);
hbox8 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox8);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), hbox8);
image4 = create_pixmap (dialog1, "5.png");
gtk_widget_show (image4);
gtk_box_pack_start (GTK_BOX (hbox8), image4, FALSE, FALSE, 0);
label19 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Noise"));
gtk_widget_show (label19);
gtk_box_pack_start (GTK_BOX (hbox8), label19, FALSE, FALSE, 4);
scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow5);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow5);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
treeview5 = gtk_tree_view_new ();
gtk_widget_show (treeview5);
gtk_container_add (GTK_CONTAINER (scrolledwindow5), treeview5);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview5), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview5), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview5), FALSE);
hbox9 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox9);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 4), hbox9);
image5 = create_pixmap (dialog1, "3.png");
gtk_widget_show (image5);
gtk_box_pack_start (GTK_BOX (hbox9), image5, FALSE, FALSE, 0);
label20 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Sharpness"));
gtk_widget_show (label20);
gtk_box_pack_start (GTK_BOX (hbox9), label20, FALSE, FALSE, 4);
scrolledwindow6 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow6);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow6);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow6), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
treeview6 = gtk_tree_view_new ();
gtk_widget_show (treeview6);
gtk_container_add (GTK_CONTAINER (scrolledwindow6), treeview6);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview6), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview6), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview6), FALSE);
hbox10 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox10);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 5), hbox10);
image6 = create_pixmap (dialog1, "7.png");
gtk_widget_show (image6);
gtk_box_pack_start (GTK_BOX (hbox10), image6, FALSE, FALSE, 0);
label21 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Subtitles"));
gtk_widget_show (label21);
gtk_box_pack_start (GTK_BOX (hbox10), label21, FALSE, FALSE, 4);
scrolledwindow7 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow7);
gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow7);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow7), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
treeview7 = gtk_tree_view_new ();
gtk_widget_show (treeview7);
gtk_container_add (GTK_CONTAINER (scrolledwindow7), treeview7);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview7), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview7), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview7), FALSE);
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 6), hbox4);
image7 = create_pixmap (dialog1, "6.png");
gtk_widget_show (image7);
gtk_box_pack_start (GTK_BOX (hbox4), image7, FALSE, FALSE, 0);
label22 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Misc"));
gtk_widget_show (label22);
gtk_box_pack_start (GTK_BOX (hbox4), label22, FALSE, FALSE, 4);
treeview8 = gtk_tree_view_new ();
gtk_widget_show (treeview8);
gtk_container_add (GTK_CONTAINER (notebook1), treeview8);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview8), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview8), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview8), FALSE);
label28 = gtk_label_new (QT_TR_NOOP("External"));
gtk_widget_show (label28);
gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 7), label28);
hbox13 = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox13);
gtk_box_pack_start (GTK_BOX (vbox2), hbox13, FALSE, FALSE, 0);
buttonAdd = gtk_button_new ();
gtk_widget_show (buttonAdd);
gtk_box_pack_end (GTK_BOX (hbox13), buttonAdd, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, buttonAdd, QT_TR_NOOP("Add selected filter to the Active Filters list"), NULL);
image11 = gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image11);
gtk_container_add (GTK_CONTAINER (buttonAdd), image11);
label23 = gtk_label_new (QT_TR_NOOP("<b>Available Filters</b>"));
gtk_widget_show (label23);
gtk_frame_set_label_widget (GTK_FRAME (frame1), label23);
gtk_label_set_use_markup (GTK_LABEL (label23), TRUE);
gtk_misc_set_alignment (GTK_MISC (label23), 1, 1);
frame2 = gtk_frame_new (NULL);
gtk_widget_show (frame2);
gtk_box_pack_start (GTK_BOX (hbox11), frame2, TRUE, TRUE, 0);
gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE);
alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_widget_show (alignment2);
gtk_container_add (GTK_CONTAINER (frame2), alignment2);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 6, 0, 18, 0);
hbox1 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox1);
gtk_container_add (GTK_CONTAINER (alignment2), hbox1);
vbox3 = gtk_vbox_new (FALSE, 6);
gtk_widget_show (vbox3);
gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 0);
scrolledwindow9 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow9);
gtk_box_pack_start (GTK_BOX (vbox3), scrolledwindow9, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_SHADOW_OUT);
treeview0 = gtk_tree_view_new ();
gtk_widget_show (treeview0);
gtk_container_add (GTK_CONTAINER (scrolledwindow9), treeview0);
gtk_widget_set_size_request (treeview0, 288, 336);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview0), FALSE);
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview0), TRUE);
gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview0), FALSE);
hbox14 = gtk_hbox_new (FALSE, 6);
gtk_widget_show (hbox14);
gtk_box_pack_start (GTK_BOX (vbox3), hbox14, FALSE, FALSE, 0);
buttonRemove = gtk_button_new ();
gtk_widget_show (buttonRemove);
gtk_box_pack_end (GTK_BOX (hbox14), buttonRemove, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, buttonRemove, QT_TR_NOOP("Remove filter"), NULL);
image15 = gtk_image_new_from_stock ("gtk-remove", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image15);
gtk_container_add (GTK_CONTAINER (buttonRemove), image15);
buttonDown = gtk_button_new ();
gtk_widget_show (buttonDown);
gtk_box_pack_end (GTK_BOX (hbox14), buttonDown, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, buttonDown, QT_TR_NOOP("Move filter down"), NULL);
image14 = gtk_image_new_from_icon_name ("gtk-go-down", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image14);
gtk_container_add (GTK_CONTAINER (buttonDown), image14);
buttonUp = gtk_button_new ();
gtk_widget_show (buttonUp);
gtk_box_pack_end (GTK_BOX (hbox14), buttonUp, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, buttonUp, QT_TR_NOOP("Move filter up"), NULL);
image13 = gtk_image_new_from_icon_name ("gtk-go-up", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image13);
gtk_container_add (GTK_CONTAINER (buttonUp), image13);
buttonPartial = gtk_button_new_with_mnemonic (QT_TR_NOOP("P_artial"));
gtk_widget_show (buttonPartial);
gtk_box_pack_end (GTK_BOX (hbox14), buttonPartial, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, buttonPartial, QT_TR_NOOP("Apply the current filter only to a part of the file"), NULL);
buttonProperties = gtk_button_new ();
gtk_widget_show (buttonProperties);
gtk_box_pack_end (GTK_BOX (hbox14), buttonProperties, FALSE, FALSE, 0);
gtk_tooltips_set_tip (tooltips, buttonProperties, QT_TR_NOOP("Configure filter"), NULL);
alignment4 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment4);
gtk_container_add (GTK_CONTAINER (buttonProperties), alignment4);
hbox16 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox16);
gtk_container_add (GTK_CONTAINER (alignment4), hbox16);
label25 = gtk_label_new_with_mnemonic (QT_TR_NOOP("C_onfigure"));
gtk_widget_show (label25);
gtk_box_pack_start (GTK_BOX (hbox16), label25, FALSE, FALSE, 0);
label2 = gtk_label_new (QT_TR_NOOP("<b >Active Filters</b>"));
gtk_widget_show (label2);
gtk_frame_set_label_widget (GTK_FRAME (frame2), label2);
gtk_label_set_use_markup (GTK_LABEL (label2), TRUE);
gtk_misc_set_alignment (GTK_MISC (label2), 1, 1);
dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
gtk_widget_show (dialog_action_area1);
gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);
buttonPreview = gtk_button_new ();
gtk_widget_show (buttonPreview);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), buttonPreview, GTK_RESPONSE_APPLY);
GTK_WIDGET_SET_FLAGS (buttonPreview, GTK_CAN_DEFAULT);
alignment5 = gtk_alignment_new (0.5, 0.5, 0, 0);
gtk_widget_show (alignment5);
gtk_container_add (GTK_CONTAINER (buttonPreview), alignment5);
hbox17 = gtk_hbox_new (FALSE, 2);
gtk_widget_show (hbox17);
gtk_container_add (GTK_CONTAINER (alignment5), hbox17);
image17 = create_pixmap (dialog1, "preview-button.png");
gtk_widget_show (image17);
gtk_box_pack_start (GTK_BOX (hbox17), image17, FALSE, FALSE, 0);
label26 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Preview"));
gtk_widget_show (label26);
gtk_box_pack_start (GTK_BOX (hbox17), label26, FALSE, FALSE, 0);
buttonClose = gtk_button_new_from_stock ("gtk-close");
gtk_widget_show (buttonClose);
gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), buttonClose, GTK_RESPONSE_CLOSE);
GTK_WIDGET_SET_FLAGS (buttonClose, GTK_CAN_DEFAULT);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox3b, "vbox3b");
GLADE_HOOKUP_OBJECT (dialog1, toolbar1, "toolbar1");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonOpen, "toolbuttonOpen");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSave, "toolbuttonSave");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonScript, "toolbuttonScript");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonDVD, "toolbuttonDVD");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonHalfD1, "toolbuttonHalfD1");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSVCD, "toolbuttonSVCD");
GLADE_HOOKUP_OBJECT (dialog1, toolbuttonVCD, "toolbuttonVCD");
GLADE_HOOKUP_OBJECT (dialog1, hbox11, "hbox11");
GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1");
GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1");
GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (dialog1, notebook1, "notebook1");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow1, "scrolledwindow1");
GLADE_HOOKUP_OBJECT (dialog1, treeview1, "treeview1");
GLADE_HOOKUP_OBJECT (dialog1, hbox5, "hbox5");
GLADE_HOOKUP_OBJECT (dialog1, image1, "image1");
GLADE_HOOKUP_OBJECT (dialog1, label11, "label11");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow2, "scrolledwindow2");
GLADE_HOOKUP_OBJECT (dialog1, treeview2, "treeview2");
GLADE_HOOKUP_OBJECT (dialog1, hbox6, "hbox6");
GLADE_HOOKUP_OBJECT (dialog1, image2, "image2");
GLADE_HOOKUP_OBJECT (dialog1, label17, "label17");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow3, "scrolledwindow3");
GLADE_HOOKUP_OBJECT (dialog1, treeview3, "treeview3");
GLADE_HOOKUP_OBJECT (dialog1, hbox7, "hbox7");
GLADE_HOOKUP_OBJECT (dialog1, image3, "image3");
GLADE_HOOKUP_OBJECT (dialog1, label18, "label18");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow4, "scrolledwindow4");
GLADE_HOOKUP_OBJECT (dialog1, treeview4, "treeview4");
GLADE_HOOKUP_OBJECT (dialog1, hbox8, "hbox8");
GLADE_HOOKUP_OBJECT (dialog1, image4, "image4");
GLADE_HOOKUP_OBJECT (dialog1, label19, "label19");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow5, "scrolledwindow5");
GLADE_HOOKUP_OBJECT (dialog1, treeview5, "treeview5");
GLADE_HOOKUP_OBJECT (dialog1, hbox9, "hbox9");
GLADE_HOOKUP_OBJECT (dialog1, image5, "image5");
GLADE_HOOKUP_OBJECT (dialog1, label20, "label20");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow6, "scrolledwindow6");
GLADE_HOOKUP_OBJECT (dialog1, treeview6, "treeview6");
GLADE_HOOKUP_OBJECT (dialog1, hbox10, "hbox10");
GLADE_HOOKUP_OBJECT (dialog1, image6, "image6");
GLADE_HOOKUP_OBJECT (dialog1, label21, "label21");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow7, "scrolledwindow7");
GLADE_HOOKUP_OBJECT (dialog1, treeview7, "treeview7");
GLADE_HOOKUP_OBJECT (dialog1, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT (dialog1, image7, "image7");
GLADE_HOOKUP_OBJECT (dialog1, label22, "label22");
GLADE_HOOKUP_OBJECT (dialog1, treeview8, "treeview8");
GLADE_HOOKUP_OBJECT (dialog1, label28, "label28");
GLADE_HOOKUP_OBJECT (dialog1, hbox13, "hbox13");
GLADE_HOOKUP_OBJECT (dialog1, buttonAdd, "buttonAdd");
GLADE_HOOKUP_OBJECT (dialog1, image11, "image11");
GLADE_HOOKUP_OBJECT (dialog1, label23, "label23");
GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2");
GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2");
GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
GLADE_HOOKUP_OBJECT (dialog1, vbox3, "vbox3");
GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow9, "scrolledwindow9");
GLADE_HOOKUP_OBJECT (dialog1, treeview0, "treeview0");
GLADE_HOOKUP_OBJECT (dialog1, hbox14, "hbox14");
GLADE_HOOKUP_OBJECT (dialog1, buttonRemove, "buttonRemove");
GLADE_HOOKUP_OBJECT (dialog1, image15, "image15");
GLADE_HOOKUP_OBJECT (dialog1, buttonDown, "buttonDown");
GLADE_HOOKUP_OBJECT (dialog1, image14, "image14");
GLADE_HOOKUP_OBJECT (dialog1, buttonUp, "buttonUp");
GLADE_HOOKUP_OBJECT (dialog1, image13, "image13");
GLADE_HOOKUP_OBJECT (dialog1, buttonPartial, "buttonPartial");
GLADE_HOOKUP_OBJECT (dialog1, buttonProperties, "buttonProperties");
GLADE_HOOKUP_OBJECT (dialog1, alignment4, "alignment4");
GLADE_HOOKUP_OBJECT (dialog1, hbox16, "hbox16");
GLADE_HOOKUP_OBJECT (dialog1, label25, "label25");
GLADE_HOOKUP_OBJECT (dialog1, label2, "label2");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
GLADE_HOOKUP_OBJECT (dialog1, buttonPreview, "buttonPreview");
GLADE_HOOKUP_OBJECT (dialog1, alignment5, "alignment5");
GLADE_HOOKUP_OBJECT (dialog1, hbox17, "hbox17");
GLADE_HOOKUP_OBJECT (dialog1, image17, "image17");
GLADE_HOOKUP_OBJECT (dialog1, label26, "label26");
GLADE_HOOKUP_OBJECT (dialog1, buttonClose, "buttonClose");
GLADE_HOOKUP_OBJECT_NO_REF (dialog1, tooltips, "tooltips");
gtk_window_add_accel_group (GTK_WINDOW (dialog1), accel_group);
return dialog1;
}
GtkWidget*
create_YappiWindow (void)
{
GtkWidget *YappiWindow;
GtkWidget *vbox2;
GtkWidget *hbox4;
GtkWidget *vbox4;
GtkWidget *hbox5;
GtkWidget *CommandLabel1;
GtkWidget *InputBox;
GtkWidget *OkButton;
GtkWidget *handlebox1;
GtkWidget *toolbar4;
GtkIconSize tmp_toolbar_icon_size;
GtkWidget *PlayBt;
GtkWidget *StopBt;
GtkWidget *scrollBt;
GtkWidget *tmp_image;
GtkWidget *MaximazeBt;
GtkWidget *textview1;
GtkWidget *statusbar1;
YappiWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (YappiWindow), _("Yappi !"));
vbox2 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox2);
gtk_container_add (GTK_CONTAINER (YappiWindow), vbox2);
hbox4 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox4);
gtk_box_pack_start (GTK_BOX (vbox2), hbox4, FALSE, FALSE, 0);
vbox4 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox4);
gtk_box_pack_start (GTK_BOX (hbox4), vbox4, FALSE, FALSE, 0);
hbox5 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox5);
gtk_box_pack_start (GTK_BOX (vbox4), hbox5, TRUE, FALSE, 0);
CommandLabel1 = gtk_label_new (_(" CODE: "));
gtk_widget_show (CommandLabel1);
gtk_box_pack_start (GTK_BOX (hbox5), CommandLabel1, TRUE, TRUE, 0);
InputBox = gtk_entry_new ();
gtk_widget_show (InputBox);
gtk_box_pack_start (GTK_BOX (hbox5), InputBox, TRUE, TRUE, 0);
gtk_widget_set_size_request (InputBox, 115, -1);
gtk_entry_set_text (GTK_ENTRY (InputBox), _("PRUEBA"));
gtk_entry_set_activates_default (GTK_ENTRY (InputBox), TRUE);
OkButton = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (OkButton);
gtk_box_pack_start (GTK_BOX (hbox5), OkButton, TRUE, TRUE, 0);
handlebox1 = gtk_handle_box_new ();
gtk_widget_show (handlebox1);
gtk_box_pack_start (GTK_BOX (hbox4), handlebox1, TRUE, TRUE, 0);
toolbar4 = gtk_toolbar_new ();
gtk_widget_show (toolbar4);
gtk_container_add (GTK_CONTAINER (handlebox1), toolbar4);
gtk_widget_set_size_request (toolbar4, 209, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar4), GTK_TOOLBAR_ICONS);
tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar4));
PlayBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-media-play");
gtk_widget_show (PlayBt);
gtk_container_add (GTK_CONTAINER (toolbar4), PlayBt);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (PlayBt), TRUE);
StopBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-media-pause");
gtk_widget_show (StopBt);
gtk_container_add (GTK_CONTAINER (toolbar4), StopBt);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (StopBt), TRUE);
scrollBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-down");
gtk_widget_show (scrollBt);
gtk_container_add (GTK_CONTAINER (toolbar4), scrollBt);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (scrollBt), TRUE);
tmp_image = gtk_image_new_from_stock ("gtk-zoom-in", tmp_toolbar_icon_size);
gtk_widget_show (tmp_image);
MaximazeBt = (GtkWidget*) gtk_tool_button_new (tmp_image, "");
gtk_widget_show (MaximazeBt);
gtk_container_add (GTK_CONTAINER (toolbar4), MaximazeBt);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (MaximazeBt), TRUE);
textview1 = gtk_text_view_new ();
gtk_widget_show (textview1);
gtk_box_pack_start (GTK_BOX (vbox2), textview1, TRUE, TRUE, 1);
gtk_widget_set_size_request (textview1, 136, 87);
gtk_container_set_border_width (GTK_CONTAINER (textview1), 5);
statusbar1 = gtk_statusbar_new ();
gtk_widget_show (statusbar1);
gtk_box_pack_start (GTK_BOX (vbox2), statusbar1, FALSE, FALSE, 0);
g_signal_connect ((gpointer) InputBox, "activate",
G_CALLBACK (on_InputBox_activate),
NULL);
g_signal_connect ((gpointer) InputBox, "grab_focus",
G_CALLBACK (InputBox_grab_focus),
NULL);
g_signal_connect ((gpointer) OkButton, "button_press_event",
G_CALLBACK (on_OkButton_button_press_event),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (YappiWindow, YappiWindow, "YappiWindow");
GLADE_HOOKUP_OBJECT (YappiWindow, vbox2, "vbox2");
GLADE_HOOKUP_OBJECT (YappiWindow, hbox4, "hbox4");
GLADE_HOOKUP_OBJECT (YappiWindow, vbox4, "vbox4");
GLADE_HOOKUP_OBJECT (YappiWindow, hbox5, "hbox5");
GLADE_HOOKUP_OBJECT (YappiWindow, CommandLabel1, "CommandLabel1");
GLADE_HOOKUP_OBJECT (YappiWindow, InputBox, "InputBox");
GLADE_HOOKUP_OBJECT (YappiWindow, OkButton, "OkButton");
GLADE_HOOKUP_OBJECT (YappiWindow, handlebox1, "handlebox1");
GLADE_HOOKUP_OBJECT (YappiWindow, toolbar4, "toolbar4");
GLADE_HOOKUP_OBJECT (YappiWindow, PlayBt, "PlayBt");
GLADE_HOOKUP_OBJECT (YappiWindow, StopBt, "StopBt");
GLADE_HOOKUP_OBJECT (YappiWindow, scrollBt, "scrollBt");
GLADE_HOOKUP_OBJECT (YappiWindow, MaximazeBt, "MaximazeBt");
GLADE_HOOKUP_OBJECT (YappiWindow, textview1, "textview1");
GLADE_HOOKUP_OBJECT (YappiWindow, statusbar1, "statusbar1");
return YappiWindow;
}
void
e_composer_private_constructed (EMsgComposer *composer)
{
EMsgComposerPrivate *priv = composer->priv;
EFocusTracker *focus_tracker;
EComposerHeader *header;
EShell *shell;
EClientCache *client_cache;
EHTMLEditor *editor;
EHTMLEditorView *view;
GtkUIManager *ui_manager;
GtkAction *action;
GtkWidget *container;
GtkWidget *widget;
GtkWidget *send_widget;
GtkWindow *window;
GSettings *settings;
const gchar *path;
gchar *filename, *gallery_path;
gint ii;
GError *error = NULL;
editor = e_msg_composer_get_editor (composer);
ui_manager = e_html_editor_get_ui_manager (editor);
view = e_html_editor_get_view (editor);
settings = e_util_ref_settings ("org.gnome.evolution.mail");
shell = e_msg_composer_get_shell (composer);
client_cache = e_shell_get_client_cache (shell);
/* Each composer window gets its own window group. */
window = GTK_WINDOW (composer);
priv->window_group = gtk_window_group_new ();
gtk_window_group_add_window (priv->window_group, window);
priv->async_actions = gtk_action_group_new ("async");
priv->charset_actions = gtk_action_group_new ("charset");
priv->composer_actions = gtk_action_group_new ("composer");
priv->extra_hdr_names = g_ptr_array_new ();
priv->extra_hdr_values = g_ptr_array_new ();
priv->charset = e_composer_get_default_charset ();
priv->is_from_new_message = FALSE;
priv->set_signature_from_message = FALSE;
priv->disable_signature = FALSE;
priv->busy = FALSE;
priv->saved_editable = FALSE;
priv->drop_occured = FALSE;
priv->dnd_is_uri = FALSE;
priv->check_if_signature_is_changed = FALSE;
priv->ignore_next_signature_change = FALSE;
priv->dnd_history_saved = FALSE;
priv->focused_entry = NULL;
e_composer_actions_init (composer);
filename = e_composer_find_data_file ("evolution-composer.ui");
gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error);
g_free (filename);
/* We set the send button as important to have a label */
path = "/main-toolbar/pre-main-toolbar/send";
send_widget = gtk_ui_manager_get_widget (ui_manager, path);
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE);
composer_setup_charset_menu (composer);
if (error != NULL) {
/* Henceforth, bad things start happening. */
g_critical ("%s", error->message);
g_clear_error (&error);
}
/* Configure an EFocusTracker to manage selection actions. */
focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer));
action = e_html_editor_get_action (editor, "cut");
e_focus_tracker_set_cut_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "copy");
e_focus_tracker_set_copy_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "paste");
e_focus_tracker_set_paste_clipboard_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "select-all");
e_focus_tracker_set_select_all_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "undo");
e_focus_tracker_set_undo_action (focus_tracker, action);
action = e_html_editor_get_action (editor, "redo");
e_focus_tracker_set_redo_action (focus_tracker, action);
priv->focus_tracker = focus_tracker;
widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (composer), widget);
gtk_widget_show (widget);
container = widget;
/* Construct the main menu and toolbar. */
widget = e_html_editor_get_managed_widget (editor, "/main-menu");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
widget = e_html_editor_get_managed_widget (editor, "/main-toolbar");
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the header table. */
widget = e_composer_header_table_new (client_cache);
gtk_container_set_border_width (GTK_CONTAINER (widget), 6);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
priv->header_table = g_object_ref (widget);
gtk_widget_show (widget);
header = e_composer_header_table_get_header (
E_COMPOSER_HEADER_TABLE (widget),
E_COMPOSER_HEADER_SUBJECT);
e_binding_bind_property (
view, "spell-checker",
header->input_widget, "spell-checker",
G_BINDING_SYNC_CREATE);
/* Construct the editing toolbars. We'll have to reparent
* the embedded EHTMLEditorView a little further down. */
widget = GTK_WIDGET (editor);
gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0);
gtk_widget_show (widget);
/* Construct the attachment paned. */
widget = e_attachment_paned_new ();
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
priv->attachment_paned = g_object_ref_sink (widget);
gtk_widget_show (widget);
e_binding_bind_property (
view, "editable",
widget, "sensitive",
G_BINDING_SYNC_CREATE);
container = e_attachment_paned_get_content_area (
E_ATTACHMENT_PANED (priv->attachment_paned));
widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0);
gtk_widget_show (widget);
container = widget;
widget = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (
GTK_SCROLLED_WINDOW (widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT);
gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE);
priv->gallery_scrolled_window = g_object_ref (widget);
gtk_widget_show (widget);
/* Reparent the scrolled window containing the web view
* widget into the content area of the top attachment pane. */
widget = GTK_WIDGET (view);
widget = gtk_widget_get_parent (widget);
gtk_widget_reparent (widget, container);
/* Construct the picture gallery. */
container = priv->gallery_scrolled_window;
/* FIXME This should be an EMsgComposer property. */
gallery_path = g_settings_get_string (
settings, "composer-gallery-path");
widget = e_picture_gallery_new (gallery_path);
gtk_container_add (GTK_CONTAINER (container), widget);
priv->gallery_icon_view = g_object_ref_sink (widget);
g_free (gallery_path);
e_signal_connect_notify_swapped (
view, "notify::mode",
G_CALLBACK (composer_update_gallery_visibility), composer);
g_signal_connect_swapped (
ACTION (PICTURE_GALLERY), "toggled",
G_CALLBACK (composer_update_gallery_visibility), composer);
/* Initial sync */
composer_update_gallery_visibility (composer);
/* Bind headers to their corresponding actions. */
for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) {
EComposerHeaderTable *table;
EComposerHeader *header;
GtkAction *action;
table = E_COMPOSER_HEADER_TABLE (priv->header_table);
header = e_composer_header_table_get_header (table, ii);
switch (ii) {
case E_COMPOSER_HEADER_FROM:
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
e_widget_undo_attach (
GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))),
focus_tracker);
action = ACTION (VIEW_FROM_OVERRIDE);
e_binding_bind_property (
header, "override-visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
continue;
case E_COMPOSER_HEADER_BCC:
action = ACTION (VIEW_BCC);
break;
case E_COMPOSER_HEADER_CC:
action = ACTION (VIEW_CC);
break;
case E_COMPOSER_HEADER_REPLY_TO:
action = ACTION (VIEW_REPLY_TO);
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
break;
case E_COMPOSER_HEADER_SUBJECT:
e_widget_undo_attach (
GTK_WIDGET (header->input_widget),
focus_tracker);
continue;
default:
continue;
}
e_binding_bind_property (
header, "sensitive",
action, "sensitive",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
e_binding_bind_property (
header, "visible",
action, "active",
G_BINDING_BIDIRECTIONAL |
G_BINDING_SYNC_CREATE);
}
/* Disable actions that start asynchronous activities while an
* asynchronous activity is in progress. We enforce this with
* a simple inverted binding to EMsgComposer's "busy" property. */
e_binding_bind_property (
composer, "busy",
priv->async_actions, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
e_binding_bind_property (
composer, "busy",
priv->header_table, "sensitive",
G_BINDING_SYNC_CREATE |
G_BINDING_INVERT_BOOLEAN);
g_object_unref (settings);
}
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase)
{
wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase);
GSList* radioGroup;
switch ( tool->GetStyle() )
{
case wxTOOL_STYLE_BUTTON:
switch (tool->GetKind())
{
case wxITEM_CHECK:
tool->m_item = gtk_toggle_tool_button_new();
g_signal_connect(tool->m_item, "toggled",
G_CALLBACK(item_toggled), tool);
break;
case wxITEM_RADIO:
radioGroup = GetRadioGroup(pos);
if (radioGroup)
{
// this is the first button in the radio button group,
// it will be toggled automatically by GTK so bring the
// internal flag in sync
tool->Toggle(true);
}
tool->m_item = gtk_radio_tool_button_new(radioGroup);
g_signal_connect(tool->m_item, "toggled",
G_CALLBACK(item_toggled), tool);
break;
default:
wxFAIL_MSG("unknown toolbar child type");
// fall through
case wxITEM_DROPDOWN:
case wxITEM_NORMAL:
tool->m_item = gtk_tool_button_new(NULL, "");
g_signal_connect(tool->m_item, "clicked",
G_CALLBACK(item_clicked), tool);
break;
}
if (!HasFlag(wxTB_NOICONS))
{
GtkWidget* image = gtk_image_new();
gtk_tool_button_set_icon_widget(
GTK_TOOL_BUTTON(tool->m_item), image);
tool->SetImage();
gtk_widget_show(image);
g_signal_connect(image, "expose_event",
G_CALLBACK(image_expose_event), tool);
}
if (!tool->GetLabel().empty())
{
gtk_tool_button_set_label(
GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel()));
// needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT
gtk_tool_item_set_is_important(tool->m_item, true);
}
if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty())
{
gtk_tool_item_set_tooltip(tool->m_item,
m_tooltips, wxGTK_CONV(tool->GetShortHelp()), "");
}
g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event",
G_CALLBACK(button_press_event), tool);
g_signal_connect(tool->m_item, "enter_notify_event",
G_CALLBACK(enter_notify_event), tool);
g_signal_connect(tool->m_item, "leave_notify_event",
G_CALLBACK(enter_notify_event), tool);
if (tool->GetKind() == wxITEM_DROPDOWN)
tool->CreateDropDown();
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_SEPARATOR:
tool->m_item = gtk_separator_tool_item_new();
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
break;
case wxTOOL_STYLE_CONTROL:
wxWindow* control = tool->GetControl();
if (control->m_widget->parent == NULL)
AddChildGTK(control);
tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent);
if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos))
{
g_object_ref(tool->m_item);
gtk_container_remove(
GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item));
gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos));
g_object_unref(tool->m_item);
}
// Inserted items "slide" into place using an animated effect that
// causes multiple size events on the item. Must set size request
// to keep item size from getting permanently set too small by the
// first of these size events.
const wxSize size = control->GetSize();
gtk_widget_set_size_request(control->m_widget, size.x, size.y);
break;
}
gtk_widget_show(GTK_WIDGET(tool->m_item));
InvalidateBestSize();
return true;
}
static GObject *
debug_dialog_constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
EmpathyDebugDialogPriv *priv;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *image;
GtkWidget *label;
GtkToolItem *item;
GtkCellRenderer *renderer;
GtkListStore *level_store;
GtkTreeIter iter;
object = G_OBJECT_CLASS (empathy_debug_dialog_parent_class)->constructor
(type, n_construct_params, construct_params);
priv = GET_PRIV (object);
gtk_window_set_title (GTK_WINDOW (object), _("Debug Window"));
gtk_window_set_default_size (GTK_WINDOW (object), 800, 400);
vbox = GTK_DIALOG (object)->vbox;
toolbar = gtk_toolbar_new ();
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE);
gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar),
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_widget_show (toolbar);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
/* CM */
priv->cm_chooser = gtk_combo_box_new_text ();
priv->cms = gtk_list_store_new (NUM_COLS_CM, G_TYPE_STRING, G_TYPE_STRING);
gtk_combo_box_set_model (GTK_COMBO_BOX (priv->cm_chooser),
GTK_TREE_MODEL (priv->cms));
gtk_widget_show (priv->cm_chooser);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), priv->cm_chooser);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
g_signal_connect (priv->cm_chooser, "changed",
G_CALLBACK (debug_dialog_cm_chooser_changed_cb), object);
gtk_widget_show (GTK_WIDGET (priv->cm_chooser));
item = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Save */
priv->save_button = gtk_tool_button_new_from_stock (GTK_STOCK_SAVE);
g_signal_connect (priv->save_button, "clicked",
G_CALLBACK (debug_dialog_save_clicked_cb), object);
gtk_widget_show (GTK_WIDGET (priv->save_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->save_button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->save_button, -1);
/* Copy */
priv->copy_button = gtk_tool_button_new_from_stock (GTK_STOCK_COPY);
g_signal_connect (priv->copy_button, "clicked",
G_CALLBACK (debug_dialog_copy_clicked_cb), object);
gtk_widget_show (GTK_WIDGET (priv->copy_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->copy_button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->copy_button, -1);
/* Clear */
priv->clear_button = gtk_tool_button_new_from_stock (GTK_STOCK_CLEAR);
g_signal_connect (priv->clear_button, "clicked",
G_CALLBACK (debug_dialog_clear_clicked_cb), object);
gtk_widget_show (GTK_WIDGET (priv->clear_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->clear_button), TRUE);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->clear_button, -1);
item = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Pause */
priv->paused = FALSE;
image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
priv->pause_button = gtk_toggle_tool_button_new ();
gtk_toggle_tool_button_set_active (
GTK_TOGGLE_TOOL_BUTTON (priv->pause_button), priv->paused);
g_signal_connect (priv->pause_button, "toggled",
G_CALLBACK (debug_dialog_pause_toggled_cb), object);
gtk_widget_show (GTK_WIDGET (priv->pause_button));
gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->pause_button), TRUE);
gtk_tool_button_set_label (GTK_TOOL_BUTTON (priv->pause_button), _("Pause"));
gtk_tool_button_set_icon_widget (
GTK_TOOL_BUTTON (priv->pause_button), image);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->pause_button, -1);
item = gtk_separator_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
/* Level */
priv->level_label = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (priv->level_label));
label = gtk_label_new (_("Level "));
gtk_widget_show (label);
gtk_container_add (GTK_CONTAINER (priv->level_label), label);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->level_label, -1);
priv->level_filter = gtk_combo_box_new_text ();
gtk_widget_show (priv->level_filter);
item = gtk_tool_item_new ();
gtk_widget_show (GTK_WIDGET (item));
gtk_container_add (GTK_CONTAINER (item), priv->level_filter);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);
level_store = gtk_list_store_new (NUM_COLS_LEVEL,
G_TYPE_STRING, G_TYPE_UINT);
gtk_combo_box_set_model (GTK_COMBO_BOX (priv->level_filter),
GTK_TREE_MODEL (level_store));
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Debug"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_DEBUG,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Info"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_INFO,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Message"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_MESSAGE,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Warning"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_WARNING,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Critical"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_CRITICAL,
-1);
gtk_list_store_append (level_store, &iter);
gtk_list_store_set (level_store, &iter,
COL_LEVEL_NAME, _("Error"),
COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_ERROR,
-1);
gtk_combo_box_set_active (GTK_COMBO_BOX (priv->level_filter), 0);
g_signal_connect (priv->level_filter, "changed",
G_CALLBACK (debug_dialog_filter_changed_cb), object);
/* Debug treeview */
priv->view = gtk_tree_view_new ();
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->view), TRUE);
g_signal_connect (priv->view, "button-press-event",
G_CALLBACK (debug_dialog_button_press_event_cb), object);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "yalign", 0, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Time"), renderer, "text", COL_DEBUG_TIMESTAMP, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Domain"), renderer, "text", COL_DEBUG_DOMAIN, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Category"), renderer, "text", COL_DEBUG_CATEGORY, NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Level"), renderer, "text", COL_DEBUG_LEVEL_STRING, NULL);
renderer = gtk_cell_renderer_text_new ();
g_object_set (renderer, "family", "Monospace", NULL);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view),
-1, _("Message"), renderer, "text", COL_DEBUG_MESSAGE, NULL);
priv->store = gtk_list_store_new (NUM_DEBUG_COLS, G_TYPE_DOUBLE,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_UINT);
priv->store_filter = gtk_tree_model_filter_new (
GTK_TREE_MODEL (priv->store), NULL);
gtk_tree_model_filter_set_visible_func (
GTK_TREE_MODEL_FILTER (priv->store_filter),
debug_dialog_visible_func, object, NULL);
gtk_tree_view_set_model (GTK_TREE_VIEW (priv->view), priv->store_filter);
/* Scrolled window */
priv->scrolled_win = g_object_ref (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_win),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_show (priv->view);
gtk_container_add (GTK_CONTAINER (priv->scrolled_win), priv->view);
gtk_widget_show (priv->scrolled_win);
/* Not supported label */
priv->not_supported_label = g_object_ref (gtk_label_new (
_("The selected connection manager does not support the remote "
"debugging extension.")));
gtk_widget_show (priv->not_supported_label);
gtk_box_pack_start (GTK_BOX (vbox), priv->not_supported_label, TRUE, TRUE, 0);
priv->view_visible = FALSE;
debug_dialog_set_toolbar_sensitivity (EMPATHY_DEBUG_DIALOG (object), FALSE);
debug_dialog_fill_cm_chooser (EMPATHY_DEBUG_DIALOG (object));
gtk_widget_show (GTK_WIDGET (object));
return object;
}
