/*
* create_page:
* @child: the #CheeseWidget to pack into the container
* @button: the #GtkButton for taking a photo
*
* Create the widgets for the #CheeseAvatarWidget and pack them into a
* container.
*
* Returns: a #GtkBox containing the individual #CheeseAvatarWidget widgets
*/
static GtkWidget *
create_page (GtkWidget *child,
GtkWidget *button)
{
GtkWidget *vgrid, *bar;
GtkStyleContext *context;
vgrid = gtk_grid_new ();
gtk_grid_attach (GTK_GRID (vgrid),
child, 0, 0, 1, 1);
gtk_widget_set_hexpand (child, TRUE);
gtk_widget_set_vexpand (child, TRUE);
bar = gtk_header_bar_new ();
context = gtk_widget_get_style_context (GTK_WIDGET (bar));
gtk_style_context_remove_class (context, "header-bar");
gtk_style_context_add_class (context, "inline-toolbar");
gtk_style_context_add_class (context, "toolbar");
gtk_style_context_add_class (context, GTK_STYLE_CLASS_HORIZONTAL);
g_object_set (G_OBJECT (button), "margin-top", 6, "margin-bottom", 6, NULL);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (bar), button);
gtk_grid_attach (GTK_GRID (vgrid),
bar, 0, 1, 1, 1);
return vgrid;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *footer;
GtkWidget *button;
GtkWidget *content;
GtkCssProvider *provider;
gtk_init (NULL, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_style_context_add_class (gtk_widget_get_style_context (window), "main");
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider, css, -1, NULL);
gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (window),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
change_header (NULL, window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
footer = gtk_header_bar_new ();
button = gtk_button_new_with_label ("Title");
g_signal_connect (button, "clicked", G_CALLBACK (change_title), footer);
gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_toggle_button_new_with_label ("Custom");
g_signal_connect (button, "clicked", G_CALLBACK (change_header), window);
gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_button_new_with_label ("Subtitle");
g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), NULL);
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
button = gtk_button_new_with_label ("Fullscreen");
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
g_signal_connect (button, "clicked", G_CALLBACK (toggle_fullscreen), window);
gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE, 0);
content = gtk_image_new_from_icon_name ("start-here-symbolic", GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (content), 512);
gtk_box_pack_start (GTK_BOX (box), content, FALSE, TRUE, 0);
gtk_widget_show_all (window);
gtk_main ();
gtk_widget_destroy (window);
return 0;
}
GtkWidget *
create_header_bar (GtkWidget *dialog, const gchar *title)
{
static GtkWidget *header_bar = NULL;
header_bar = gtk_header_bar_new();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header_bar), FALSE);
gtk_header_bar_set_title (GTK_HEADER_BAR (header_bar), title);
gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header_bar), FALSE);
gtk_window_set_titlebar (GTK_WINDOW (dialog), header_bar);
return header_bar;
}
static void
setup_header_bar (GtkWidget *window,
VteTerminal *vtterm,
gboolean show_maximized_title)
{
/*
* Using the default GtkHeaderBar title/subtitle widget makes the bar
* too thick to look nice for a terminal, so set a custom widget.
*/
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5);
const gchar *title = gtk_window_get_title (GTK_WINDOW (window));
GtkWidget *label = gtk_label_new (title ? title : "dwt");
g_object_bind_property (G_OBJECT (vtterm), "window-title",
G_OBJECT (label), "label",
G_BINDING_DEFAULT);
GtkWidget *header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (header), TRUE);
gtk_header_bar_set_has_subtitle (GTK_HEADER_BAR (header), FALSE);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (header), label);
GtkWidget *button = gtk_button_new_from_icon_name ("tab-new-symbolic",
GTK_ICON_SIZE_BUTTON);
gtk_button_set_relief (GTK_BUTTON (button), GTK_RELIEF_NONE);
gtk_actionable_set_action_name (GTK_ACTIONABLE (button), "app.new-terminal");
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
GtkWidget *revealer = gtk_revealer_new ();
gtk_container_add (GTK_CONTAINER (revealer),
gtk_image_new_from_icon_name ("software-update-urgent-symbolic",
GTK_ICON_SIZE_BUTTON));
gtk_revealer_set_transition_duration (GTK_REVEALER (revealer), 500);
gtk_revealer_set_transition_type (GTK_REVEALER (revealer),
GTK_REVEALER_TRANSITION_TYPE_CROSSFADE);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), revealer);
g_signal_connect (G_OBJECT (vtterm), "bell",
G_CALLBACK (header_bar_term_beeped), revealer);
g_object_bind_property (G_OBJECT (window), "urgency-hint",
G_OBJECT (revealer), "reveal-child",
G_BINDING_DEFAULT);
gtk_window_set_titlebar (GTK_WINDOW (window), header);
/* Hide the header bar when the window is maximized. */
if (!show_maximized_title) {
g_object_bind_property (G_OBJECT (window), "is-maximized",
G_OBJECT (header), "visible",
G_BINDING_INVERT_BOOLEAN);
}
}
static void
change_header (GtkButton *button, gpointer data)
{
GtkWidget *window = GTK_WIDGET (data);
GtkWidget *label;
GtkWidget *widget;
GtkWidget *image;
GtkWidget *box;
if (button && gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
{
header = gtk_event_box_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (header), "titlebar");
gtk_style_context_add_class (gtk_widget_get_style_context (header), "header-bar");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
g_object_set (box, "margin", 10, NULL);
gtk_container_add (GTK_CONTAINER (header), box);
label = gtk_label_new ("Label");
gtk_box_pack_start (GTK_BOX (box), label, FALSE, TRUE);
widget = gtk_level_bar_new ();
gtk_level_bar_set_value (GTK_LEVEL_BAR (widget), 0.4);
gtk_box_pack_start (GTK_BOX (box), widget, TRUE, TRUE);
gtk_widget_show_all (header);
}
else
{
header = gtk_header_bar_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (header), "titlebar");
gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Example header");
widget = gtk_button_new_with_label ("_Close");
gtk_button_set_use_underline (GTK_BUTTON (widget), TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (widget), "suggested-action");
g_signal_connect (widget, "clicked", G_CALLBACK (gtk_main_quit), NULL);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), widget);
widget= gtk_button_new ();
image = gtk_image_new_from_icon_name ("bookmark-new-symbolic", GTK_ICON_SIZE_BUTTON);
g_signal_connect (widget, "clicked", G_CALLBACK (on_bookmark_clicked), window);
gtk_container_add (GTK_CONTAINER (widget), image);
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), widget);
gtk_widget_show_all (header);
}
gtk_window_set_titlebar (GTK_WINDOW (window), header);
}
void
ManageDB_sidebar(GtkApplication *application){
GtkWidget *sidebar;
GtkWidget *stack;
GtkWidget *box;
GtkWidget *widget;
GtkWidget *header;
windowdb = gtk_application_window_new (application);
header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(header), TRUE);
gtk_window_set_titlebar (GTK_WINDOW(windowdb), header);
gtk_window_set_title(GTK_WINDOW(windowdb), "Gerenciamento do Banco de Dados");
gtk_window_set_default_size (GTK_WINDOW (windowdb), 500, 500);
g_signal_connect (windowdb, "destroy",
G_CALLBACK (gtk_widget_destroyed), &windowdb);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
sidebar = gtk_stack_sidebar_new ();
gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE, 0);
stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
/* Separator between sidebar and stack */
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX(box), widget, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE, 0);
/* Precisamos adicionar as ações... */
Welcome_side(widget, stack);
Create_side(widget, stack);
Backup_side(widget, stack);
Restore_side(widget, stack);
Delete_side(widget, stack);
Advanced_side(widget, stack);
gtk_container_add (GTK_CONTAINER (windowdb), box);
gtk_widget_show_all (windowdb);
}
void WebInspectorProxy::createInspectorWindow()
{
if (m_client.openWindow(this))
return;
ASSERT(!m_inspectorWindow);
m_inspectorWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget* inspectedViewParent = gtk_widget_get_toplevel(m_page->viewWidget());
if (WebCore::widgetIsOnscreenToplevelWindow(inspectedViewParent))
gtk_window_set_transient_for(GTK_WINDOW(m_inspectorWindow), GTK_WINDOW(inspectedViewParent));
#if GTK_CHECK_VERSION(3, 10, 0)
m_headerBar = gtk_header_bar_new();
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(m_headerBar), TRUE);
m_dockBottomButton = gtk_button_new();
g_object_add_weak_pointer(G_OBJECT(m_dockBottomButton), reinterpret_cast<void**>(&m_dockBottomButton));
g_signal_connect(m_dockBottomButton, "clicked", G_CALLBACK(dockButtonClicked), this);
gtk_widget_set_sensitive(m_dockBottomButton, canAttach());
gtk_button_set_relief(GTK_BUTTON(m_dockBottomButton), GTK_RELIEF_NONE);
gtk_button_set_image(GTK_BUTTON(m_dockBottomButton), gtk_image_new_from_resource("/org/webkitgtk/inspector/UserInterface/Images/DockBottom.svg"));
gtk_header_bar_pack_start(GTK_HEADER_BAR(m_headerBar), m_dockBottomButton);
gtk_widget_show(m_dockBottomButton);
m_dockRightButton = gtk_button_new();
g_object_add_weak_pointer(G_OBJECT(m_dockRightButton), reinterpret_cast<void**>(&m_dockRightButton));
g_signal_connect(m_dockRightButton, "clicked", G_CALLBACK(dockButtonClicked), this);
gtk_widget_set_sensitive(m_dockRightButton, canAttach());
gtk_button_set_relief(GTK_BUTTON(m_dockRightButton), GTK_RELIEF_NONE);
gtk_button_set_image(GTK_BUTTON(m_dockRightButton), gtk_image_new_from_resource("/org/webkitgtk/inspector/UserInterface/Images/DockRight.svg"));
gtk_header_bar_pack_start(GTK_HEADER_BAR(m_headerBar), m_dockRightButton);
gtk_widget_show(m_dockRightButton);
gtk_window_set_titlebar(GTK_WINDOW(m_inspectorWindow), m_headerBar);
gtk_widget_show(m_headerBar);
#endif
updateInspectorWindowTitle();
gtk_window_set_default_size(GTK_WINDOW(m_inspectorWindow), initialWindowWidth, initialWindowHeight);
gtk_container_add(GTK_CONTAINER(m_inspectorWindow), m_inspectorView);
gtk_widget_show(m_inspectorView);
g_object_add_weak_pointer(G_OBJECT(m_inspectorWindow), reinterpret_cast<void**>(&m_inspectorWindow));
gtk_window_present(GTK_WINDOW(m_inspectorWindow));
}
GtkWidget*
conversation_page_new (Ekiga::ConversationPtr conversation)
{
ConversationPage* result = NULL;
GtkWidget* header = NULL;
GtkWidget* box = NULL;
GtkWidget* area = NULL;
GtkWidget* heapview = NULL;
result = (ConversationPage*)g_object_new (TYPE_CONVERSATION_PAGE,
"orientation", GTK_ORIENTATION_VERTICAL,
NULL);
result->priv->conversation = conversation;
result->priv->title = NULL;
result->priv->connections.add (conversation->updated.connect (boost::bind (&on_conversation_updated, result)));
header = gtk_header_bar_new ();
result->priv->header = header;
gtk_box_pack_start (GTK_BOX (result), header,
FALSE, FALSE, 2);
gtk_widget_show (header);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2);
gtk_box_pack_start (GTK_BOX (result), box,
TRUE, TRUE, 2);
gtk_widget_show (box);
area = chat_area_new (conversation);
result->priv->area = area;
gtk_box_pack_start (GTK_BOX (box), area,
TRUE, TRUE, 2);
gtk_widget_show (area);
heapview = heap_view_new (conversation->get_heap());
result->priv->heapview = heapview;
gtk_box_pack_start (GTK_BOX (box), heapview,
TRUE, TRUE, 2);
gtk_widget_show (heapview);
conversation_page_update_title_and_status (result);
return GTK_WIDGET (result);
}
static void
ekiga_window_init_actions_toolbar (EkigaWindow *mw)
{
GtkWidget *image = NULL;
GtkWidget *button = NULL;
GtkWidget *switcher = NULL;
g_return_if_fail (EKIGA_IS_WINDOW (mw));
mw->priv->actions_toolbar = gtk_header_bar_new ();
gtk_window_set_titlebar (GTK_WINDOW (mw), mw->priv->actions_toolbar);
/* Start packing buttons */
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("call-start-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (button), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (button),
_("Call the selected contact"));
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (button), "win.call");
gtk_header_bar_pack_start (GTK_HEADER_BAR (mw->priv->actions_toolbar), button);
mw->priv->preview_button = gtk_toggle_button_new ();
image = gtk_image_new_from_icon_name ("camera-web-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (mw->priv->preview_button), image);
gtk_widget_set_tooltip_text (GTK_WIDGET (mw->priv->preview_button),
_("Display images from your camera device"));
gtk_actionable_set_detailed_action_name (GTK_ACTIONABLE (mw->priv->preview_button),
"win.enable-preview");
gtk_header_bar_pack_start (GTK_HEADER_BAR (mw->priv->actions_toolbar), mw->priv->preview_button);
switcher = gtk_stack_switcher_new ();
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER (switcher), GTK_STACK (mw->priv->main_stack));
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (mw->priv->actions_toolbar), switcher);
gtk_widget_set_margin_end (GTK_WIDGET (switcher), 6);
mw->priv->menu_button = gtk_menu_button_new ();
g_object_set (G_OBJECT (mw->priv->menu_button), "use-popover", true, NULL);
image = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_MENU);
gtk_button_set_image (GTK_BUTTON (mw->priv->menu_button), image);
gtk_header_bar_pack_end (GTK_HEADER_BAR (mw->priv->actions_toolbar), mw->priv->menu_button);
gtk_widget_show_all (mw->priv->actions_toolbar);
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (mw->priv->actions_toolbar), TRUE);
}
static void
_gth_window_add_header_bar (GthWindow *self)
{
self->priv->headerbar = gtk_header_bar_new ();
gtk_widget_show (self->priv->headerbar);
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (self->priv->headerbar), TRUE);
g_object_add_weak_pointer (G_OBJECT (self->priv->headerbar), &self->priv->headerbar);
#if GTK_CHECK_VERSION(3,12,0)
{
gboolean shell_shows_app_menu;
char *decoration_layout;
g_object_get (gtk_settings_get_default (),
"gtk-shell-shows-app-menu", &shell_shows_app_menu,
"gtk-decoration-layout", &decoration_layout,
NULL);
if (! shell_shows_app_menu && ((decoration_layout == NULL) || (strstr (decoration_layout, "menu") == NULL))) {
gboolean left_part_is_empty;
char *new_layout;
/* add 'menu' to the left */
left_part_is_empty = (decoration_layout == NULL) || (decoration_layout[0] == '\0') || (decoration_layout[0] == ':');
new_layout = g_strconcat ("menu", (left_part_is_empty ? "" : ","), decoration_layout, NULL);
gtk_header_bar_set_decoration_layout (GTK_HEADER_BAR (self->priv->headerbar), new_layout);
g_free (new_layout);
}
g_free (decoration_layout);
}
#endif
self->priv->title = gth_window_title_new ();
gtk_widget_show (self->priv->title);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (self->priv->headerbar), self->priv->title);
self->priv->headerbar_container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show (self->priv->headerbar_container);
gtk_box_pack_start (GTK_BOX (self->priv->headerbar_container), self->priv->headerbar, TRUE, TRUE, 0);
gtk_window_set_titlebar (GTK_WINDOW (self), self->priv->headerbar_container);
}
static void
gtimer_window_construct_ui (GTimerWindow *window)
{
GtkWidget *headerbar;
GtkWidget *gtimer_face;
g_return_if_fail (GTIMER_IS_WINDOW (window));
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (headerbar), TRUE);
gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), g_get_application_name ());
gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
gtimer_face = gtimer_face_new ();
gtk_container_add (GTK_CONTAINER (window), gtimer_face);
gtk_widget_show_all (GTK_WIDGET (window));
}
GtkWidget *
do_paint (GtkWidget *toplevel)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *draw_area, *headerbar, *colorbutton;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
draw_area = drawing_area_new ();
gtk_container_add (GTK_CONTAINER (window), draw_area);
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Paint");
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (headerbar), TRUE);
colorbutton = gtk_color_button_new ();
g_signal_connect (colorbutton, "color-set",
G_CALLBACK (color_button_color_set), draw_area);
g_signal_connect (draw_area, "color-set",
G_CALLBACK (drawing_area_color_set), colorbutton);
gtk_color_chooser_set_rgba (GTK_COLOR_CHOOSER (colorbutton),
&(GdkRGBA) { 0, 0, 0, 1 });
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), colorbutton);
gtk_window_set_titlebar (GTK_WINDOW (window), headerbar);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
static void
bjb_selection_toolbar_init (BjbSelectionToolbar *self)
{
BjbSelectionToolbarPrivate *priv;
GtkWidget *widget;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, BJB_TYPE_SELECTION_TOOLBAR, BjbSelectionToolbarPrivate);
priv = self->priv;
widget = GTK_WIDGET (self);
gtk_revealer_set_transition_type (
GTK_REVEALER (self), GTK_REVEALER_TRANSITION_TYPE_SLIDE_UP);
priv->bar = GTK_HEADER_BAR (gtk_header_bar_new ());
gtk_container_add (GTK_CONTAINER (self), GTK_WIDGET (priv->bar));
/* Trash notes */
priv->toolbar_trash = gtk_button_new_with_label (_("Delete"));
gtk_header_bar_pack_start (priv->bar, priv->toolbar_trash);
/* Notes color */
priv->toolbar_color = bjb_color_button_new ();
gtk_widget_set_tooltip_text (GTK_WIDGET (priv->toolbar_color),
_("Note color"));
gtk_header_bar_pack_end (priv->bar, priv->toolbar_color);
/* Notes tags */
priv->toolbar_tag = gtk_button_new_with_label (_("Add to Collection"));
gtk_header_bar_pack_end (priv->bar, priv->toolbar_tag);
gtk_widget_show_all (widget);
bjb_selection_toolbar_fade_out (self);
}
MidiogreApp *midiogre_app_init(void)
{
MidiogreApp *app;
GtkWidget *header;
GtkWidget *separator;
GtkWidget *scrolled;
GtkWidget *label,*frame;
GtkWidget *button;
GtkBox *box;
gint i;
GError *err;
/* Allocate app */
app = calloc(1, sizeof(MidiogreApp));
/* Setup window */
app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400);
g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL);
gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err));
/* Setup header bar */
header = gtk_header_bar_new();
gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre");
gtk_window_set_titlebar(app->window, header);
/* Setup close button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window);
/* Add seperator */
separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator);
/* Setup folder button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window);
/* Global horizontal box */
app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box));
/* Scroll container for sidepanel */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0);
/* Sidepanel box */
app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box));
gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10);
/* Frame with favorit info */
frame = gtk_frame_new("Favorite");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box));
/* Current favorite */
app->fav_title_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_title_label, 20);
gtk_label_set_width_chars(app->fav_title_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0);
app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!"));
gtk_label_set_max_width_chars(app->fav_artist_label, 20);
gtk_label_set_width_chars(app->fav_artist_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0);
app->fav_album_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_album_label, 20);
gtk_label_set_width_chars(app->fav_album_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0);
/* Frame with search criteria widgets */
frame = gtk_frame_new("Search");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10));
gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box));
/* Title entry */
frame = gtk_frame_new("Title");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0);
/* Artist entry */
frame = gtk_frame_new("Artist");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->artist_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0);
/* Album entry */
frame = gtk_frame_new("Album");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->album_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0);
/* Instrument class buttons */
frame = gtk_frame_new("Instrument Classes");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
app->instr_grid = GTK_GRID(gtk_grid_new());
#if GTK_MINOR_VERSION >= 12
gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10);
#else
gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10);
#endif
gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid));
for (i = 0; i < INSTR_CLASSES; i++) {
label = gtk_label_new(instrument_classes[i]);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1);
app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END);
gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1);
}
/* Result spinbutton */
frame = gtk_frame_new("Max result");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1));
gtk_spin_button_set_value(app->result_spinbutton, 25);
gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0);
/* Search button */
app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search"));
gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0);
g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app);
/* Songboxes notebook (Tabsview) */
app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE);
gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0);
/* Add song boxes */
app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical");
app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint");
app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match");
app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity");
app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest");
/* Show all widgets */
gtk_widget_show_all(GTK_WIDGET(app->window));
/* Allocate song queue */
app->songs[SONGBOX_ALPHA] = g_queue_new();
app->songs[SONGBOX_FPRNT] = g_queue_new();
app->songs[SONGBOX_BEST] = g_queue_new();
app->songs[SONGBOX_POP] = g_queue_new();
app->songs[SONGBOX_NEW] = g_queue_new();
return app;
}
static void
GyahtzeeCreateMainWindow (GApplication *app, gpointer user_data)
{
GtkWidget *hbox, *vbox;
GtkWidget *toolbar;
GtkWidget *tmp;
GtkWidget *dicebox;
GtkWidget *undo_button;
GtkWidget *menu_button;
GtkWidget *icon;
GtkBuilder *builder;
GMenuModel *appmenu;
int i, j;
window = gtk_application_window_new (application);
gtk_window_set_application (GTK_WINDOW (window), application);
gtk_window_set_title (GTK_WINDOW (window), _(appName));
gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), FALSE);
gtk_window_set_icon_name (GTK_WINDOW (window), "org.gnome.Tali");
//games_conf_add_window (GTK_WINDOW (window), NULL);
g_signal_connect (GTK_WIDGET (window), "key_press_event",
G_CALLBACK (key_press), NULL);
g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application);
const gchar *vaccels_help[] = {"F1", NULL};
const gchar *vaccels_new[] = {"<Primary>n", NULL};
const gchar *vaccels_roll[] = {"<Primary>r", NULL};
const gchar *vaccels_undo[] = {"<Primary>z", NULL};
gtk_application_set_accels_for_action (application, "app.help", vaccels_help);
gtk_application_set_accels_for_action (application, "app.new-game", vaccels_new);
gtk_application_set_accels_for_action (application, "app.roll", vaccels_roll);
gtk_application_set_accels_for_action (application, "app.undo", vaccels_undo);
scores_action = g_action_map_lookup_action (G_ACTION_MAP (application), "scores");
undo_action = g_action_map_lookup_action (G_ACTION_MAP (application), "undo");
update_undo_sensitivity ();
/*--- Headerbar ---*/
hbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (hbar), TRUE);
gtk_header_bar_set_title (GTK_HEADER_BAR (hbar), _(appName));
gtk_widget_show (hbar);
gtk_window_set_titlebar (GTK_WINDOW (window), hbar);
if (gtk_widget_get_default_direction () == GTK_TEXT_DIR_RTL)
undo_button = gtk_button_new_from_icon_name ("edit-undo-rtl-symbolic", GTK_ICON_SIZE_BUTTON);
else
undo_button = gtk_button_new_from_icon_name ("edit-undo-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_widget_set_valign (undo_button, GTK_ALIGN_CENTER);
gtk_actionable_set_action_name (GTK_ACTIONABLE (undo_button), "app.undo");
gtk_widget_set_tooltip_text (undo_button, _("Undo your most recent move"));
gtk_widget_show (undo_button);
gtk_header_bar_pack_start (GTK_HEADER_BAR (hbar), undo_button);
builder = gtk_builder_new_from_resource ("/org/gnome/Tali/ui/menus.ui");
appmenu = (GMenuModel *) gtk_builder_get_object (builder, "app-menu");
menu_button = gtk_menu_button_new();
icon = gtk_image_new_from_icon_name ("open-menu-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image (GTK_BUTTON (menu_button), icon);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (menu_button), appmenu);
gtk_widget_show (menu_button);
gtk_header_bar_pack_end (GTK_HEADER_BAR (hbar), menu_button);
/*---- Content ----*/
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
/* Retreive dice pixmaps from memory or files */
LoadDicePixmaps ();
/* Put all the dice in a vertical column */
dicebox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start (GTK_BOX (hbox), dicebox, FALSE, TRUE, 0);
gtk_widget_show (dicebox);
rollLabel = gtk_label_new (NULL);
gtk_label_set_use_markup (GTK_LABEL (rollLabel), TRUE);
gtk_widget_show (rollLabel);
gtk_box_pack_start (GTK_BOX (dicebox), rollLabel, FALSE, TRUE, 5);
mbutton = gtk_button_new_with_label (_("Roll!"));
gtk_box_pack_end (GTK_BOX (dicebox), mbutton, FALSE, FALSE, 5);
g_signal_connect (GTK_BUTTON (mbutton), "clicked",
G_CALLBACK (roll_button_pressed_cb), NULL);
gtk_widget_show (GTK_WIDGET (mbutton));
toolbar = gtk_toolbar_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar),
GTK_ORIENTATION_VERTICAL);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), FALSE);
gtk_box_pack_end (GTK_BOX (dicebox), toolbar, TRUE, TRUE, 0);
for (i = 0; i < NUMBER_OF_DICE; i++) {
tmp = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
for (j = 0; j < NUMBER_OF_PIXMAPS; j++) {
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_YAHTZEE], FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (tmp), dicePixmaps[i][j][GAME_KISMET], FALSE, FALSE, 0);
}
diceBox[i] = gtk_toggle_tool_button_new ();
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (diceBox[i]), tmp);
g_signal_connect (GTK_TOOL_BUTTON (diceBox[i]), "clicked",
G_CALLBACK (modify_dice), &DiceValues[i]);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar),
GTK_TOOL_ITEM (diceBox[i]), -1);
gtk_widget_show (GTK_WIDGET (diceBox[i]));
gtk_widget_show (tmp);
/*gtk_widget_show (dicePixmaps[i][0][game_type]);*/
}
gtk_widget_show (toolbar);
/* Scores displayed in score list */
ScoreList = create_score_list ();
gtk_box_pack_end (GTK_BOX (hbox), ScoreList, TRUE, TRUE, 0);
setup_score_list (ScoreList);
gtk_widget_show (ScoreList);
gtk_widget_show (hbox);
gtk_widget_show (vbox);
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *box;
GtkWidget *header;
GtkWidget *footer;
GtkWidget *button;
GtkWidget *image;
GtkWidget *content;
GtkCssProvider *provider;
gtk_init (NULL, NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
header = gtk_header_bar_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (header), "titlebar");
provider = gtk_css_provider_new ();
gtk_css_provider_load_from_data (provider, css, -1, NULL);
gtk_style_context_add_provider_for_screen (gtk_widget_get_screen (window),
GTK_STYLE_PROVIDER (provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
gtk_header_bar_set_title (GTK_HEADER_BAR (header), "Example header");
button = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_style_context_add_class (gtk_widget_get_style_context (button), "suggested-action");
g_signal_connect (button, "clicked", G_CALLBACK (gtk_main_quit), NULL);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), button);
button = gtk_button_new ();
image = gtk_image_new_from_icon_name ("bookmark-new-symbolic", GTK_ICON_SIZE_BUTTON);
gtk_container_add (GTK_CONTAINER (button), image);
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), button);
gtk_window_set_titlebar (GTK_WINDOW (window), header);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
footer = gtk_header_bar_new ();
button = gtk_button_new_with_label ("Start");
g_signal_connect (button, "clicked", G_CALLBACK (change_title), footer);
gtk_header_bar_pack_start (GTK_HEADER_BAR (footer), button);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (footer), gtk_check_button_new_with_label ("Middle"));
button = gtk_button_new_with_label ("End 1");
g_signal_connect (button, "clicked", G_CALLBACK (change_subtitle), header);
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), button);
gtk_header_bar_pack_end (GTK_HEADER_BAR (footer), gtk_button_new_with_label ("End 2"));
gtk_box_pack_end (GTK_BOX (box), footer, FALSE, FALSE, 0);
content = gtk_image_new_from_icon_name ("start-here-symbolic", GTK_ICON_SIZE_DIALOG);
gtk_image_set_pixel_size (GTK_IMAGE (content), 512);
gtk_box_pack_start (GTK_BOX (box), content, FALSE, TRUE, 0);
gtk_widget_show_all (window);
gtk_main ();
return 0;
}
PocketvoxSetup* pocketvox_setup_new()
{
PocketvoxSetup *setup = (PocketvoxSetup *)g_object_new(TYPE_POCKETVOX_SETUP, NULL);
setup->priv = G_TYPE_INSTANCE_GET_PRIVATE (setup,
TYPE_POCKETVOX_SETUP, PocketvoxSetupPrivate);
PocketvoxSetupPrivate *priv = setup->priv;
bindtextdomain (GETTEXT_PACKAGE, PROGRAMNAME_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain(GETTEXT_PACKAGE);
priv->settings = g_settings_new("org.pocketvox.config");
//Build the window
priv->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(priv->window), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_title(GTK_WINDOW(priv->window), "pocketvox-gtk");
gtk_window_set_default_size(GTK_WINDOW(priv->window), 500, 350);
gtk_window_set_icon_name(GTK_WINDOW(priv->window), "pocketvox");
gtk_container_set_border_width(GTK_CONTAINER(priv->window), 5);
g_signal_connect_swapped(priv->window, "delete-event", G_CALLBACK(pocketvox_setup_save_and_quit), setup);
GtkWidget *bar = gtk_header_bar_new();
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(bar), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(priv->window), bar);
//add a vertical box
GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add(GTK_CONTAINER(priv->window), box);
//a button for all
GtkWidget* button_notification = gtk_button_new_with_label(_("Notifications"));
GtkWidget* button_user = gtk_button_new_with_label(_("Users"));
GtkWidget* button_pocketsphinx = gtk_button_new_with_label(_("Pocketsphinx"));
GtkWidget* button_gstreamer = gtk_button_new_with_label(_("Gstreamer"));
gtk_widget_set_tooltip_text(button_notification, _("Display notifications parameters"));
gtk_widget_set_tooltip_text(button_user, _("Display user parameters"));
gtk_widget_set_tooltip_text(button_pocketsphinx, _("Display pocketsphinx parameters"));
gtk_widget_set_tooltip_text(button_gstreamer, _("Display gstreamer parameters"));
gtk_button_set_relief(GTK_BUTTON(button_notification), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(button_user), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(button_pocketsphinx), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(button_gstreamer), GTK_RELIEF_NONE);
GtkWidget *grid_button = gtk_grid_new();
gtk_grid_attach(GTK_GRID(grid_button), button_user, 0, 0, 1, 1);
gtk_grid_attach(GTK_GRID(grid_button), button_notification, 0, 1, 1, 1);
gtk_grid_attach(GTK_GRID(grid_button), button_pocketsphinx, 0, 2, 1, 1);
gtk_grid_attach(GTK_GRID(grid_button), button_gstreamer, 0, 3, 1, 1);
GtkWidget* grid_notification = pocketvox_setup_get_notification_grid(setup);
GtkWidget* grid_user = pocketvox_setup_get_user_grid(setup);
GtkWidget* grid_pocketsphinx = pocketvox_setup_get_pocketsphinx_grid(setup);
GtkWidget* grid_gstreamer = pocketvox_setup_get_gstreamer_grid(setup);
//connect all signals (TODO)
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_show), grid_notification);
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx);
g_signal_connect_swapped(button_notification, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_show), grid_pocketsphinx);
g_signal_connect_swapped(button_pocketsphinx, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_show), grid_user);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx);
g_signal_connect_swapped(button_user, "clicked", G_CALLBACK(gtk_widget_hide), grid_gstreamer);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_notification);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_user);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_hide), grid_pocketsphinx);
g_signal_connect_swapped(button_gstreamer, "clicked", G_CALLBACK(gtk_widget_show), grid_gstreamer);
//add
GtkWidget* gridBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_user, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_notification, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_pocketsphinx, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(gridBox), grid_gstreamer, TRUE, TRUE, 0);
GtkWidget* separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_widget_show(separator);
GtkWidget *hgridBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(hgridBox), grid_button, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hgridBox), separator, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(hgridBox), gridBox, TRUE, TRUE, 0);
GtkWidget *stack = gtk_stack_new();
gtk_stack_set_transition_type(GTK_STACK(stack) , GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT_RIGHT);
gtk_stack_set_transition_duration(GTK_STACK(stack), 1000);
gtk_stack_add_titled(GTK_STACK(stack), hgridBox, "Setup", _("Configuration"));
GtkWidget* scrolledWindow = gtk_scrolled_window_new(NULL, NULL);
//return void
pocketvox_setup_get_modules_grid(setup);
gtk_container_add(GTK_CONTAINER(scrolledWindow), priv->listBox);
gtk_widget_show_all(scrolledWindow);
gtk_stack_add_titled(GTK_STACK(stack), scrolledWindow, "Modules", _("Modules"));
//adding a task switcher
GtkWidget* stackSwitcher = gtk_stack_switcher_new();
gtk_stack_switcher_set_stack(GTK_STACK_SWITCHER(stackSwitcher), GTK_STACK(stack));
gtk_header_bar_set_custom_title(GTK_HEADER_BAR(bar), stackSwitcher);
GtkWidget *add_module_button = gtk_button_new_from_icon_name("gtk-new", GTK_ICON_SIZE_MENU);
GtkWidget *remove_module_button = gtk_button_new_from_icon_name("gtk-delete", GTK_ICON_SIZE_MENU);
gtk_button_set_relief(GTK_BUTTON(add_module_button), GTK_RELIEF_NONE);
gtk_button_set_relief(GTK_BUTTON(remove_module_button), GTK_RELIEF_NONE);
gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), add_module_button);
gtk_header_bar_pack_start(GTK_HEADER_BAR(bar), remove_module_button);
g_signal_connect_swapped(remove_module_button, "clicked", G_CALLBACK(pocketvox_setup_remove_module), setup);
g_signal_connect_swapped(add_module_button, "clicked", G_CALLBACK(pocketvox_setup_add_module_callback), setup);
g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), add_module_button);
g_signal_connect_swapped(stack, "notify::visible-child", G_CALLBACK(pocketvox_stack_child_changed), remove_module_button);
//add them to the vbox
gtk_box_pack_start(GTK_BOX(box), stack, TRUE, TRUE, 0);
gtk_widget_show(grid_user);
gtk_widget_hide(grid_notification);
gtk_widget_hide(grid_pocketsphinx);
gtk_widget_hide(grid_gstreamer);
gtk_widget_show(gridBox);
gtk_widget_show_all(grid_button);
gtk_widget_show(hgridBox);
gtk_widget_show(box);
gtk_widget_show(stack);
gtk_widget_show(stackSwitcher);
gtk_widget_show_all(bar);
//get the setup
return setup;
}
/**
* Creates empty main application window
*/
GtkWidget
*create_mainwindow (ezeedo_wrapper_structure *ezeedo)
{
// define widgets
GtkWidget *window;
GtkWidget *headerbar;
GtkWidget *windowmenu_button;
GtkWidget *stack;
GtkWidget *stackswitcher;
GtkWidget *todo_stack;
GtkWidget *todo_paned;
GtkWidget *todolist_scrollbox;
GtkWidget *todolist_box;
GtkWidget *categories_scrollbox;
GtkWidget *categories_box;
GtkWidget *task_entry;
GtkWidget *done_stack;
GtkWidget *donelist_scrollbox;
GtkWidget *donelist_box;
GtkWidget *archive_button;
// define action
GSimpleAction *about_action;
// get window size and position from gsettings store
GSettings *settings;
gint width;
gint height;
gint x;
gint y;
gint sidebar_size;
settings = g_settings_new ("org.y20k.ezeedo");
width = g_settings_get_int (settings,
"main-window-width");
height = g_settings_get_int (settings,
"main-window-height");
x = g_settings_get_int (settings,
"main-window-position-y");
y = g_settings_get_int (settings,
"main-window-position-y");
sidebar_size = g_settings_get_int (settings,
"sidebar-size");
g_object_unref (settings);
// create main window with title and default size
window = gtk_application_window_new (ezeedo->application);
gtk_window_set_title (GTK_WINDOW (window),
"Ezeedo");
gtk_window_set_icon_name (GTK_WINDOW (window),
EZEEDOICON);
gtk_window_set_default_size (GTK_WINDOW (window),
width,
height);
gtk_window_move (GTK_WINDOW (window),
x,
y);
// create headerbar and stack switcher
headerbar = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(headerbar),
true);
stackswitcher = gtk_stack_switcher_new ();
// create stack for todo and done
stack = gtk_stack_new ();
// create stack for todolist
todo_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create paned container for left and right columns of todo tab
todo_paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED(todo_paned),
sidebar_size);
// create categories scrollbox and box for left pane
categories_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
categories_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create todolist scrollbox and box for right pane
todolist_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
todolist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create task entry
task_entry = gtk_entry_new ();
gtk_widget_set_margin_start (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_end (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_top (GTK_WIDGET(task_entry),
10);
gtk_widget_set_margin_bottom (GTK_WIDGET(task_entry),
10);
gtk_entry_set_placeholder_text (GTK_ENTRY(task_entry),
"Enter new task");
gtk_entry_set_max_length (GTK_ENTRY(task_entry),
TASKLENGTH);
gtk_widget_grab_focus (task_entry);
// create stack for donelist
done_stack = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create donelist scrollbox and box
donelist_scrollbox = gtk_scrolled_window_new (NULL,
NULL);
donelist_box = gtk_box_new (GTK_ORIENTATION_VERTICAL,
0);
// create archive button
archive_button = gtk_button_new_with_label ("Archive all done tasks");
gtk_widget_set_margin_start (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_end (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_top (GTK_WIDGET (archive_button),
10);
gtk_widget_set_margin_bottom (GTK_WIDGET (archive_button),
10);
// add some widgets to ezeedo wrapper structure
ezeedo->window = window;
ezeedo->todo_paned = todo_paned;
ezeedo->categories_box = categories_box;
ezeedo->todolist_box = todolist_box;
ezeedo->donelist_box = donelist_box;
// create window menu
windowmenu_button = create_windowmenu (ezeedo);
// create about action and connect about action signal
about_action = g_simple_action_new ("about",
NULL);
g_action_map_add_action (G_ACTION_MAP (window),
G_ACTION (about_action));
g_signal_connect (about_action, "activate",
G_CALLBACK (show_about_window), window);
// detect entry signal
g_signal_connect (task_entry, "activate",
G_CALLBACK (add_task_entry), ezeedo);
// detect archive button pressed
g_signal_connect (archive_button, "clicked",
G_CALLBACK (display_info_dialog), "Task archival is not supported yet.");
// detect window close
g_signal_connect (G_OBJECT (window), "delete-event",
G_CALLBACK (close_window), ezeedo);
// construct headerbar for main window
gtk_window_set_titlebar (GTK_WINDOW(window),
headerbar);
gtk_header_bar_pack_start (GTK_HEADER_BAR(headerbar),
stackswitcher);
gtk_header_bar_pack_end (GTK_HEADER_BAR(headerbar),
windowmenu_button);
// add stack to main window
gtk_container_add (GTK_CONTAINER(window),
stack);
// set stack switcher and populate stack with todolist and donelist
gtk_stack_switcher_set_stack (GTK_STACK_SWITCHER(stackswitcher),
GTK_STACK(stack));
gtk_stack_add_titled (GTK_STACK(stack),
todo_stack,
"To do",
"To do");
gtk_stack_add_titled (GTK_STACK(stack),
done_stack,
"Done",
"Done");
// construct main todo stack
gtk_container_add (GTK_CONTAINER(todo_stack),
todo_paned);
gtk_paned_add1 (GTK_PANED(todo_paned),
categories_scrollbox);
gtk_paned_add2 (GTK_PANED(todo_paned),
todolist_scrollbox);
// add box to scrollable box
gtk_container_add (GTK_CONTAINER(todolist_scrollbox),
todolist_box);
// add task entry to todo stack
gtk_container_add (GTK_CONTAINER(todo_stack),
task_entry);
// add box to scrollable box
gtk_container_add (GTK_CONTAINER(categories_scrollbox),
categories_box);
// construct main donelist stack
gtk_container_add (GTK_CONTAINER(done_stack),
donelist_scrollbox);
gtk_container_add (GTK_CONTAINER(donelist_scrollbox),
donelist_box);
return (window);
}
GtkWidget *
reader_window_new(GtkApplication *application,
CainteoirSettings *settings,
CainteoirSpeechSynthesizers *synthesizers,
const gchar *filename)
{
ReaderWindow *reader = READER_WINDOW(g_object_new(READER_TYPE_WINDOW,
"application", application,
nullptr));
ReaderWindowPrivate *priv = READER_WINDOW_PRIVATE(reader);
priv->self = GTK_WIDGET(reader);
priv->settings = CAINTEOIR_SETTINGS(g_object_ref(G_OBJECT(settings)));
priv->tts = CAINTEOIR_SPEECH_SYNTHESIZERS(g_object_ref(G_OBJECT(synthesizers)));
priv->application = READER_APPLICATION(application);
gtk_window_set_default_size(GTK_WINDOW(reader), INDEX_PANE_WIDTH + DOCUMENT_PANE_WIDTH + 5, 300);
gtk_window_set_title(GTK_WINDOW(reader), i18n("Cainteoir Text-to-Speech"));
GtkWidget *layout = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add(GTK_CONTAINER(reader), layout);
priv->header = gtk_header_bar_new();
gtk_header_bar_set_title(GTK_HEADER_BAR(priv->header), i18n("Cainteoir Text-to-Speech"));
if (cainteoir_settings_get_boolean(priv->settings, "window", "have-csd", TRUE))
{
// Use client-side decorations (e.g. on Gnome Shell and Unity) ...
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(priv->header), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(reader), priv->header);
}
else
{
// Don't use client-side decorations (e.g. on KDE) ...
gtk_box_pack_start(GTK_BOX(layout), priv->header, FALSE, FALSE, 0);
}
priv->actions = create_action_group(priv);
gtk_widget_insert_action_group(GTK_WIDGET(reader), "cainteoir", G_ACTION_GROUP(priv->actions));
priv->view = reader_document_view_new(priv->settings);
gtk_box_pack_start(GTK_BOX(layout), priv->view, TRUE, TRUE, 0);
reader_document_view_set_index_pane_close_action_name(READER_DOCUMENT_VIEW(priv->view), "cainteoir.side-pane");
GtkWidget *bottombar = gtk_toolbar_new();
gtk_widget_set_size_request(bottombar, -1, 45);
gtk_style_context_add_class(gtk_widget_get_style_context(bottombar), "bottombar");
gtk_box_pack_start(GTK_BOX(layout), bottombar, FALSE, FALSE, 0);
GtkToolItem *record = gtk_tool_button_new(gtk_image_new_from_icon_name("media-record-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), record, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(record), "cainteoir.record");
priv->play_stop = gtk_tool_button_new(nullptr, nullptr);
gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(priv->play_stop), "media-playback-start-symbolic");
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), priv->play_stop, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->play_stop), "cainteoir.play-stop");
GtkToolItem *open = gtk_tool_button_new(gtk_image_new_from_icon_name("document-open-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR), nullptr);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), open, -1);
gtk_actionable_set_action_name(GTK_ACTIONABLE(open), "cainteoir.open");
GtkToolItem *timebar = gtk_tool_item_new();
gtk_tool_item_set_expand(GTK_TOOL_ITEM(timebar), TRUE);
gtk_toolbar_insert(GTK_TOOLBAR(bottombar), timebar, -1);
priv->timebar = cainteoir_timebar_new();
gtk_style_context_add_class(gtk_widget_get_style_context(priv->timebar), "timebar");
gtk_container_add(GTK_CONTAINER(timebar), priv->timebar);
priv->previous = gtk_button_new();
gtk_button_set_image(GTK_BUTTON(priv->previous), gtk_image_new_from_icon_name("go-previous-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_header_bar_pack_start(GTK_HEADER_BAR(priv->header), priv->previous);
gtk_actionable_set_action_name(GTK_ACTIONABLE(priv->previous), "cainteoir.view-previous");
GtkWidget *menu_button = gtk_menu_button_new();
gtk_button_set_image(GTK_BUTTON(menu_button), gtk_image_new_from_icon_name(HAMBURGER_MENU_ICON, GTK_ICON_SIZE_SMALL_TOOLBAR));
gtk_menu_button_set_menu_model(GTK_MENU_BUTTON(menu_button), create_main_menu());
gtk_header_bar_pack_end(GTK_HEADER_BAR(priv->header), menu_button);
g_signal_connect(reader, "window-state-event", G_CALLBACK(on_window_state_changed), priv->settings);
g_signal_connect(reader, "delete_event", G_CALLBACK(on_window_delete), priv);
g_signal_connect(reader, "show", G_CALLBACK(on_window_show), priv);
g_signal_connect(priv->tts, "speaking", G_CALLBACK(on_speaking), priv);
g_signal_connect(priv->tts, "text-range-changed", G_CALLBACK(on_text_range_changed), priv);
gtk_window_resize(GTK_WINDOW(reader),
cainteoir_settings_get_integer(priv->settings, "window", "width", 700),
cainteoir_settings_get_integer(priv->settings, "window", "height", 445));
gtk_window_move(GTK_WINDOW(reader),
cainteoir_settings_get_integer(priv->settings, "window", "left", 0),
cainteoir_settings_get_integer(priv->settings, "window", "top", 0));
if (cainteoir_settings_get_boolean(priv->settings, "window", "maximized", FALSE))
gtk_window_maximize(GTK_WINDOW(reader));
if (filename)
reader_window_load_document(reader, filename);
else
{
gchar *prev_filename = cainteoir_settings_get_string(priv->settings, "document", "filename", nullptr);
if (prev_filename)
{
reader_window_load_document(reader, prev_filename);
g_free(prev_filename);
}
}
gchar *anchor = cainteoir_settings_get_string(priv->settings, "highlight", "anchor", "none");
if (anchor)
{
if (!strcmp(anchor, "top"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_START);
else if (!strcmp(anchor, "middle"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_CENTER);
else if (!strcmp(anchor, "bottom"))
reader_window_set_highlight_anchor(reader, GTK_ALIGN_END);
g_free(anchor);
}
return GTK_WIDGET(reader);
}
/*********************************************************************** Menu */
void
bmd_construct_menu (GtkApplication *app, gpointer data)
{
GtkWidget *headerbar;
// the application menu displayed in the GNOME panel
GMenu *appmenu;
GMenu *editmenu;
GtkWidget *openbutton;
GtkWidget *savebutton;
// the menu displayed as a popover below the gears button
GMenu *gearmenu;
GtkWidget *gearmenubutton;
GtkWidget *gearicon;
bmd_widgets *a = (bmd_widgets *) data;
// define keyboard accelerators
const gchar *open_accels[2] = { "<Ctrl>O", NULL };
const gchar *save_accels[2] = { "<Ctrl>S", NULL };
const gchar *quit_accels[2] = { "<Ctrl>Q", NULL };
const gchar *add_accels[2] = { "<Ctrl>A", NULL };
const gchar *del_accels[2] = { "<Ctrl>D", NULL };
const gchar *find_accels[2] = { "<Ctrl>F", NULL };
const gchar *help_accels[2] = { "F1", NULL };
// create and fill in the application menu in the GNOME panel
appmenu = g_menu_new();
g_menu_append (appmenu, "About", "app.about");
g_menu_append (appmenu, "Help", "app.help");
g_menu_append (appmenu, "_Quit", "app.quit");
gtk_application_set_app_menu (GTK_APPLICATION (app), G_MENU_MODEL (appmenu));
g_object_unref (appmenu);
// create a headerbar
headerbar = gtk_header_bar_new ();
gtk_widget_show (headerbar);
gtk_header_bar_set_title (GTK_HEADER_BAR (headerbar), "Book Management");
gtk_header_bar_set_subtitle (GTK_HEADER_BAR (headerbar), "Simple Demo Application");
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR (headerbar), TRUE);
gtk_window_set_titlebar (GTK_WINDOW (a->window), headerbar);
// create an OPEN button, add it to the headerbar and connect the callbacks
openbutton = gtk_button_new_with_label ("Open");
gtk_header_bar_pack_start (GTK_HEADER_BAR (headerbar), openbutton);
gtk_actionable_set_action_name (GTK_ACTIONABLE (openbutton), "app.open");
// create the gear menu button
gearmenubutton = gtk_menu_button_new();
gearicon = gtk_image_new_from_icon_name ("emblem-system-symbolic",
GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_button_set_image (GTK_BUTTON (gearmenubutton), gearicon);
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), gearmenubutton);
// create a menu for the gear button
gearmenu = g_menu_new();
g_menu_append (gearmenu, "Save As ...", "app.saveAs");
editmenu = g_menu_new();
g_menu_append (editmenu, "_Find", "app.find");
g_menu_append (editmenu, "_Add", "app.add");
g_menu_append (editmenu, "_Delete", "app.delete");
g_menu_append_section (gearmenu, NULL, G_MENU_MODEL (editmenu));
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (gearmenubutton),
G_MENU_MODEL (gearmenu));
g_object_unref (editmenu);
g_object_unref (gearmenu);
// create an SAVE button, add it to the headerbar and connect the callbacks
savebutton = gtk_button_new_with_label ("Save");
gtk_header_bar_pack_end (GTK_HEADER_BAR (headerbar), savebutton);
gtk_actionable_set_action_name (GTK_ACTIONABLE (savebutton), "app.save");
// connect keyboard accelerators
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.open", open_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.save", save_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.quit", quit_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.add", add_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.delete", del_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.find", find_accels);
gtk_application_set_accels_for_action (GTK_APPLICATION (app),
"app.help", help_accels);
}
GtkWidget *
do_sidebar (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
GtkWidget *sidebar;
GtkWidget *stack;
GtkWidget *box;
GtkWidget *widget;
GtkWidget *header;
const gchar* pages[] = {
"Welcome to GTK+",
"GtkStackSidebar Widget",
"Automatic navigation",
"Consistent appearance",
"Scrolling",
"Page 6",
"Page 7",
"Page 8",
"Page 9",
NULL
};
const gchar *c = NULL;
guint i;
if (!window)
{
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_resizable (GTK_WINDOW (window), TRUE);
gtk_widget_set_size_request (window, 500, 350);
header = gtk_header_bar_new ();
gtk_header_bar_set_show_close_button (GTK_HEADER_BAR(header), TRUE);
gtk_window_set_titlebar (GTK_WINDOW(window), header);
gtk_window_set_title (GTK_WINDOW(window), "Stack Sidebar");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
sidebar = gtk_stack_sidebar_new ();
gtk_box_pack_start (GTK_BOX (box), sidebar, FALSE, FALSE);
stack = gtk_stack_new ();
gtk_stack_set_transition_type (GTK_STACK (stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
gtk_stack_sidebar_set_stack (GTK_STACK_SIDEBAR (sidebar), GTK_STACK (stack));
/* Separator between sidebar and stack */
widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX(box), widget, FALSE, FALSE);
gtk_box_pack_start (GTK_BOX (box), stack, TRUE, TRUE);
for (i=0; (c = *(pages+i)) != NULL; i++ )
{
if (i == 0)
{
widget = gtk_image_new_from_icon_name ("help-about", GTK_ICON_SIZE_MENU);
gtk_image_set_pixel_size (GTK_IMAGE (widget), 256);
}
else
{
widget = gtk_label_new (c);
}
gtk_stack_add_named (GTK_STACK (stack), widget, c);
gtk_container_child_set (GTK_CONTAINER (stack), widget, "title", c, NULL);
}
gtk_container_add (GTK_CONTAINER (window), box);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
gint _vala_main (gchar** args, int args_length1) {
gint result = 0;
Block1Data* _data1_;
GtkHeaderBar* headerbar = NULL;
GtkHeaderBar* _tmp0_ = NULL;
GtkWindow* window = NULL;
GtkWindow* _tmp1_ = NULL;
GtkGrid* grid = NULL;
GtkGrid* _tmp2_ = NULL;
GtkButton* _tmp3_ = NULL;
GtkGrid* gridtwo = NULL;
GtkGrid* _tmp4_ = NULL;
GtkLabel* _tmp5_ = NULL;
GtkLabel* _tmp6_ = NULL;
GtkLabel* _tmp7_ = NULL;
GtkLabel* _tmp8_ = NULL;
GtkLabel* _tmp9_ = NULL;
GtkLabel* _tmp10_ = NULL;
GtkLabel* _tmp11_ = NULL;
GtkLabel* _tmp12_ = NULL;
GtkGrid* layout = NULL;
GtkGrid* _tmp13_ = NULL;
GtkButton* _tmp14_ = NULL;
GtkLabel* _tmp15_ = NULL;
GtkButton* rotate_button = NULL;
GtkButton* _tmp16_ = NULL;
GtkLabel* _tmp17_ = NULL;
#line 20 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_ = g_slice_new0 (Block1Data);
#line 20 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_->_ref_count_ = 1;
#line 21 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_init (&args_length1, &args);
#line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp0_ = (GtkHeaderBar*) gtk_header_bar_new ();
#line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp0_);
#line 24 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
headerbar = _tmp0_;
#line 25 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_header_bar_set_show_close_button (headerbar, TRUE);
#line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp1_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL);
#line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp1_);
#line 28 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
window = _tmp1_;
#line 29 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_window_set_titlebar (window, (GtkWidget*) headerbar);
#line 30 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_window_set_title (window, "Hello Again Again Again!");
#line 31 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_set_border_width ((GtkContainer*) window, (guint) 12);
#line 32 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_window_set_position (window, GTK_WIN_POS_CENTER);
#line 33 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_window_set_default_size (window, 350, 350);
#line 34 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_signal_connect ((GtkWidget*) window, "destroy", (GCallback) _gtk_main_quit_gtk_widget_destroy, NULL);
#line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp2_ = (GtkGrid*) gtk_grid_new ();
#line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp2_);
#line 37 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
grid = _tmp2_;
#line 38 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_orientable_set_orientation ((GtkOrientable*) grid, GTK_ORIENTATION_VERTICAL);
#line 39 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_set_row_spacing (grid, 6);
#line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp3_ = (GtkButton*) gtk_button_new_with_label ("testing");
#line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp3_);
#line 42 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_->button = _tmp3_;
#line 43 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_signal_connect_data (_data1_->button, "clicked", (GCallback) ___lambda3__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
#line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp4_ = (GtkGrid*) gtk_grid_new ();
#line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp4_);
#line 52 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gridtwo = _tmp4_;
#line 53 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_set_column_spacing (gridtwo, 6);
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp5_ = (GtkLabel*) gtk_label_new ("Label 1");
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp5_);
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp6_ = _tmp5_;
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _tmp6_);
#line 55 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (_tmp6_);
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp7_ = (GtkLabel*) gtk_label_new ("Label 2");
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp7_);
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp8_ = _tmp7_;
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _tmp8_);
#line 56 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (_tmp8_);
#line 57 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) grid, (GtkWidget*) _data1_->button);
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp9_ = (GtkLabel*) gtk_label_new ("Label 3");
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp9_);
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp10_ = _tmp9_;
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) _tmp10_);
#line 59 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (_tmp10_);
#line 60 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) grid);
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp11_ = (GtkLabel*) gtk_label_new ("Label 4");
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp11_);
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp12_ = _tmp11_;
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) gridtwo, (GtkWidget*) _tmp12_);
#line 61 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (_tmp12_);
#line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp13_ = (GtkGrid*) gtk_grid_new ();
#line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp13_);
#line 63 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
layout = _tmp13_;
#line 64 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_set_column_spacing (layout, 6);
#line 65 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_set_row_spacing (layout, 6);
#line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp14_ = (GtkButton*) gtk_button_new_with_label ("Say Hello");
#line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp14_);
#line 67 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_->hello_button = _tmp14_;
#line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp15_ = (GtkLabel*) gtk_label_new (NULL);
#line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp15_);
#line 68 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_->hello_label = _tmp15_;
#line 70 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_signal_connect_data (_data1_->hello_button, "clicked", (GCallback) ___lambda4__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
#line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp16_ = (GtkButton*) gtk_button_new_with_label ("Rotate");
#line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp16_);
#line 75 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
rotate_button = _tmp16_;
#line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_tmp17_ = (GtkLabel*) gtk_label_new ("Horizontal");
#line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_object_ref_sink (_tmp17_);
#line 76 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_->rotate_label = _tmp17_;
#line 78 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
g_signal_connect_data (rotate_button, "clicked", (GCallback) ___lambda5__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0);
#line 82 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_attach (layout, (GtkWidget*) _data1_->hello_button, 0, 0, 1, 1);
#line 83 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_attach_next_to (layout, (GtkWidget*) _data1_->hello_label, (GtkWidget*) _data1_->hello_button, GTK_POS_RIGHT, 1, 1);
#line 84 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_attach (layout, (GtkWidget*) rotate_button, 0, 1, 1, 1);
#line 85 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_attach_next_to (layout, (GtkWidget*) _data1_->rotate_label, (GtkWidget*) rotate_button, GTK_POS_RIGHT, 1, 1);
#line 86 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_grid_attach (layout, (GtkWidget*) gridtwo, 0, 2, 2, 2);
#line 88 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_container_add ((GtkContainer*) window, (GtkWidget*) layout);
#line 89 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_widget_show_all ((GtkWidget*) window);
#line 91 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
gtk_main ();
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
result = 0;
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (rotate_button);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (layout);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (gridtwo);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (grid);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (window);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_g_object_unref0 (headerbar);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
block1_data_unref (_data1_);
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
_data1_ = NULL;
#line 92 "/home/riley/git/vala/gtk-testing/src/gtk-testing.vala"
return result;
#line 529 "gtk-testing.c"
}
bool wxTopLevelWindowGTK::Create( wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& sizeOrig,
long style,
const wxString &name )
{
wxSize size(sizeOrig);
if (!size.IsFullySpecified())
size.SetDefaults(GetDefaultSize());
wxTopLevelWindows.Append( this );
if (!PreCreation( parent, pos, size ) ||
!CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
{
wxFAIL_MSG( wxT("wxTopLevelWindowGTK creation failed") );
return false;
}
m_title = title;
// NB: m_widget may be !=NULL if it was created by derived class' Create,
// e.g. in wxTaskBarIconAreaGTK
if (m_widget == NULL)
{
m_widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
{
// Tell WM that this is a dialog window and make it center
// on parent by default (this is what GtkDialog ctor does):
gtk_window_set_type_hint(GTK_WINDOW(m_widget),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_position(GTK_WINDOW(m_widget),
GTK_WIN_POS_CENTER_ON_PARENT);
}
else
{
if (style & wxFRAME_TOOL_WINDOW)
{
gtk_window_set_type_hint(GTK_WINDOW(m_widget),
GDK_WINDOW_TYPE_HINT_UTILITY);
// On some WMs, like KDE, a TOOL_WINDOW will still show
// on the taskbar, but on Gnome a TOOL_WINDOW will not.
// For consistency between WMs and with Windows, we
// should set the NO_TASKBAR flag which will apply
// the set_skip_taskbar_hint if it is available,
// ensuring no taskbar entry will appear.
style |= wxFRAME_NO_TASKBAR;
}
}
g_object_ref(m_widget);
}
wxWindow *topParent = wxGetTopLevelParent(m_parent);
if (topParent && (((GTK_IS_WINDOW(topParent->m_widget)) &&
(GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)) ||
(style & wxFRAME_FLOAT_ON_PARENT)))
{
gtk_window_set_transient_for( GTK_WINDOW(m_widget),
GTK_WINDOW(topParent->m_widget) );
}
if (style & wxFRAME_NO_TASKBAR)
{
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(m_widget), TRUE);
}
if (style & wxSTAY_ON_TOP)
{
gtk_window_set_keep_above(GTK_WINDOW(m_widget), TRUE);
}
if (style & wxMAXIMIZE)
gtk_window_maximize(GTK_WINDOW(m_widget));
#if 0
if (!name.empty())
gtk_window_set_role( GTK_WINDOW(m_widget), wxGTK_CONV( name ) );
#endif
gtk_window_set_title( GTK_WINDOW(m_widget), wxGTK_CONV( title ) );
gtk_widget_set_can_focus(m_widget, false);
g_signal_connect (m_widget, "delete_event",
G_CALLBACK (gtk_frame_delete_callback), this);
// m_mainWidget is a GtkVBox, holding the bars and client area (m_wxwindow)
m_mainWidget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show( m_mainWidget );
gtk_widget_set_can_focus(m_mainWidget, false);
gtk_container_add( GTK_CONTAINER(m_widget), m_mainWidget );
// m_wxwindow is the client area
m_wxwindow = wxPizza::New();
gtk_widget_show( m_wxwindow );
gtk_box_pack_start(GTK_BOX(m_mainWidget), m_wxwindow, true, true, 0);
// we donm't allow the frame to get the focus as otherwise
// the frame will grab it at arbitrary focus changes
gtk_widget_set_can_focus(m_wxwindow, false);
if (m_parent) m_parent->AddChild( this );
g_signal_connect(m_wxwindow, "size_allocate",
G_CALLBACK(size_allocate), this);
PostCreation();
#ifndef __WXGTK3__
if (pos != wxDefaultPosition)
gtk_widget_set_uposition( m_widget, m_x, m_y );
#endif
// for some reported size corrections
g_signal_connect (m_widget, "map_event",
G_CALLBACK (gtk_frame_map_callback), this);
// for iconized state
g_signal_connect (m_widget, "window_state_event",
G_CALLBACK (gtk_frame_window_state_callback), this);
// for wxMoveEvent
g_signal_connect (m_widget, "configure_event",
G_CALLBACK (gtk_frame_configure_callback), this);
// activation
g_signal_connect_after (m_widget, "focus_in_event",
G_CALLBACK (gtk_frame_focus_in_callback), this);
g_signal_connect_after (m_widget, "focus_out_event",
G_CALLBACK (gtk_frame_focus_out_callback), this);
// We need to customize the default GTK+ logic for key processing to make
// it conforming to wxWidgets event processing order.
g_signal_connect (m_widget, "key_press_event",
G_CALLBACK (wxgtk_tlw_key_press_event), NULL);
#ifdef GDK_WINDOWING_X11
#ifdef __WXGTK3__
if (GDK_IS_X11_SCREEN(gtk_window_get_screen(GTK_WINDOW(m_widget))))
#endif
{
gtk_widget_add_events(m_widget, GDK_PROPERTY_CHANGE_MASK);
g_signal_connect(m_widget, "property_notify_event",
G_CALLBACK(property_notify_event), this);
}
#endif // GDK_WINDOWING_X11
// translate wx decorations styles into Motif WM hints (they are recognized
// by other WMs as well)
// always enable moving the window as we have no separate flag for enabling
// it
m_gdkFunc = GDK_FUNC_MOVE;
if ( style & wxCLOSE_BOX )
m_gdkFunc |= GDK_FUNC_CLOSE;
if ( style & wxMINIMIZE_BOX )
m_gdkFunc |= GDK_FUNC_MINIMIZE;
if ( style & wxMAXIMIZE_BOX )
m_gdkFunc |= GDK_FUNC_MAXIMIZE;
if ( (style & wxSIMPLE_BORDER) || (style & wxNO_BORDER) )
{
m_gdkDecor = 0;
gtk_window_set_decorated(GTK_WINDOW(m_widget), false);
}
else // have border
{
m_gdkDecor = GDK_DECOR_BORDER;
if ( style & wxCAPTION )
m_gdkDecor |= GDK_DECOR_TITLE;
#if defined(GDK_WINDOWING_WAYLAND) && GTK_CHECK_VERSION(3,10,0)
else if (
GDK_IS_WAYLAND_DISPLAY(gtk_widget_get_display(m_widget)) &&
gtk_check_version(3,10,0) == NULL)
{
gtk_window_set_titlebar(GTK_WINDOW(m_widget), gtk_header_bar_new());
}
#endif
if ( style & wxSYSTEM_MENU )
m_gdkDecor |= GDK_DECOR_MENU;
if ( style & wxMINIMIZE_BOX )
m_gdkDecor |= GDK_DECOR_MINIMIZE;
if ( style & wxMAXIMIZE_BOX )
m_gdkDecor |= GDK_DECOR_MAXIMIZE;
if ( style & wxRESIZE_BORDER )
{
m_gdkFunc |= GDK_FUNC_RESIZE;
m_gdkDecor |= GDK_DECOR_RESIZEH;
}
}
m_decorSize = GetCachedDecorSize();
int w, h;
GTKDoGetSize(&w, &h);
if (style & wxRESIZE_BORDER)
{
gtk_window_set_default_size(GTK_WINDOW(m_widget), w, h);
#ifndef __WXGTK3__
gtk_window_set_policy(GTK_WINDOW(m_widget), 1, 1, 1);
#endif
}
else
{
gtk_window_set_resizable(GTK_WINDOW(m_widget), false);
// gtk_window_set_default_size() does not work for un-resizable windows,
// unless you set the size hints, but that causes Ubuntu's WM to make
// the window resizable even though GDK_FUNC_RESIZE is not set.
gtk_widget_set_size_request(m_widget, w, h);
}
return true;
}
static void main_window_init(MainWindow *wnd)
{
GdkRGBA vid_area_bg_color;
wnd->fullscreen = FALSE;
wnd->playlist_visible = FALSE;
wnd->playlist_width = PLAYLIST_DEFAULT_WIDTH;
wnd->timeout_tag = 0;
wnd->settings = gtk_settings_get_default();
wnd->header_bar = gtk_header_bar_new();
wnd->open_hdr_btn = NULL;
wnd->fullscreen_hdr_btn = NULL;
wnd->menu_hdr_btn = NULL;
wnd->main_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
wnd->vid_area_paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
wnd->vid_area = gtk_drawing_area_new();
wnd->fs_control = gtk_window_new(GTK_WINDOW_POPUP);
wnd->control_box = control_box_new();
wnd->playlist = playlist_widget_new();
gdk_rgba_parse(&vid_area_bg_color, VID_AREA_BG_COLOR);
gtk_widget_add_events( wnd->fs_control,
GDK_ENTER_NOTIFY_MASK
|GDK_LEAVE_NOTIFY_MASK );
gtk_widget_add_events(wnd->vid_area, GDK_BUTTON_PRESS_MASK);
gtk_header_bar_set_show_close_button( GTK_HEADER_BAR(wnd->header_bar),
TRUE );
gtk_window_set_title(GTK_WINDOW(wnd), g_get_application_name());
gtk_paned_set_position( GTK_PANED(wnd->vid_area_paned),
MAIN_WINDOW_DEFAULT_WIDTH
-PLAYLIST_DEFAULT_WIDTH );
gtk_window_set_default_size( GTK_WINDOW(wnd),
MAIN_WINDOW_DEFAULT_WIDTH,
MAIN_WINDOW_DEFAULT_HEIGHT );
gtk_widget_override_background_color( wnd->vid_area,
GTK_STATE_NORMAL,
&vid_area_bg_color);
gtk_box_pack_start
(GTK_BOX(wnd->main_box), wnd->vid_area_paned, TRUE, TRUE, 0);
gtk_paned_pack1
(GTK_PANED(wnd->vid_area_paned), wnd->vid_area, TRUE, TRUE);
gtk_paned_pack2
(GTK_PANED(wnd->vid_area_paned), wnd->playlist, FALSE, TRUE);
gtk_container_add
(GTK_CONTAINER(wnd->main_box), wnd->control_box);
gtk_container_add
(GTK_CONTAINER(wnd), wnd->main_box);
g_signal_connect( wnd,
"focus-in-event",
G_CALLBACK(focus_in_handler),
wnd );
g_signal_connect( wnd,
"focus-out-event",
G_CALLBACK(focus_out_handler),
wnd );
g_signal_connect( wnd->fs_control,
"enter-notify-event",
G_CALLBACK(fs_control_enter_handler),
wnd->fs_control );
g_signal_connect( wnd->fs_control,
"leave-notify-event",
G_CALLBACK(fs_control_leave_handler),
wnd->fs_control );
g_signal_connect( wnd,
"motion-notify-event",
G_CALLBACK(motion_notify_handler),
wnd );
}
int
main (int argc, char *argv[])
{
GtkWidget *win;
GtkWidget *box;
GtkWidget *button;
GtkWidget *button2;
GtkBuilder *builder;
GMenuModel *model;
GSimpleActionGroup *actions;
GtkWidget *overlay;
GtkWidget *grid;
GtkWidget *popover;
GtkWidget *popover2;
GtkWidget *label;
GtkWidget *check;
GtkWidget *combo;
GtkWidget *header_bar;
#ifdef GTK_SRCDIR
g_chdir (GTK_SRCDIR);
#endif
gtk_init ();
win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (win), 400, 600);
header_bar = gtk_header_bar_new ();
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header_bar), TRUE);
gtk_window_set_titlebar (GTK_WINDOW (win), header_bar);
gtk_window_set_title (GTK_WINDOW (win), "Test GtkPopover");
actions = g_simple_action_group_new ();
g_action_map_add_action_entries (G_ACTION_MAP (actions), entries, G_N_ELEMENTS (entries), NULL);
gtk_widget_insert_action_group (win, "top", G_ACTION_GROUP (actions));
overlay = gtk_overlay_new ();
gtk_container_add (GTK_CONTAINER (win), overlay);
grid = gtk_grid_new ();
gtk_widget_set_halign (grid, GTK_ALIGN_FILL);
gtk_widget_set_valign (grid, GTK_ALIGN_FILL);
gtk_grid_set_row_spacing (GTK_GRID (grid), 10);
gtk_grid_set_column_spacing (GTK_GRID (grid), 10);
gtk_container_add (GTK_CONTAINER (overlay), grid);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
label = gtk_label_new ("");
gtk_widget_set_hexpand (label, TRUE);
gtk_widget_set_vexpand (label, TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 3, 6, 1, 1);
builder = gtk_builder_new_from_file ("popover.ui");
model = (GMenuModel *)gtk_builder_get_object (builder, "menu");
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
button = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button);
button2 = gtk_menu_button_new ();
gtk_container_add (GTK_CONTAINER (box), button2);
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (button), model);
gtk_menu_button_set_use_popover (GTK_MENU_BUTTON (button), TRUE);
popover = GTK_WIDGET (gtk_menu_button_get_popover (GTK_MENU_BUTTON (button)));
builder = gtk_builder_new_from_file ("popover2.ui");
popover2 = (GtkWidget *)gtk_builder_get_object (builder, "popover");
gtk_menu_button_set_popover (GTK_MENU_BUTTON (button2), popover2);
g_object_set (box, "margin", 10, NULL);
gtk_overlay_add_overlay (GTK_OVERLAY (overlay), box);
label = gtk_label_new ("Popover hexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "hexpand", G_BINDING_SYNC_CREATE);
g_object_bind_property (check, "active", popover2, "hexpand", G_BINDING_SYNC_CREATE);
gtk_grid_attach (GTK_GRID (grid), label , 1, 1, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 1, 1, 1);
label = gtk_label_new ("Popover vexpand");
check = gtk_check_button_new ();
g_object_bind_property (check, "active", popover, "vexpand", G_BINDING_SYNC_CREATE);
g_object_bind_property (check, "active", popover2, "vexpand", G_BINDING_SYNC_CREATE);
gtk_grid_attach (GTK_GRID (grid), label , 1, 2, 1, 1);
gtk_grid_attach (GTK_GRID (grid), check, 2, 2, 1, 1);
label = gtk_label_new ("Button direction");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "up", "Up");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "down", "Down");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "left", "Left");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "right", "Right");
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
g_object_bind_property (combo, "active", button, "direction", G_BINDING_SYNC_CREATE);
g_object_bind_property (combo, "active", button2, "direction", G_BINDING_SYNC_CREATE);
gtk_grid_attach (GTK_GRID (grid), label , 1, 3, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 3, 1, 1);
label = gtk_label_new ("Button halign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 2);
g_object_bind_property (combo, "active", box, "halign", G_BINDING_SYNC_CREATE);
gtk_grid_attach (GTK_GRID (grid), label , 1, 4, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 4, 1, 1);
label = gtk_label_new ("Button valign");
combo = gtk_combo_box_text_new ();
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "fill", "Fill");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "start", "Start");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "end", "End");
gtk_combo_box_text_append (GTK_COMBO_BOX_TEXT (combo), "center", "Center");
gtk_combo_box_set_active (GTK_COMBO_BOX (combo), 1);
g_object_bind_property (combo, "active", box, "valign", G_BINDING_SYNC_CREATE);
gtk_grid_attach (GTK_GRID (grid), label , 1, 5, 1, 1);
gtk_grid_attach (GTK_GRID (grid), combo, 2, 5, 1, 1);
g_signal_connect (win, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (win);
gtk_main ();
return 0;
}
static void
on_activate (GApplication *app,
gpointer data)
{
static GtkWidget *window = NULL;
if (window == NULL)
{
GtkWidget *header, *sidebar_toggle, *animation_switch;
GtkWidget *hbox, *revealer, *sidebar, *img;
window = gtk_application_window_new (GTK_APPLICATION (app));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
/* titlebar */
header = gtk_header_bar_new ();
gtk_header_bar_set_show_title_buttons (GTK_HEADER_BAR (header), TRUE);
gtk_window_set_titlebar (GTK_WINDOW (window), header);
sidebar_toggle = gtk_toggle_button_new_with_label ("Show Sidebar");
gtk_header_bar_pack_start (GTK_HEADER_BAR (header), sidebar_toggle);
animation_switch = gtk_switch_new ();
gtk_widget_set_valign (animation_switch, GTK_ALIGN_CENTER);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header), animation_switch);
gtk_header_bar_pack_end (GTK_HEADER_BAR (header),
gtk_label_new ("Animations"));
/* content */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_add (GTK_CONTAINER (window), hbox);
revealer = gtk_revealer_new ();
gtk_revealer_set_transition_type (GTK_REVEALER (revealer),
GTK_REVEALER_TRANSITION_TYPE_SLIDE_LEFT);
gtk_container_add (GTK_CONTAINER (hbox), revealer);
sidebar = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_size_request (sidebar, 150, -1);
gtk_style_context_add_class (gtk_widget_get_style_context (sidebar),
GTK_STYLE_CLASS_SIDEBAR);
gtk_container_add (GTK_CONTAINER (revealer), sidebar);
img = gtk_image_new ();
g_object_set (img, "icon-name", "face-smile-symbolic",
"pixel-size", 128,
"hexpand", TRUE,
"halign", GTK_ALIGN_CENTER,
"valign", GTK_ALIGN_CENTER,
NULL);
gtk_container_add (GTK_CONTAINER (hbox), img);
g_object_bind_property (sidebar_toggle, "active",
revealer, "reveal-child",
G_BINDING_SYNC_CREATE);
g_object_bind_property (gtk_settings_get_default(), "gtk-enable-animations",
animation_switch, "active",
G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL);
}
gtk_window_present (GTK_WINDOW (window));
}
void WebInspectorProxy::createInspectorWindow()
{
if (m_client.openWindow(this))
return;
ASSERT(!m_inspectorWindow);
m_inspectorWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget* inspectedViewParent = gtk_widget_get_toplevel(inspectedPage()->viewWidget());
if (WebCore::widgetIsOnscreenToplevelWindow(inspectedViewParent))
gtk_window_set_transient_for(GTK_WINDOW(m_inspectorWindow), GTK_WINDOW(inspectedViewParent));
#if GTK_CHECK_VERSION(3, 10, 0)
m_headerBar = gtk_header_bar_new();
gtk_header_bar_set_show_close_button(GTK_HEADER_BAR(m_headerBar), TRUE);
gtk_window_set_titlebar(GTK_WINDOW(m_inspectorWindow), m_headerBar);
gtk_widget_show(m_headerBar);
#endif
updateInspectorWindowTitle();
gtk_window_set_default_size(GTK_WINDOW(m_inspectorWindow), initialWindowWidth, initialWindowHeight);
gtk_container_add(GTK_CONTAINER(m_inspectorWindow), m_inspectorView);
gtk_widget_show(m_inspectorView);
g_object_add_weak_pointer(G_OBJECT(m_inspectorWindow), reinterpret_cast<void**>(&m_inspectorWindow));
gtk_window_present(GTK_WINDOW(m_inspectorWindow));
}
