static void gcal_application_activate (GApplication *application) { GcalApplicationPrivate *priv; priv = GCAL_APPLICATION (application)->priv; if (priv->window != NULL) { gtk_window_present (GTK_WINDOW (priv->window)); } else { priv->window = gcal_window_new_with_view (GCAL_APPLICATION (application), g_settings_get_enum (priv->settings, "active-view")); g_settings_bind (priv->settings, "active-view", priv->window, "active-view", G_SETTINGS_BIND_SET | G_SETTINGS_BIND_GET); gtk_window_set_title (GTK_WINDOW (priv->window), _("Calendar")); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window), TRUE); gtk_window_maximize (GTK_WINDOW (priv->window)); gtk_widget_show_all (priv->window); } }
static void change_titlebar_state (GSimpleAction *action, GVariant *state, gpointer user_data) { GtkWindow *window = user_data; gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), g_variant_get_boolean (state)); g_simple_action_set_state (action, state); }
static void brio_application_activate (GApplication *application) { BrioApplicationPrivate *priv; priv = BRIO_APPLICATION (application)->priv; if (priv->window != NULL) gtk_window_present (GTK_WINDOW (priv->window)); else { priv->window = brio_window_new (BRIO_APPLICATION (application)); gtk_window_set_title (GTK_WINDOW (priv->window), _("Brio")); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window), TRUE); gtk_window_maximize (GTK_WINDOW (priv->window)); gtk_widget_show_all (priv->window); } }
static void initGUI(int numframes, gchar *notefile) { g_object_set(gtk_settings_get_default(),"gtk-application-prefer-dark-theme", TRUE, NULL); int i = 0, transIndex = 0; GtkWidget *timeBox = NULL, *pageBox = NULL, *notePadBox = NULL, *notePadScroll = NULL, *table = NULL; GtkWidget *canvas = NULL, *frame = NULL, *evbox = NULL, *pageevbox = NULL, *outerevbox = NULL, *timeFrame = NULL, *pageFrame = NULL; GtkWidget *mainVBox = NULL; GdkRGBA black; GtkWidget *toolbar = NULL, *timeToolbar = NULL; GtkToolItem *openButton = NULL, *saveAsButton = NULL, *fontSelectButton = NULL, *timeFontSelectButton = NULL; PangoFontDescription *font_desc = NULL; struct viewport *thisport = NULL; /* init colors */ if (gdk_rgba_parse(&black,"#000000") != TRUE) fprintf(stderr, "Could not resolve color \"black\".\n"); if (gdk_rgba_parse(&col_current,"#BBFFBB") != TRUE) fprintf(stderr, "Could not resolve color \"col_current\".\n"); if (gdk_rgba_parse(&col_marked,"#990000") != TRUE) fprintf(stderr, "Could not resolve color \"col_marked\".\n"); if (gdk_rgba_parse(&col_dim,"#999999") != TRUE) fprintf(stderr, "Could not resolve color \"col_dim\".\n"); /* init our two windows */ win_preview = gtk_window_new(GTK_WINDOW_TOPLEVEL); win_beamer = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win_preview), "pdfpres - Preview"); gtk_window_set_title(GTK_WINDOW(win_beamer), "pdfpres - Beamer"); g_signal_connect(G_OBJECT(win_preview), "delete_event", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_preview), "destroy", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_beamer), "delete_event", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_beamer), "destroy", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_preview), "key_press_event", G_CALLBACK(onKeyPressed), NULL); g_signal_connect(G_OBJECT(win_beamer), "key_press_event", G_CALLBACK(onKeyPressed), NULL); gtk_widget_add_events(win_beamer, GDK_BUTTON_PRESS_MASK); gtk_widget_add_events(win_beamer, GDK_BUTTON_RELEASE_MASK); g_signal_connect(G_OBJECT(win_beamer), "button_release_event", G_CALLBACK(onMouseReleased), NULL); gtk_widget_add_events(win_preview, GDK_BUTTON_PRESS_MASK); gtk_widget_add_events(win_preview, GDK_BUTTON_RELEASE_MASK); g_signal_connect(G_OBJECT(win_preview), "button_release_event", G_CALLBACK(onMouseReleased), NULL); gtk_container_set_border_width(GTK_CONTAINER(win_preview), 0); gtk_container_set_border_width(GTK_CONTAINER(win_beamer), 0); gtk_widget_override_background_color(win_beamer, GTK_STATE_NORMAL, &black); /* That little "resize grip" is a no-go for our beamer window. */ gtk_window_set_has_resize_grip(GTK_WINDOW(win_beamer), FALSE); /* create buttons */ timeToolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(timeToolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(timeToolbar), 5); if (!prefs.timer_is_clock) { startButton = gtk_tool_button_new_from_stock( GTK_STOCK_MEDIA_PLAY); g_signal_connect(G_OBJECT(startButton), "clicked", G_CALLBACK(toggleTimer), NULL); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), startButton, -1); resetButton = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_REWIND); g_signal_connect(G_OBJECT(resetButton), "clicked", G_CALLBACK(resetTimer), NULL); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), resetButton, -1); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), gtk_separator_tool_item_new(), -1); } timeFontSelectButton = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), timeFontSelectButton, -1); g_signal_connect(G_OBJECT(timeFontSelectButton), "clicked", G_CALLBACK(onTimerFontSelectClick), NULL); /* setting text size for time/page label */ timeElapsedLabel = gtk_label_new(NULL); curPageLabel = gtk_label_new(NULL); font_desc = pango_font_description_from_string(prefs.font_timer); gtk_widget_modify_font(GTK_WIDGET(timeElapsedLabel), font_desc); gtk_widget_modify_font(GTK_WIDGET(curPageLabel), font_desc); pango_font_description_free(font_desc); if (prefs.timer_is_clock) { printCurrentTime(timeElapsedLabel); } else { gtk_label_set_text(GTK_LABEL(timeElapsedLabel), "00:00"); } gtk_label_set_text(GTK_LABEL(curPageLabel), "0/0"); /* Add timer label to another event box so we can set a nice border. */ evbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evbox), timeElapsedLabel); gtk_container_set_border_width(GTK_CONTAINER(evbox), 10); pageevbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(pageevbox), curPageLabel); gtk_container_set_border_width(GTK_CONTAINER(pageevbox), 10); /* create timer */ timeBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start(GTK_BOX(timeBox), evbox, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(timeBox), timeToolbar, FALSE, FALSE, 5); pageBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_box_pack_start(GTK_BOX(pageBox), pageevbox, FALSE, FALSE, 5); if (prefs.timer_is_clock) { timeFrame = gtk_frame_new("Clock"); } else { timeFrame = gtk_frame_new("Timer"); } gtk_container_add(GTK_CONTAINER(timeFrame), timeBox); pageFrame = gtk_frame_new("Page"); gtk_container_add(GTK_CONTAINER(pageFrame), pageBox); /* create note pad inside a scrolled window */ notePadBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2); notePadScroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(notePadScroll), 5); notePadFrame = gtk_frame_new("Notes for current slide"); notePad = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(notePad), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(notePad), FALSE); g_signal_connect(G_OBJECT(notePad), "key_press_event", G_CALLBACK(onPadKeyPressed), NULL); /* Remarks: * * - The note pad uses word wrapping. If that's not enough, it also * uses wrapping on a per character basis. * - The note pad is placed into a GtkScrolledWindow. This window * allows vertical scrolling but no horizontal scrolling. */ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(notePad), GTK_WRAP_WORD_CHAR); gtk_container_add(GTK_CONTAINER(notePadScroll), notePad); gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(notePadScroll), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(notePadScroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(notePadBox), notePadScroll, TRUE, TRUE, 2); /* set note pad font and margin */ font_desc = pango_font_description_from_string(prefs.font_notes); gtk_widget_modify_font(notePad, font_desc); pango_font_description_free(font_desc); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(notePad), 5); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(notePad), 5); noteBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(notePad)); /* We detect changes of the notes by catching the "changed" signal. * As this signal is also emitted when we change the buffer * programmatically, we first have a look if there was a * "begin_user_action" signal. If so, the user has changed the * buffer. */ g_signal_connect(G_OBJECT(noteBuffer), "changed", G_CALLBACK(onEditing), NULL); g_signal_connect(G_OBJECT(noteBuffer), "begin_user_action", G_CALLBACK(onBeginUserAction), NULL); g_signal_connect(G_OBJECT(noteBuffer), "end_user_action", G_CALLBACK(onEndUserAction), NULL); /* create toolbar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(toolbar), 5); openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openButton, -1); g_signal_connect(G_OBJECT(openButton), "clicked", G_CALLBACK(onOpenClicked), NULL); /* TODO: Tooltips?! */ saveButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveButton, -1); gtk_widget_set_sensitive(GTK_WIDGET(saveButton), FALSE); g_signal_connect(G_OBJECT(saveButton), "clicked", G_CALLBACK(onSaveClicked), NULL); saveAsButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveAsButton, -1); g_signal_connect(G_OBJECT(saveAsButton), "clicked", G_CALLBACK(onSaveAsClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), gtk_separator_tool_item_new(), -1); editButton = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_EDIT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), editButton, -1); g_signal_connect(G_OBJECT(editButton), "toggled", G_CALLBACK(onEditToggled), NULL); fontSelectButton = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), fontSelectButton, -1); g_signal_connect(G_OBJECT(fontSelectButton), "clicked", G_CALLBACK(onFontSelectClick), NULL); gtk_box_pack_start(GTK_BOX(notePadBox), toolbar, FALSE, FALSE, 2); gtk_container_add(GTK_CONTAINER(notePadFrame), notePadBox); /* init containers for "preview" */ table = gtk_table_new(7, 10, TRUE); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_container_set_border_width(GTK_CONTAINER(table), 10); /* dynamically create all the frames */ for (i = 0; i < numframes; i++) { /* calc the offset for this frame */ transIndex = i - (int)((double)numframes / 2.0); /* create the widget - note that it is important not to * set the title to NULL. this would cause a lot more * redraws on startup because the frame will get re- * allocated when the title changes. */ frame = gtk_frame_new(""); /* create a new drawing area - the pdf will be rendered in * there */ canvas = gtk_drawing_area_new(); /* add widgets to their parents. the canvas is placed in an * eventbox, the box's size_allocate signal will be handled. so, * we know the exact width/height we can render into. (placing * the canvas into the frame would create the need of knowing the * frame's border size...) */ evbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evbox), canvas); gtk_container_add(GTK_CONTAINER(frame), evbox); /* every frame will be placed in another eventbox so we can set a * background color */ outerevbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(outerevbox), frame); if (i == 0) { //gtk_table_attach_defaults(GTK_TABLE(table), notePadFrame, // 0, 1, 0, 2); //gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, // 3, 4, 1, 2); } else { if (i == numframes - 1) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, 6, 10, 0, 5); gtk_table_attach_defaults(GTK_TABLE(table), timeFrame, 6, 8, 5, 7); gtk_table_attach_defaults(GTK_TABLE(table), pageFrame, 8, 10, 5, 7); } else { if (i == (int)(numframes / 2)) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, 0, 6, 0, 7); } } } /* make the eventbox "transparent" */ gtk_event_box_set_visible_window(GTK_EVENT_BOX(evbox), FALSE); /* save info of this rendering port */ thisport = (struct viewport *)malloc(sizeof(struct viewport)); g_assert(thisport); thisport->offset = transIndex; thisport->canvas = canvas; thisport->frame = frame; thisport->pixbuf = NULL; thisport->width = -1; thisport->height = -1; thisport->isBeamer = FALSE; ports = g_list_append(ports, thisport); /* resize callback */ g_signal_connect(G_OBJECT(evbox), "size_allocate", G_CALLBACK(onResize), thisport); /* How to draw into this particular canvas: */ g_signal_connect(G_OBJECT(canvas), "draw", G_CALLBACK(onCanvasDraw), thisport); } /* Add main content and a status bar to preview window. * * Note: It's important to use gtk_box_pack_* to add the statusbar * because gtk_container_add will pick unappropriate defaults. */ mainVBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); gtk_container_add(GTK_CONTAINER(mainVBox), table); mainStatusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(mainVBox), mainStatusbar, FALSE, FALSE, 0); setStatusText_strdup("Ready."); gtk_container_add(GTK_CONTAINER(win_preview), mainVBox); /* in order to set the initially highlighted frame */ refreshFrames(); /* add a rendering area to the beamer window */ canvas = gtk_drawing_area_new(); gtk_container_add(GTK_CONTAINER(win_beamer), canvas); /* save info of this rendering port */ thisport = (struct viewport *)malloc(sizeof(struct viewport)); g_assert(thisport); thisport->offset = 0; thisport->canvas = canvas; thisport->frame = NULL; thisport->pixbuf = NULL; thisport->width = -1; thisport->height = -1; thisport->isBeamer = TRUE; ports = g_list_append(ports, thisport); /* connect the on-resize-callback directly to the window */ g_signal_connect(G_OBJECT(win_beamer), "size_allocate", G_CALLBACK(onResize), thisport); /* How to draw into this particular canvas: */ g_signal_connect(G_OBJECT(canvas), "draw", G_CALLBACK(onCanvasDraw), thisport); /* load notes if requested */ if (notefile) { showNotesFromFile(notefile); } /* Set default sizes for both windows. (Note: If the widgets don't * fit into that space, the windows will be larger. Also, they are * allowed to get shrinked by the user.) */ gtk_window_set_default_size(GTK_WINDOW(win_preview), 640, 400); gtk_window_set_default_size(GTK_WINDOW(win_beamer), 320, 240); /* Hide titlebar when maximized */ gtk_window_set_hide_titlebar_when_maximized(GTK_WINDOW(win_preview), TRUE); /* show the windows */ gtk_widget_show_all(win_preview); gtk_widget_show_all(win_beamer); /* now, as the real gdk window exists, hide mouse cursor in the * beamer window */ gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(win_beamer)), gdk_cursor_new(GDK_BLANK_CURSOR)); /* Show a clock or a timer? */ if (prefs.timer_is_clock) { g_timeout_add(500, (GSourceFunc)printCurrentTime, (gpointer)timeElapsedLabel); } else { g_timeout_add(500, (GSourceFunc)printTimeElapsed, (gpointer)timeElapsedLabel); } }
static GtkWidget* create_new_window (GtkApplication *application, GVariantDict *options) { dg_lmem gchar* command = NULL; dg_lmem gchar* title = NULL; gboolean opt_show_title; gboolean opt_update_title; gboolean opt_no_headerbar; g_object_get (dwt_settings_get_instance (), "show-title", &opt_show_title, "update-title", &opt_update_title, "no-header-bar", &opt_no_headerbar, "command", &command, "title", &title, NULL); const gchar *opt_command = command; const gchar *opt_title = title; const gchar *opt_workdir = NULL; if (options) { gboolean opt_no_auto_title = FALSE; g_variant_dict_lookup (options, "title-on-maximize", "b", &opt_show_title); g_variant_dict_lookup (options, "no-header-bar", "b", &opt_no_headerbar); g_variant_dict_lookup (options, "no-auto-title", "b", &opt_no_auto_title); g_variant_dict_lookup (options, "workdir", "&s", &opt_workdir); g_variant_dict_lookup (options, "command", "&s", &opt_command); g_variant_dict_lookup (options, "title", "&s", &opt_title); if (opt_no_auto_title) opt_update_title = FALSE; } if (!opt_workdir) opt_workdir = g_get_home_dir (); if (!opt_command) opt_command = guess_shell (); /* * Title either comes from the default value of the "title" setting, * or from the command line flag, but should never be NULL at this * point. */ g_assert (opt_title); dg_lerr GError *gerror = NULL; gint command_argv_len = 0; gchar **command_argv = NULL; if (!g_shell_parse_argv (opt_command, &command_argv_len, &command_argv, &gerror)) { g_printerr ("%s: coult not parse command: %s\n", __func__, gerror->message); return NULL; } GtkWidget *window = gtk_application_window_new (application); gtk_widget_set_visual (window, gdk_screen_get_system_visual (gtk_widget_get_screen (window))); gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (window), FALSE); gtk_window_set_title (GTK_WINDOW (window), opt_title); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (window), !opt_show_title); g_action_map_add_action_entries (G_ACTION_MAP (window), win_actions, G_N_ELEMENTS (win_actions), window); VteTerminal *vtterm = VTE_TERMINAL (vte_terminal_new ()); configure_term_widget (vtterm, options); term_char_size_changed (vtterm, vte_terminal_get_char_width (vtterm), vte_terminal_get_char_height (vtterm), window); g_signal_connect (G_OBJECT (window), "notify::has-toplevel-focus", G_CALLBACK (window_has_toplevel_focus_notified), vtterm); g_signal_connect (G_OBJECT (vtterm), "char-size-changed", G_CALLBACK (term_char_size_changed), window); g_signal_connect (G_OBJECT (vtterm), "child-exited", G_CALLBACK (term_child_exited), window); g_signal_connect (G_OBJECT (vtterm), "bell", G_CALLBACK (term_beeped), window); g_signal_connect (G_OBJECT (vtterm), "button-release-event", G_CALLBACK (term_mouse_button_released), setup_popover (vtterm)); /* * Propagate title changes to the window. */ if (opt_update_title) g_object_bind_property (G_OBJECT (vtterm), "window-title", G_OBJECT (window), "title", G_BINDING_DEFAULT); if (!opt_no_headerbar) setup_header_bar (window, vtterm, opt_show_title); gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (vtterm)); gtk_widget_set_receives_default (GTK_WIDGET (vtterm), TRUE); /* We need to realize and show the window for it to have a valid XID */ gtk_widget_show_all (window); gchar **command_env = g_get_environ (); #ifdef GDK_WINDOWING_X11 if (GDK_IS_X11_SCREEN (gtk_widget_get_screen (window))) { GdkWindow *gdk_window = gtk_widget_get_window (window); if (gdk_window) { gchar window_id[NDIGITS10(unsigned long)]; snprintf (window_id, sizeof (window_id), "%lu", GDK_WINDOW_XID (gdk_window)); command_env = g_environ_setenv (command_env, "WINDOWID", window_id, TRUE); } else { g_printerr ("No window, cannot set $WINDOWID!\n"); } }
static void GyahtzeeCreateMainWindow (void) { GtkWidget *hbox, *vbox; GtkWidget *toolbar; GtkWidget *tmp; GtkWidget *dicebox; GtkAccelGroup *accel_group; GtkBuilder *builder; GtkUIManager *ui_manager; 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), TRUE); //games_conf_add_window (GTK_WINDOW (window), NULL); g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (quit_game), NULL); g_signal_connect (G_OBJECT (window), "key_press_event", G_CALLBACK (key_press), NULL); statusbar = gtk_statusbar_new (); ui_manager = gtk_ui_manager_new (); builder = gtk_builder_new (); gtk_builder_add_from_string (builder, builder_description, -1, NULL); games_stock_prepare_for_statusbar_tooltips (ui_manager, statusbar); /*---- Menus ----*/ create_menus (ui_manager); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); g_action_map_add_action_entries (G_ACTION_MAP (application), app_entries, G_N_ELEMENTS (app_entries), application); gtk_application_set_app_menu (GTK_APPLICATION (application), G_MENU_MODEL (gtk_builder_get_object (builder, "app-menu"))); /*---- 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); gtk_box_pack_start (GTK_BOX (vbox), statusbar, FALSE, FALSE, 0); gtk_widget_show (statusbar); /* 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 (G_OBJECT (mbutton), "clicked", G_CALLBACK (roll_dice), 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 (G_OBJECT (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); gtk_widget_show (window); GyahtzeeNewGame (); }
static void gnome_control_center_init (GnomeControlCenter *self) { GError *err = NULL; GnomeControlCenterPrivate *priv; GdkScreen *screen; priv = self->priv = CONTROL_CENTER_PRIVATE (self); #ifdef HAVE_CHEESE if (gtk_clutter_init (NULL, NULL) != CLUTTER_INIT_SUCCESS) { g_critical ("Clutter-GTK init failed"); return; } #endif /* HAVE_CHEESE */ priv->monitor_num = -1; self->priv->small_screen = SMALL_SCREEN_UNSET; /* load the user interface */ priv->builder = gtk_builder_new (); if (!gtk_builder_add_from_file (priv->builder, UIDIR "/shell.ui", &err)) { g_critical ("Could not build interface: %s", err->message); g_error_free (err); return; } /* connect various signals */ priv->window = W (priv->builder, "main-window"); gtk_window_set_hide_titlebar_when_maximized (GTK_WINDOW (priv->window), TRUE); screen = gtk_widget_get_screen (priv->window); g_signal_connect (screen, "monitors-changed", G_CALLBACK (monitors_changed_cb), self); g_signal_connect (priv->window, "configure-event", G_CALLBACK (main_window_configure_cb), self); g_signal_connect (priv->window, "notify::application", G_CALLBACK (application_set_cb), self); g_signal_connect_swapped (priv->window, "delete-event", G_CALLBACK (g_object_unref), self); g_signal_connect_after (priv->window, "key_press_event", G_CALLBACK (window_key_press_event), self); priv->notebook = W (priv->builder, "notebook"); /* Main scrolled window */ priv->scrolled_window = W (priv->builder, "scrolledwindow1"); gtk_widget_set_size_request (priv->scrolled_window, FIXED_WIDTH, -1); priv->main_vbox = W (priv->builder, "main-vbox"); g_signal_connect (priv->notebook, "notify::page", G_CALLBACK (notebook_page_notify_cb), priv); g_signal_connect (gtk_builder_get_object (priv->builder, "home-button"), "clicked", G_CALLBACK (home_button_clicked_cb), self); /* keep a list of custom widgets to unload on panel change */ priv->custom_widgets = g_ptr_array_new_with_free_func ((GDestroyNotify) g_object_unref); /* load the available settings panels */ setup_model (self); /* load the panels that are implemented as plugins */ load_panel_plugins (self); /* setup search functionality */ setup_search (self); setup_lock (self); /* store default window title and name */ priv->default_window_title = g_strdup (gtk_window_get_title (GTK_WINDOW (priv->window))); priv->default_window_icon = g_strdup (gtk_window_get_icon_name (GTK_WINDOW (priv->window))); notebook_page_notify_cb (GTK_NOTEBOOK (priv->notebook), NULL, priv); }
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); }