static void gw_window_constructed (GObject *object) { GwWindow *window; GwWindowPrivate *priv; gboolean os_shows_app_menu; GtkSettings *settings; //Chain the parent class { G_OBJECT_CLASS (gw_window_parent_class)->constructed (object); } window = GW_WINDOW (object); priv = window->priv; settings = gtk_settings_get_default (); g_object_get (settings, "gtk-shell-shows-app-menu", &os_shows_app_menu, NULL); gtk_widget_add_events (GTK_WIDGET (window), GDK_FOCUS_CHANGE_MASK); gtk_application_window_set_show_menubar (GTK_APPLICATION_WINDOW (window), FALSE); priv->accelgroup = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), priv->accelgroup); gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (priv->application)); priv->builder = gtk_builder_new (); gw_window_load_ui_xml (window, priv->ui_xml); priv->toplevel = GTK_WIDGET (gw_window_get_object (GW_WINDOW (window), "toplevel")); g_signal_connect (G_OBJECT (window), "configure-event", G_CALLBACK (gw_window_configure_event_cb), NULL); g_signal_connect (window, "focus-in-event", G_CALLBACK (gw_window_focus_in_event_cb), NULL); }
/**************************************************************** MAIN WINDOW */ static void bmd_activate (GtkApplication *app, gpointer data) { bmd_widgets *a = (bmd_widgets *) data; // create a window with title, default size and icons a->window = gtk_application_window_new (app); gtk_window_set_application (GTK_WINDOW (a->window), GTK_APPLICATION (app)); gtk_window_set_position (GTK_WINDOW (a->window), GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW (a->window), "Book Management Demo"); gtk_window_set_default_size (GTK_WINDOW (a->window), XSIZE, YSIZE); gtk_window_set_default_icon_from_file ("bmd_icon.png", NULL); a->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (a->window), a->box); /* moved the creation of the menu to a dedicated function */ bmd_construct_menu (app, (gpointer) a); a->paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_box_pack_start (GTK_BOX (a->box), a->paned, TRUE, TRUE, 0); bmd_construct_editablecells (app, (gpointer) a); bmd_construct_imagedemo (app, (gpointer) a); gtk_widget_show_all (GTK_WIDGET (a->window)); }
static void granite_hello_granite_hello_real_activate (GApplication* base) { GraniteHelloGraniteHello * self; Block1Data* _data1_; GtkWindow* _tmp0_; GtkWindow* _tmp1_; GtkWindow* _tmp2_; GtkButton* _tmp3_; GtkWindow* _tmp4_; GtkWindow* _tmp5_; self = (GraniteHelloGraniteHello*) base; _data1_ = g_slice_new0 (Block1Data); _data1_->_ref_count_ = 1; _data1_->self = g_object_ref (self); _tmp0_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL); g_object_ref_sink (_tmp0_); _g_object_unref0 (self->m_window); self->m_window = _tmp0_; _tmp1_ = self->m_window; gtk_window_set_default_size (_tmp1_, 800, 600); _tmp2_ = self->m_window; gtk_window_set_application (_tmp2_, (GtkApplication*) self); _tmp3_ = (GtkButton*) gtk_button_new_with_label ("Oh Boy!"); g_object_ref_sink (_tmp3_); _data1_->button = _tmp3_; g_signal_connect_data (_data1_->button, "clicked", (GCallback) ___lambda2__gtk_button_clicked, block1_data_ref (_data1_), (GClosureNotify) block1_data_unref, 0); _tmp4_ = self->m_window; gtk_container_add ((GtkContainer*) _tmp4_, (GtkWidget*) _data1_->button); _tmp5_ = self->m_window; gtk_widget_show_all ((GtkWidget*) _tmp5_); block1_data_unref (_data1_); _data1_ = NULL; }
void gnome_control_center_show (GnomeControlCenter *center, GtkApplication *app) { gtk_window_set_application (GTK_WINDOW (center->priv->window), app); gtk_widget_show (gtk_bin_get_child (GTK_BIN (center->priv->window))); }
static void trg_gtk_app_startup(GtkApplication * app, gpointer data) { TrgGtkAppPrivate *priv = GET_PRIVATE(app); TrgMainWindow *window = trg_main_window_new(priv->client, priv->min_start); gtk_window_set_application(GTK_WINDOW(window), app); }
void mate_about_run(void) { mate_about_dialog = (GtkAboutDialog*) gtk_about_dialog_new(); gtk_window_set_default_icon_name(desktop_icon); GtkIconTheme* icon_theme = gtk_icon_theme_get_default(); if (gtk_icon_theme_has_icon(icon_theme, icon)) { gtk_about_dialog_set_logo_icon_name(mate_about_dialog, icon); } else { gtk_about_dialog_set_logo_icon_name(mate_about_dialog, desktop_icon); } // name #if GTK_CHECK_VERSION(3, 0, 0) || GTK_CHECK_VERSION(2, 12, 0) gtk_about_dialog_set_program_name(mate_about_dialog, gettext(program_name)); #else gtk_about_dialog_set_name(mate_about_dialog, gettext(program_name)); #endif // version gtk_about_dialog_set_version(mate_about_dialog, version); // credits and website gtk_about_dialog_set_copyright(mate_about_dialog, copyright); gtk_about_dialog_set_website(mate_about_dialog, website); /** * This generate a random message. * The comments index must not be more than comments_count - 1 */ gtk_about_dialog_set_comments(mate_about_dialog, gettext(comments_array[g_random_int_range(0, comments_count - 1)])); gtk_about_dialog_set_authors(mate_about_dialog, authors); gtk_about_dialog_set_artists(mate_about_dialog, artists); gtk_about_dialog_set_documenters(mate_about_dialog, documenters); /* Translators should localize the following string which will be * displayed in the about box to give credit to the translator(s). */ gtk_about_dialog_set_translator_credits(mate_about_dialog, _("translator-credits")); #if GTK_CHECK_VERSION(3, 0, 0) gtk_about_dialog_set_license_type(mate_about_dialog, GTK_LICENSE_GPL_3_0); gtk_about_dialog_set_wrap_license(mate_about_dialog, TRUE); #endif #ifdef USE_UNIQUE unique_app_watch_window(mate_about_application, (GtkWindow*) mate_about_dialog); #elif GTK_CHECK_VERSION(3, 0, 0) && !defined(UNIQUE) gtk_window_set_application(GTK_WINDOW(mate_about_dialog), mate_about_application); #endif // start and destroy gtk_dialog_run((GtkDialog*) mate_about_dialog); gtk_widget_destroy((GtkWidget*) mate_about_dialog); }
static void preferences_app_activated (GtkApplication* app) { GtkApplication* _tmp0_; GList* _tmp1_ = NULL; GList* list; GList* _tmp2_; g_return_if_fail (app != NULL); _tmp0_ = app; _tmp1_ = gtk_application_get_windows (_tmp0_); list = _tmp1_; _tmp2_ = list; if (_tmp2_ != NULL) { GList* _tmp3_; gconstpointer _tmp4_; guint32 _tmp5_ = 0U; _tmp3_ = list; _tmp4_ = _tmp3_->data; _tmp5_ = gtk_get_current_event_time (); gtk_window_present_with_time ((GtkWindow*) _tmp4_, _tmp5_); } else { GtkWindow* _tmp6_; GtkWindow* _tmp7_; GtkWindow* dlg; GtkWindow* _tmp8_; const gchar* _tmp9_ = NULL; GtkWindow* _tmp10_; DejaDupPreferences* _tmp11_; DejaDupPreferences* _tmp12_; DejaDupPreferences* prefs; DejaDupPreferences* _tmp13_; GtkWindow* _tmp14_; DejaDupPreferences* _tmp15_; GtkWindow* _tmp16_; GtkApplication* _tmp17_; GtkWindow* _tmp18_; _tmp6_ = (GtkWindow*) gtk_window_new (GTK_WINDOW_TOPLEVEL); _tmp7_ = g_object_ref_sink (_tmp6_); dlg = _tmp7_; _tmp8_ = dlg; _tmp9_ = _ ("Backup"); gtk_window_set_title (_tmp8_, _tmp9_); _tmp10_ = dlg; gtk_window_set_resizable (_tmp10_, FALSE); _tmp11_ = deja_dup_preferences_new (); _tmp12_ = g_object_ref_sink (_tmp11_); prefs = _tmp12_; _tmp13_ = prefs; gtk_container_set_border_width ((GtkContainer*) _tmp13_, (guint) 12); _tmp14_ = dlg; _tmp15_ = prefs; gtk_container_add ((GtkContainer*) _tmp14_, (GtkWidget*) _tmp15_); _tmp16_ = dlg; _tmp17_ = app; gtk_window_set_application (_tmp16_, _tmp17_); _tmp18_ = dlg; gtk_widget_show_all ((GtkWidget*) _tmp18_); _g_object_unref0 (prefs); _g_object_unref0 (dlg); } }
void gw_window_set_application (GwWindow *window, GwApplication *application) { GwWindowPrivate *priv; priv = window->priv; priv->application = application; gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (application)); }
static void gt_win_init(GtWin* self) { GtWinPrivate* priv = gt_win_get_instance_private(self); GPropertyAction* action; GT_TYPE_PLAYER; // Hack to load GtPlayer into the symbols table GT_TYPE_PLAYER_HEADER_BAR; GT_TYPE_BROWSE_HEADER_BAR; GT_TYPE_CHANNELS_VIEW; GT_TYPE_GAMES_VIEW; GT_TYPE_FOLLOWS_VIEW; GT_TYPE_CHAT; gtk_window_set_application(GTK_WINDOW(self), GTK_APPLICATION(main_app)); gtk_widget_init_template(GTK_WIDGET(self)); gtk_widget_realize(priv->player_header_bar); priv->cur_info_data = NULL; priv->info_queue = g_queue_new(); gtk_window_set_default_size(GTK_WINDOW(self), g_settings_get_int(main_app->settings, "window-width"), g_settings_get_int(main_app->settings, "window-height")); gtk_window_set_default_icon_name("gnome-twitch"); g_object_bind_property(priv->browse_stack, "visible-child", self, "visible-view", G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE); GdkScreen* screen = gdk_screen_get_default(); GtkCssProvider* css = gtk_css_provider_new(); gtk_css_provider_load_from_resource(css, "/com/vinszent/GnomeTwitch/com.vinszent.GnomeTwitch.style.css"); gtk_style_context_add_provider_for_screen(screen, GTK_STYLE_PROVIDER(css), GTK_STYLE_PROVIDER_PRIORITY_APPLICATION); g_signal_connect_after(self, "key-press-event", G_CALLBACK(key_press_cb), self); g_signal_connect(self, "delete-event", G_CALLBACK(delete_cb), self); g_signal_connect_after(priv->info_bar, "response", G_CALLBACK(close_info_bar_cb), self); g_action_map_add_action_entries(G_ACTION_MAP(self), win_actions, G_N_ELEMENTS(win_actions), self); action = g_property_action_new("toggle_fullscreen", self, "fullscreen"); g_action_map_add_action(G_ACTION_MAP(self), G_ACTION(action)); g_object_unref(action); GtkWindowGroup* window_group = gtk_window_group_new(); gtk_window_group_add_window(window_group, GTK_WINDOW(self)); g_object_unref(window_group); }
static void activate (GtkApplication *app, gpointer user_data) { GtkWidget *window; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app)); gtk_window_set_title (GTK_WINDOW (window), "Hello GNOME"); gtk_widget_show_all (GTK_WIDGET (window)); }
static void activate(GtkApplication *app, Baka *baka) { GList *list; list = gtk_application_get_windows(baka->application); if(list != NULL) { gtk_window_present(GTK_WINDOW(list->data)); } else { baka->window = baka_load_interface(baka); gtk_window_set_application(GTK_WINDOW(baka->window), app); gtk_widget_show_all(baka->window); } }
/* Create a new window loading a file */ static void sereneplayer_new_window (GApplication *app, GFile *file) { GtkWidget *window; GtkWidget *headerbar; GtkWidget *canvas; GtkBuilder *builder; GError* error = NULL; SereneplayerPrivate *priv = SERENEPLAYER_APPLICATION(app)->priv; /* Load UI from file */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UI_FILE, &error)) { g_critical ("Couldn't load builder file: %s", error->message); g_error_free (error); } /* Auto-connect signal handlers */ gtk_builder_connect_signals (builder, app); /* Get the window object from the ui file */ window = GTK_WIDGET (gtk_builder_get_object (builder, TOP_WINDOW)); if (!window) { g_critical ("Widget \"%s\" is missing in file %s.", TOP_WINDOW, UI_FILE); } headerbar = GTK_WIDGET (gtk_builder_get_object (builder, HEADERBAR)); gtk_window_set_titlebar (GTK_WINDOW (window), headerbar); canvas = GTK_WIDGET (gtk_builder_get_object (builder, CANVAS)); /* ANJUTA: Widgets initialization for sereneplayer.ui - DO NOT REMOVE */ g_object_unref (builder); gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app)); if (file != NULL) { /* TODO: Add code here to open the file in the new window */ } MplayerWrap *mwrap = mplayerwrap_new(canvas); gtk_widget_show_all (GTK_WIDGET (window)); }
[+NameCLower+]_new_window (GApplication *app, GFile *file) { GtkWidget *window; [+IF (=(get "HaveBuilderUI") "1")+] GtkBuilder *builder; GError* error = NULL; [+NameCClass+]Private *priv = [+NameCUpper+]_APPLICATION(app)->priv; /* Load UI from file */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UI_FILE, &error)) { g_critical ("Couldn't load builder file: %s", error->message); g_error_free (error); } /* Auto-connect signal handlers */ gtk_builder_connect_signals (builder, app); /* Get the window object from the ui file */ window = GTK_WIDGET (gtk_builder_get_object (builder, TOP_WINDOW)); if (!window) { g_critical ("Widget \"%s\" is missing in file %s.", TOP_WINDOW, UI_FILE); } /* ANJUTA: Widgets initialization for [+NameHLower+].ui - DO NOT REMOVE */ g_object_unref (builder); [+ELSE+] window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "[+Name+]"); [+ENDIF+] gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app)); if (file != NULL) { /* TODO: Add code here to open the file in the new window */ } gtk_widget_show_all (GTK_WIDGET (window)); }
/* GApplication implementation */ static void roadmap_activate (GApplication *self) { GtkBuilder *builder; GError* error = NULL; RoadmapPrivate *priv = ROADMAP_GET_PRIVATE(self); GList *tickets; RoadmapTicket *ticket; /* Load UI from file */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UI_FILE, &error)) { g_critical ("Couldn't load builder file: %s", error->message); g_error_free (error); } /* Auto-connect signal handlers */ gtk_builder_connect_signals (builder, self); /* Get the window object from the ui file */ priv->main_window = GTK_WIDGET (gtk_builder_get_object (builder, TOP_WINDOW)); if (!priv->main_window) { g_critical ("Widget \"%s\" is missing in file %s.", TOP_WINDOW, UI_FILE); } g_object_unref (builder); gtk_window_set_application (GTK_WINDOW (priv->main_window), GTK_APPLICATION (self)); gtk_widget_show_all (GTK_WIDGET (priv->main_window)); tickets = roadmap_engine_get_tickets (priv->engine, "alvaro.pena"); while (tickets) { ticket = ROADMAP_TICKET (tickets->data); if (ROADMAP_IS_TICKET (ticket)) { gchar *summary; summary = roadmap_ticket_get_string_attribute (ticket, "summary"); g_print ("%s\n", summary); } tickets = g_list_next (tickets); } }
static void activate(GtkApplication *app, gpointer user_data) { GList *list = gtk_application_get_windows(app); if (list) { gtk_window_present(GTK_WINDOW(list->data)); } else { HandyWindow *window = handy_window_new(app); handy_window_setup(window); gtk_window_set_application(GTK_WINDOW(window), app); gtk_widget_show_all(GTK_WIDGET(window)); keybinder_init(); keybinder_bind("F10", handy_show_hide, window); } }
OxWindowObject* OxWindow_New(OxWidgetObject* oxParent, OxRect* rc, char* sCaption) { OxWindowObject* ox = (OxWindowObject*)OxObject_Allocate(pOxClass); if (ox == NULL) return NULL; if (!OxWidget_Init((OxWidgetObject*)ox, oxParent, rc)) return NULL; ox->oxIcon = NULL; ox->oxMenu = NULL; ox->oxToolBar = NULL; ox->oxStatusBar = NULL; ox->oxMdiArea = NULL; ox->oxWindow = ox; ox->oxFocusWidget = NULL; ox->fnBeforeCloseCB = NULL; ox->iMinWidth = 320; ox->iMinHeight = 240; ox->iMaxWidth = -1; ox->iMaxHeight = -1; ox->bModal = false; ox->bDeleteOnClose = true; ox->pGtk = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(ox->pGtk), sCaption); gtk_window_set_application(GTK_WINDOW(ox->pGtk), OxApp->pGtk); g_object_set_qdata(ox->pGtk, OxQuark, ox); //OxWidget_CalculateRect((OxWidgetObject*)ox, rc); gtk_window_set_default_size(GTK_WINDOW(ox->pGtk), rc->iWidth, rc->iHeight); gtk_window_move(GTK_WINDOW(ox->pGtk), rc->iLeft, rc->iTop); ox->pGtkFixed = gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(ox->pGtk), ox->pGtkFixed); gtk_widget_show_all(ox->pGtk); g_signal_connect(G_OBJECT(ox->pGtk), "configure-event", G_CALLBACK(OxWindowConfigureEventCB), ox); return ox; }
static void gth_window_init (GthWindow *window) { window->priv = G_TYPE_INSTANCE_GET_PRIVATE (window, GTH_TYPE_WINDOW, GthWindowPrivate); window->priv->grid = NULL; window->priv->contents = NULL; window->priv->pages = NULL; window->priv->n_pages = 0; window->priv->current_page = GTH_WINDOW_PAGE_UNDEFINED; window->priv->menubar = NULL; window->priv->toolbar = NULL; window->priv->infobar = NULL; window->priv->statusbar = NULL; window->priv->headerbar = NULL; window->priv->use_header_bar = FALSE; window->priv->window_group = gtk_window_group_new (); gtk_window_group_add_window (window->priv->window_group, GTK_WINDOW (window)); window->priv->accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), window->priv->accel_group); gtk_window_set_application (GTK_WINDOW (window), Main_Application); }
/** * @brief GUI thread load UI File and create the GUI */ static gpointer guiThread(gpointer data) { GtkBuilder *builder; GtkWidget *window; GError *error = NULL; /* create new GtkBuilder object */ builder = gtk_builder_new (); /* load UI from file. If error occurs, report it and quit application. */ if (!gtk_builder_add_from_file(builder, UI_FILE, &error)) { g_warning("error loading glade file: %s", error->message); g_free(error); return NULL; } /*Get objects from UI */ window = GTK_WIDGET (gtk_builder_get_object (builder, "window1")); scale1 = GTK_WIDGET (gtk_builder_get_object (builder, "scale1")); scale2 = GTK_WIDGET (gtk_builder_get_object (builder, "scale2")); scale3 = GTK_WIDGET (gtk_builder_get_object (builder, "scale3")); scale4 = GTK_WIDGET (gtk_builder_get_object (builder, "scale4")); scale5 = GTK_WIDGET (gtk_builder_get_object (builder, "scale5")); scale6 = GTK_WIDGET (gtk_builder_get_object (builder, "scale6")); adjustment1 = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment1")); adjustment2 = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment2")); adjustment3 = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment3")); adjustment4 = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment4")); adjustment5 = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment5")); adjustment6 = GTK_ADJUSTMENT (gtk_builder_get_object (builder, "adjustment6")); dialog_port = GTK_DIALOG (gtk_builder_get_object (builder, "dialog1")); dialog_about = GTK_DIALOG (gtk_builder_get_object (builder, "aboutdialog1")); dialog_file = GTK_DIALOG (gtk_builder_get_object (builder, "filechooserdialog1")); dialog_error = GTK_DIALOG (gtk_builder_get_object (builder, "dialog_error")); dialog_error_port = GTK_DIALOG (gtk_builder_get_object (builder, "dialog_error_port")); dialog_list = GTK_DIALOG (gtk_builder_get_object (builder, "dialog_list")); dialog_name_exists = GTK_DIALOG (gtk_builder_get_object (builder, "dialog_name_exists")); combobox1 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext1")); combobox2 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext2")); combobox3 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext3")); combobox4 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext4")); combobox5 = GTK_WIDGET (gtk_builder_get_object (builder, "comboboxtext5")); bt_con_decon = GTK_WIDGET (gtk_builder_get_object (builder, "bt_con_decon")); button_save = GTK_WIDGET (gtk_builder_get_object (builder, "bt_save_position")); button_file = GTK_WIDGET (gtk_builder_get_object (builder, "bt_file")); bt_file_save = GTK_WIDGET (gtk_builder_get_object (builder, "bt_file_save")); image_connect = GTK_IMAGE (gtk_builder_get_object (builder, "image_connect")); entry_name_position = GTK_WIDGET (gtk_builder_get_object (builder, "entry_name_position")); bt_ok_error_port = GTK_WIDGET (gtk_builder_get_object (builder, "bt_ok_error_port")); switch1 = GTK_WIDGET (gtk_builder_get_object (builder, "switch1")); bt_edit = GTK_WIDGET (gtk_builder_get_object (builder, "bt_edit")); bt_open_file = GTK_WIDGET (gtk_builder_get_object (builder, "bt_open_file")); treeview = GTK_TREE_VIEW (gtk_builder_get_object (builder, "treeview")); model = GTK_LIST_STORE (gtk_builder_get_object (builder, "model")); /*************************************************/ gtk_builder_connect_signals (builder, NULL); g_object_unref (G_OBJECT (builder)); gtk_window_set_application (GTK_WINDOW (window), GTK_APPLICATION (app)); gtk_window_set_title (GTK_WINDOW (window), "Servo Calibration"); gtk_window_set_default_size (GTK_WINDOW (window), 700,530); gtk_window_set_default_icon_from_file("../glade/img8.png", NULL); gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER); gtk_window_set_transient_for (GTK_WINDOW (dialog_port), GTK_WINDOW (window)); gtk_window_set_transient_for (GTK_WINDOW (dialog_about), GTK_WINDOW (window)); gtk_window_set_transient_for (GTK_WINDOW (dialog_file), GTK_WINDOW (window)); gtk_window_set_transient_for (GTK_WINDOW (dialog_error), GTK_WINDOW (window)); gtk_window_set_transient_for (GTK_WINDOW (dialog_error_port), GTK_WINDOW (window)); gtk_window_set_transient_for (GTK_WINDOW (dialog_list), GTK_WINDOW (window)); gtk_window_set_transient_for (GTK_WINDOW (dialog_name_exists), GTK_WINDOW (window)); gtk_scale_add_mark (GTK_SCALE(scale1), 0, GTK_POS_LEFT ,"0°"); gtk_scale_add_mark (GTK_SCALE(scale2), 0, GTK_POS_LEFT ,"0°"); gtk_scale_add_mark (GTK_SCALE(scale3), 0, GTK_POS_LEFT ,"0°"); gtk_scale_add_mark (GTK_SCALE(scale4), 0, GTK_POS_LEFT ,"0°"); gtk_scale_add_mark (GTK_SCALE(scale5), 0, GTK_POS_LEFT ,"0°"); gtk_scale_add_mark (GTK_SCALE(scale6), 0, GTK_POS_LEFT ,"0°"); gtk_widget_set_sensitive (GTK_WIDGET(entry_name_position), FALSE); gtk_widget_set_sensitive (GTK_WIDGET(button_save), FALSE); gtk_widget_set_sensitive (GTK_WIDGET(switch1), FALSE); gtk_widget_set_sensitive (GTK_WIDGET(bt_edit), FALSE); gtk_widget_show_all(GTK_WIDGET(window)); gtk_main(); return NULL; }
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); }
/** * gpk_log_startup_cb: **/ static void gpk_log_startup_cb (GtkApplication *application, gpointer user_data) { gboolean ret; GError *error = NULL; GSettings *settings; GtkEntryCompletion *completion; GtkTreeSelection *selection; GtkWidget *widget; GtkWindow *window; guint retval; client = pk_client_new (); g_object_set (client, "background", FALSE, NULL); /* get UI */ builder = gtk_builder_new (); retval = gtk_builder_add_from_file (builder, GPK_DATA "/pi-gpk-log.ui", &error); if (retval == 0) { g_warning ("failed to load ui: %s", error->message); g_error_free (error); goto out; } window = GTK_WINDOW (gtk_builder_get_object (builder, "dialog_simple")); gtk_window_set_icon_name (window, GPK_ICON_SOFTWARE_LOG); gtk_window_set_application (window, application); /* set a size, as the screen allows */ gpk_window_set_size_request (window, 1200, 1200); /* if command line arguments are set, then setup UI */ if (filter != NULL) { widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); gtk_entry_set_text (GTK_ENTRY(widget), filter); } widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_close")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_close_cb), application); gtk_widget_grab_default (widget); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_refresh")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_refresh_cb), NULL); gtk_widget_hide (widget); widget = GTK_WIDGET (gtk_builder_get_object (builder, "button_filter")); g_signal_connect (widget, "clicked", G_CALLBACK (gpk_log_button_filter_cb), NULL); /* hit enter in the search box for filter */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); g_signal_connect (widget, "activate", G_CALLBACK (gpk_log_button_filter_cb), NULL); /* autocompletion can be turned off as it's slow */ settings = g_settings_new (GPK_SETTINGS_SCHEMA); ret = g_settings_get_boolean (settings, GPK_SETTINGS_AUTOCOMPLETE); if (ret) { /* create the completion object */ completion = gpk_package_entry_completion_new (); widget = GTK_WIDGET (gtk_builder_get_object (builder, "entry_package")); gtk_entry_set_completion (GTK_ENTRY (widget), completion); g_object_unref (completion); } else { /* use search as you type */ g_signal_connect (widget, "key-release-event", G_CALLBACK (gpk_log_entry_filter_cb), NULL); } g_object_unref (settings); /* create list stores */ list_store = gtk_list_store_new (GPK_LOG_COLUMN_LAST, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); /* create transaction_id tree view */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "treeview_simple")); gtk_tree_view_set_model (GTK_TREE_VIEW (widget), GTK_TREE_MODEL (list_store)); selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget)); g_signal_connect (selection, "changed", G_CALLBACK (gpk_log_treeview_clicked_cb), NULL); /* add columns to the tree view */ pk_treeview_add_general_columns (GTK_TREE_VIEW (widget)); gtk_tree_view_columns_autosize (GTK_TREE_VIEW (widget)); gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), GPK_LOG_COLUMN_TIMESPEC, GTK_SORT_DESCENDING); /* show */ widget = GTK_WIDGET (gtk_builder_get_object (builder, "dialog_simple")); gtk_widget_show (widget); /* set the parent window if it is specified */ if (xid != 0) { g_debug ("Setting xid %i", xid); gpk_window_set_parent_xid (GTK_WINDOW (widget), xid); } /* get the update list */ gpk_log_refresh (); out: g_object_unref (list_store); g_object_unref (client); g_free (transaction_id); g_free (filter); if (transactions != NULL) g_ptr_array_unref (transactions); }
static void nautilus_bookmarks_window_constructed (GObject *object) { NautilusBookmarksWindow *self = NAUTILUS_BOOKMARKS_WINDOW (object); GtkBuilder *builder; GError *error = NULL; GtkWindow *window; GtkWidget *content; GtkTreeViewColumn *col; GtkCellRenderer *rend; G_OBJECT_CLASS (nautilus_bookmarks_window_parent_class)->constructed (object); builder = gtk_builder_new (); if (!gtk_builder_add_from_resource (builder, "/org/gnome/nautilus/nautilus-bookmarks-window.ui", &error)) { g_object_unref (builder); g_critical ("Can't load UI description for the bookmarks editor: %s", error->message); g_error_free (error); return; } window = GTK_WINDOW (object); gtk_window_set_title (window, _("Bookmarks")); gtk_window_set_default_size (window, BOOKMARKS_WINDOW_INITIAL_WIDTH, BOOKMARKS_WINDOW_INITIAL_HEIGHT); gtk_window_set_application (window, gtk_window_get_application (GTK_WINDOW (self->priv->parent_window))); gtk_window_set_destroy_with_parent (window, TRUE); gtk_window_set_transient_for (window, GTK_WINDOW (self->priv->parent_window)); gtk_window_set_position (window, GTK_WIN_POS_CENTER_ON_PARENT); gtk_container_set_border_width (GTK_CONTAINER (window), 6); g_signal_connect (window, "key-press-event", G_CALLBACK (nautilus_bookmarks_window_key_press_event_cb), NULL); content = GTK_WIDGET (gtk_builder_get_object (builder, "bookmarks_window_content")); gtk_container_add (GTK_CONTAINER (window), content); /* tree view */ self->priv->tree_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "bookmark_tree_view")); self->priv->selection = gtk_tree_view_get_selection (self->priv->tree_view); gtk_tree_selection_set_mode (self->priv->selection, GTK_SELECTION_BROWSE); rend = gtk_cell_renderer_pixbuf_new (); g_object_set (rend, "follow-state", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "gicon", BOOKMARK_LIST_COLUMN_ICON, NULL); gtk_tree_view_append_column (self->priv->tree_view, GTK_TREE_VIEW_COLUMN (col)); gtk_tree_view_column_set_fixed_width (GTK_TREE_VIEW_COLUMN (col), NAUTILUS_ICON_SIZE_SMALLER); rend = gtk_cell_renderer_text_new (); g_object_set (rend, "ellipsize", PANGO_ELLIPSIZE_END, "ellipsize-set", TRUE, NULL); col = gtk_tree_view_column_new_with_attributes ("Icon", rend, "text", BOOKMARK_LIST_COLUMN_NAME, "style", BOOKMARK_LIST_COLUMN_STYLE, NULL); gtk_tree_view_append_column (self->priv->tree_view, GTK_TREE_VIEW_COLUMN (col)); self->priv->model = create_bookmark_store (); setup_empty_list (self); /* name entry */ self->priv->name_field = nautilus_entry_new (); gtk_widget_show (self->priv->name_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_name_placeholder")), self->priv->name_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_name_label")), self->priv->name_field); /* URI entry */ self->priv->uri_field = nautilus_entry_new (); gtk_widget_show (self->priv->uri_field); gtk_box_pack_start (GTK_BOX (gtk_builder_get_object (builder, "bookmark_location_placeholder")), self->priv->uri_field, TRUE, TRUE, 0); gtk_label_set_mnemonic_widget ( GTK_LABEL (gtk_builder_get_object (builder, "bookmark_location_label")), self->priv->uri_field); /* buttons */ self->priv->remove_button = GTK_WIDGET (gtk_builder_get_object (builder, "bookmark_remove_button")); self->priv->up_button = GTK_WIDGET (gtk_builder_get_object (builder, "bookmark_up_button")); self->priv->down_button = GTK_WIDGET (gtk_builder_get_object (builder, "bookmark_down_button")); g_object_unref (builder); /* setup bookmarks list and signals */ self->priv->bookmarks = nautilus_application_get_bookmarks (NAUTILUS_APPLICATION (g_application_get_default ())); self->priv->bookmarks_changed_id = g_signal_connect (self->priv->bookmarks, "changed", G_CALLBACK (on_bookmark_list_changed), self); self->priv->row_changed_id = g_signal_connect (self->priv->model, "row-changed", G_CALLBACK (on_row_changed), self); self->priv->row_deleted_id = g_signal_connect (self->priv->model, "row-deleted", G_CALLBACK (on_row_deleted), self); self->priv->row_activated_id = g_signal_connect (self->priv->tree_view, "row-activated", G_CALLBACK (on_row_activated), self); self->priv->button_press_id = g_signal_connect (self->priv->tree_view, "button-press-event", G_CALLBACK (on_button_pressed), self); self->priv->key_press_id = g_signal_connect (self->priv->tree_view, "key-press-event", G_CALLBACK (on_key_pressed), self); self->priv->selection_changed_id = g_signal_connect (self->priv->selection, "changed", G_CALLBACK (on_selection_changed), self); self->priv->name_changed_id = g_signal_connect (self->priv->name_field, "changed", G_CALLBACK (on_name_field_changed), self); g_signal_connect (self->priv->name_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), self); g_signal_connect (self->priv->name_field, "activate", G_CALLBACK (name_or_uri_field_activate), self); self->priv->uri_changed_id = g_signal_connect (self->priv->uri_field, "changed", G_CALLBACK (on_uri_field_changed), self); g_signal_connect (self->priv->uri_field, "focus_out_event", G_CALLBACK (on_text_field_focus_out_event), self); g_signal_connect (self->priv->uri_field, "activate", G_CALLBACK (name_or_uri_field_activate), self); g_signal_connect (self->priv->remove_button, "clicked", G_CALLBACK (on_remove_button_clicked), self); g_signal_connect (self->priv->up_button, "clicked", G_CALLBACK (on_up_button_clicked), self); g_signal_connect (self->priv->down_button, "clicked", G_CALLBACK (on_down_button_clicked), self); /* Fill in list widget with bookmarks, must be after signals are wired up. */ repopulate (self); }
void create_main_window (GsmApplication *app) { GtkApplicationWindow *main_window; GtkStack *stack; GtkMenuButton *process_menu_button; GMenuModel *process_menu_model; GdkDisplay *display; GdkMonitor *monitor; GdkRectangle monitor_geometry; const char* session; int width, height, xpos, ypos; GtkBuilder *builder = gtk_builder_new(); gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/interface.ui", NULL); gtk_builder_add_from_resource (builder, "/org/gnome/gnome-system-monitor/data/menus.ui", NULL); main_window = GTK_APPLICATION_WINDOW (gtk_builder_get_object (builder, "main_window")); gtk_window_set_application (GTK_WINDOW (main_window), app->gobj()); gtk_widget_set_name (GTK_WIDGET (main_window), "gnome-system-monitor"); app->main_window = main_window; session = g_getenv ("XDG_CURRENT_DESKTOP"); if (session && !strstr (session, "GNOME")){ GtkBox *mainbox; GtkHeaderBar *headerbar; mainbox = GTK_BOX (gtk_builder_get_object (builder, "main_box")); headerbar = GTK_HEADER_BAR (gtk_builder_get_object (builder, "header_bar")); gtk_style_context_remove_class (gtk_widget_get_style_context (GTK_WIDGET (headerbar)), "titlebar"); gtk_window_set_titlebar (GTK_WINDOW (main_window), NULL); gtk_header_bar_set_show_close_button (headerbar, FALSE); gtk_box_pack_start (mainbox, GTK_WIDGET (headerbar), FALSE, FALSE, 0); } g_settings_get (app->settings->gobj(), GSM_SETTING_WINDOW_STATE, "(iiii)", &width, &height, &xpos, &ypos); display = gdk_display_get_default (); monitor = gdk_display_get_monitor_at_point (display, xpos, ypos); if (monitor == NULL) { monitor = gdk_display_get_monitor (display, 0); } gdk_monitor_get_geometry (monitor, &monitor_geometry); width = CLAMP (width, 50, monitor_geometry.width); height = CLAMP (height, 50, monitor_geometry.height); xpos = CLAMP (xpos, 0, monitor_geometry.width - width); ypos = CLAMP (ypos, 0, monitor_geometry.height - height); gtk_window_set_default_size (GTK_WINDOW (main_window), width, height); gtk_window_move (GTK_WINDOW (main_window), xpos, ypos); if (app->settings->get_boolean (GSM_SETTING_MAXIMIZED)) gtk_window_maximize (GTK_WINDOW (main_window)); app->process_menu_button = process_menu_button = GTK_MENU_BUTTON (gtk_builder_get_object (builder, "process_menu_button")); process_menu_model = G_MENU_MODEL (gtk_builder_get_object (builder, "process-window-menu")); gtk_menu_button_set_menu_model (process_menu_button, process_menu_model); app->end_process_button = GTK_BUTTON (gtk_builder_get_object (builder, "end_process_button")); app->search_button = GTK_BUTTON (gtk_builder_get_object (builder, "search_button")); GActionEntry win_action_entries[] = { { "about", on_activate_about, NULL, NULL, NULL }, { "search", on_activate_search, "b", "false", NULL }, { "send-signal-stop", on_activate_send_signal, "i", NULL, NULL }, { "send-signal-cont", on_activate_send_signal, "i", NULL, NULL }, { "send-signal-end", on_activate_send_signal, "i", NULL, NULL }, { "send-signal-kill", on_activate_send_signal, "i", NULL, NULL }, { "priority", on_activate_priority, "i", "@i 0", change_priority_state }, { "memory-maps", on_activate_memory_maps, NULL, NULL, NULL }, { "open-files", on_activate_open_files, NULL, NULL, NULL }, { "process-properties", on_activate_process_properties, NULL, NULL, NULL }, { "refresh", on_activate_refresh, NULL, NULL, NULL }, { "show-page", on_activate_radio, "s", "'resources'", change_show_page_state }, { "show-whose-processes", on_activate_radio, "s", "'all'", change_show_processes_state }, { "show-dependencies", on_activate_toggle, NULL, "false", change_show_dependencies_state } }; g_action_map_add_action_entries (G_ACTION_MAP (main_window), win_action_entries, G_N_ELEMENTS (win_action_entries), app); GdkScreen* screen = gtk_widget_get_screen(GTK_WIDGET (main_window)); GdkVisual* visual = gdk_screen_get_rgba_visual(screen); /* use visual, if available */ if (visual) gtk_widget_set_visual(GTK_WIDGET (main_window), visual); /* create the main stack */ app->stack = stack = GTK_STACK (gtk_builder_get_object (builder, "stack")); create_proc_view(app, builder); create_sys_view (app, builder); create_disk_view (app, builder); g_settings_bind (app->settings->gobj (), GSM_SETTING_CURRENT_TAB, stack, "visible-child-name", G_SETTINGS_BIND_DEFAULT); g_signal_connect (G_OBJECT (stack), "notify::visible-child", G_CALLBACK (cb_change_current_page), app); g_signal_connect (G_OBJECT (main_window), "delete_event", G_CALLBACK (cb_main_window_delete), app); g_signal_connect (G_OBJECT (main_window), "window-state-event", G_CALLBACK (cb_main_window_state_changed), app); GAction *action; action = g_action_map_lookup_action (G_ACTION_MAP (main_window), "show-dependencies"); g_action_change_state (action, g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_DEPENDENCIES)); action = g_action_map_lookup_action (G_ACTION_MAP (main_window), "show-whose-processes"); g_action_change_state (action, g_settings_get_value (app->settings->gobj (), GSM_SETTING_SHOW_WHOSE_PROCESSES)); gtk_widget_show (GTK_WIDGET (main_window)); update_page_activities (app); g_object_unref (G_OBJECT (builder)); }
void liferea_shell_create (GtkApplication *app, const gchar *overrideWindowState) { GtkUIManager *ui_manager; GtkAccelGroup *accel_group; GError *error = NULL; gboolean toggle; gchar *id; debug_enter ("liferea_shell_create"); g_object_new (LIFEREA_SHELL_TYPE, NULL); shell->priv->window = GTK_WINDOW (liferea_shell_lookup ("mainwindow")); gtk_window_set_application (GTK_WINDOW (shell->priv->window), app); /* 1.) menu creation */ debug0 (DEBUG_GUI, "Setting up menues"); shell->priv->itemlist = itemlist_create (); /* Prepare some toggle button states */ conf_get_bool_value (REDUCED_FEEDLIST, &toggle); liferea_shell_feedlist_toggle_entries[0].is_active = toggle; ui_manager = gtk_ui_manager_new (); shell->priv->generalActions = gtk_action_group_new ("GeneralActions"); gtk_action_group_set_translation_domain (shell->priv->generalActions, PACKAGE); gtk_action_group_add_actions (shell->priv->generalActions, liferea_shell_action_entries, G_N_ELEMENTS (liferea_shell_action_entries), shell->priv); gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_action_toggle_entries, G_N_ELEMENTS (liferea_shell_action_toggle_entries), shell->priv); gtk_action_group_add_radio_actions (shell->priv->generalActions, liferea_shell_view_radio_entries, G_N_ELEMENTS (liferea_shell_view_radio_entries), itemlist_get_view_mode (), (GCallback)on_view_activate, (gpointer)TRUE); gtk_action_group_add_toggle_actions (shell->priv->generalActions, liferea_shell_feedlist_toggle_entries, G_N_ELEMENTS (liferea_shell_feedlist_toggle_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->generalActions, 0); shell->priv->addActions = gtk_action_group_new ("AddActions"); gtk_action_group_set_translation_domain (shell->priv->addActions, PACKAGE); gtk_action_group_add_actions (shell->priv->addActions, liferea_shell_add_action_entries, G_N_ELEMENTS (liferea_shell_add_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->addActions, 0); shell->priv->feedActions = gtk_action_group_new ("FeedActions"); gtk_action_group_set_translation_domain (shell->priv->feedActions, PACKAGE); gtk_action_group_add_actions (shell->priv->feedActions, liferea_shell_feed_action_entries, G_N_ELEMENTS (liferea_shell_feed_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->feedActions, 0); shell->priv->readWriteActions = gtk_action_group_new("ReadWriteActions"); gtk_action_group_set_translation_domain (shell->priv->readWriteActions, PACKAGE); gtk_action_group_add_actions (shell->priv->readWriteActions, liferea_shell_read_write_action_entries, G_N_ELEMENTS (liferea_shell_read_write_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->readWriteActions, 0); shell->priv->itemActions = gtk_action_group_new ("ItemActions"); gtk_action_group_set_translation_domain (shell->priv->itemActions, PACKAGE); gtk_action_group_add_actions (shell->priv->itemActions, liferea_shell_item_action_entries, G_N_ELEMENTS (liferea_shell_item_action_entries), shell->priv); gtk_ui_manager_insert_action_group (ui_manager, shell->priv->itemActions, 0); accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (shell->priv->window), accel_group); g_object_unref (accel_group); g_signal_connect (gtk_accel_map_get (), "changed", G_CALLBACK (on_accel_change), NULL); if (!gtk_ui_manager_add_ui_from_string (ui_manager, liferea_shell_ui_desc, -1, &error)) g_error ("building menus failed: %s", error->message); shell->priv->menubar = gtk_ui_manager_get_widget (ui_manager, "/MainwindowMenubar"); shell->priv->toolbar = gtk_ui_manager_get_widget (ui_manager, "/maintoolbar"); /* Ensure GTK3 toolbar shadows... */ gtk_style_context_add_class (gtk_widget_get_style_context (shell->priv->toolbar), "primary-toolbar"); /* what a pain, why is there no markup for this option? */ g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/newFeedButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/nextUnreadButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/MarkAsReadButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/UpdateAllButton")), "is_important", TRUE, NULL); g_object_set (G_OBJECT (gtk_ui_manager_get_widget (ui_manager, "/maintoolbar/SearchButton")), "is_important", TRUE, NULL); /* 2.) setup containers */ debug0 (DEBUG_GUI, "Setting up widget containers"); gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->toolbar, 0); gtk_box_pack_start (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, FALSE, FALSE, 0); gtk_box_reorder_child (GTK_BOX (liferea_shell_lookup ("vbox1")), shell->priv->menubar, 0); gtk_widget_show_all(GTK_WIDGET(shell->priv->toolbar)); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_press_event", G_CALLBACK (on_key_press_event_null_cb), NULL); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "key_release_event", G_CALLBACK (on_key_press_event_null_cb), NULL); g_signal_connect ((gpointer) liferea_shell_lookup ("itemtabs"), "scroll_event", G_CALLBACK (on_notebook_scroll_event_null_cb), NULL); g_signal_connect (G_OBJECT (shell->priv->window), "delete_event", G_CALLBACK(on_close), shell->priv); g_signal_connect (G_OBJECT (shell->priv->window), "window_state_event", G_CALLBACK(on_window_state_event), shell->priv); g_signal_connect (G_OBJECT (shell->priv->window), "key_press_event", G_CALLBACK(on_key_press_event), shell->priv); /* 3.) setup status bar */ debug0 (DEBUG_GUI, "Setting up status bar"); shell->priv->statusbar = GTK_STATUSBAR (liferea_shell_lookup ("statusbar")); shell->priv->statusbarLocked = FALSE; shell->priv->statusbarLockTimer = 0; shell->priv->statusbar_feedsinfo = gtk_label_new(""); gtk_widget_show(shell->priv->statusbar_feedsinfo); gtk_box_pack_start (GTK_BOX (shell->priv->statusbar), shell->priv->statusbar_feedsinfo, FALSE, FALSE, 5); /* 4.) setup tabs */ debug0 (DEBUG_GUI, "Setting up tabbed browsing"); shell->priv->tabs = browser_tabs_create (GTK_NOTEBOOK (liferea_shell_lookup ("browsertabs"))); /* 5.) setup feed list */ debug0 (DEBUG_GUI, "Setting up feed list"); shell->priv->feedlistView = GTK_TREE_VIEW (liferea_shell_lookup ("feedlist")); feed_list_view_init (shell->priv->feedlistView); /* 6.) setup menu sensivity */ debug0 (DEBUG_GUI, "Initialising menues"); /* On start, no item or feed is selected, so Item menu should be insensitive: */ liferea_shell_update_item_menu (FALSE); /* necessary to prevent selection signals when filling the feed list and setting the 2/3 pane mode view */ gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), FALSE); /* 7.) setup item view */ debug0 (DEBUG_GUI, "Setting up item view"); shell->priv->itemview = itemview_create (GTK_WIDGET (shell->priv->window)); /* 8.) load icons as required */ debug0 (DEBUG_GUI, "Loading icons"); icons_load (); /* 9.) update and restore all menu elements */ liferea_shell_update_toolbar (); liferea_shell_update_history_actions (); liferea_shell_setup_URL_receiver (); liferea_shell_restore_state (overrideWindowState); gtk_widget_set_sensitive (GTK_WIDGET (shell->priv->feedlistView), TRUE); /* 10.) After main window is realized get theme colors and set up feed list and tray icon */ render_init_theme_colors (GTK_WIDGET (shell->priv->window)); shell->priv->feedlist = feedlist_create (); g_signal_connect (shell->priv->feedlist, "new-items", G_CALLBACK (liferea_shell_update_unread_stats), shell->priv->feedlist); /* 11.) Restore latest selection */ // FIXME: Move to feed list code if (conf_get_str_value (LAST_NODE_SELECTED, &id)) { feed_list_view_select (node_from_id (id)); g_free (id); } /* 12. Setup shell plugins */ shell->priv->extensions = peas_extension_set_new (PEAS_ENGINE (liferea_plugins_engine_get_default ()), LIFEREA_TYPE_SHELL_ACTIVATABLE, "shell", shell, NULL); g_signal_connect (shell->priv->extensions, "extension-added", G_CALLBACK (on_extension_added), shell); g_signal_connect (shell->priv->extensions, "extension-removed", G_CALLBACK (on_extension_removed), shell); peas_extension_set_call (shell->priv->extensions, "activate"); /* 14. Rebuild search folders if needed */ if (searchFolderRebuild) vfolder_foreach (vfolder_rebuild); debug_exit ("liferea_shell_create"); }
/* Create a new window loading a file */ static void shabdarth_new_window (GApplication *app, GFile *file) { GtkWidget *window; GtkBuilder *builder; GError* error = NULL; ShabdarthPrivate *priv = SHABDARTH_GET_PRIVATE(app); /* Load UI from file */ builder = gtk_builder_new (); if (!gtk_builder_add_from_file (builder, UI_FILE, &error)) { g_critical ("Couldn't load builder file: %s", error->message); g_error_free (error); } /* Auto-connect signal handlers */ gtk_builder_connect_signals (builder, app); /* Get the window object from the ui file */ mydata.window = GTK_WIDGET (gtk_builder_get_object (builder, TOP_WINDOW)); if (!mydata.window) { g_critical ("Widget \"%s\" is missing in file %s.", TOP_WINDOW, UI_FILE); } mydata.statusbar = GTK_STATUSBAR (gtk_builder_get_object(builder, "statusbar")); mydata.meaning_text_view = GTK_TEXT_VIEW (gtk_builder_get_object(builder, "meaning_text_view")); mydata.treeview = GTK_TREE_VIEW (gtk_builder_get_object(builder, "treeview")); mydata.input_word = GTK_ENTRY (gtk_builder_get_object(builder, "input_word")); // mydata.statusbar_context_id = gtk_statusbar_get_context_id ( mydata.statusbar,"shabdarth"); int i = 0; for( i = 0; i < ALPHABETS; i++ ) mydata.hash_tab[i] = NULL; // ************ initialising list_store_arr ************ for( i = 0; i < ALPHABETS; i++ ) mydata.list_store_arr[i] = NULL; gtk_tree_view_set_headers_visible ( mydata.treeview, FALSE ); //************ clipboard ************** //try GDK_SELECTION_CLIPBOARD or PRIMARY GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD); g_signal_connect(clipboard, "owner_change",G_CALLBACK(on_text_selection_changed), NULL); /* ANJUTA: Widgets initialization for shabdarth.ui - DO NOT REMOVE */ priv->treeview = GTK_WIDGET (gtk_builder_get_object(builder, "treeview")); g_object_unref (builder); gtk_window_set_application (GTK_WINDOW (mydata.window), GTK_APPLICATION (app)); if (file != NULL) { /* TODO: Add code here to open the file in the new window */ } gtk_widget_show_all (GTK_WIDGET (mydata.window)); gtk_statusbar_pop ( mydata.statusbar, mydata.statusbar_context_id ); gtk_statusbar_push (GTK_STATUSBAR (mydata.statusbar), mydata.statusbar_context_id, "Please enter a word"); }
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 int goo_application_command_line (GApplication *application, GApplicationCommandLine *command_line) { char **argv; int argc; GOptionContext *options_context; GError *error = NULL; GtkWidget *window; argv = g_application_command_line_get_arguments (command_line, &argc); options_context = goo_application_create_option_context (); if (! g_option_context_parse (options_context, &argc, &argv, &error)) { g_critical ("Failed to parse arguments: %s", error->message); g_error_free (error); g_option_context_free (options_context); return goo_application_command_line_finished (application, EXIT_FAILURE); } g_option_context_free (options_context); /* check the gstreamer plugins */ if (! required_gstreamer_plugins_available ()) { GtkWidget *d; d = _gtk_message_dialog_new (NULL, 0, _GTK_ICON_NAME_DIALOG_ERROR, _("Cannot start the CD player"), _("In order to read CDs you have to install the gstreamer base plugins"), _GTK_LABEL_OK, GTK_RESPONSE_OK, NULL); g_signal_connect_swapped (G_OBJECT (d), "response", G_CALLBACK (gtk_widget_destroy), d); gtk_window_set_application (GTK_WINDOW (d), GTK_APPLICATION (application)); gtk_widget_show (d); return goo_application_command_line_finished (application, EXIT_FAILURE); } /* execute the command line */ window = _gtk_application_get_current_window (GTK_APPLICATION (application)); if (window == NULL) window = goo_window_new (NULL); gtk_window_present (GTK_WINDOW (window)); if (arg_auto_play) { goo_window_play (GOO_WINDOW (window)); } else if (arg_toggle_play) { goo_window_toggle_play (GOO_WINDOW (window)); } else if (arg_stop) { goo_window_stop (GOO_WINDOW (window)); } else if (arg_next) { goo_window_next (GOO_WINDOW (window)); } else if (arg_prev) { goo_window_prev (GOO_WINDOW (window)); } else if (arg_eject) { goo_window_eject (GOO_WINDOW (window)); } else if (arg_toggle_visibility) { goo_window_toggle_visibility (GOO_WINDOW (window)); } else if (arg_quit) { goo_window_close (GOO_WINDOW (window)); } else if (arg_device != NULL) { BraseroDrive *drive; drive = main_get_drive_for_device (arg_device); window = main_get_window_from_device (arg_device); if (window == NULL) { window = goo_window_new (drive); gtk_widget_show (window); } else goo_window_set_drive (GOO_WINDOW (window), drive); g_object_unref (drive); g_free (arg_device); arg_device = NULL; } return goo_application_command_line_finished (application, EXIT_SUCCESS); }
/*! \return Pure instance from IjadiGui */ IjadiGui * Ijadi_gui_new() { IjadiGui *object = g_object_new(IJADI_TYPE_GUI, "type", GTK_WINDOW_TOPLEVEL,NULL); //Style Provider GtkStyleProvider *provider; provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ()); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (),provider,GTK_STYLE_PROVIDER_PRIORITY_FORCE); //Private creator IjadiGuiPrivate *priv = IJADI_GUI_PRIVATE(object); //Prepare Window gtk_window_set_position (GTK_WINDOW(object),GTK_WIN_POS_CENTER); gtk_window_set_title (GTK_WINDOW(object), "Ijadi"); //gtk_window_set_icon (GTK_WINDOW(object),create_pixbuf("/home/bijan/Source/Ijadi/PURE/Resourses/e.png")); //Style for window //gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET(object)), "ijadi-window"); //gtk_css_provider_load_from_path (GTK_CSS_PROVIDER(provider),LOCAL_RESOURCES"/style.css",NULL); //gtk_style_context_reset_widgets (gdk_screen_get_default ()); //------------Create Widget---------------- //Add welcome image priv->img_welcome = gtk_image_new_from_file ("/home/bijan/Project/Ijadi/PURE/Resources/mainwindow-welcome.png"); //Add Button priv->btn_new_project = gtk_button_new_with_label("New Project"); priv->img_new_project = gtk_image_new_from_file ("/home/bijan/Pictures/Icons/Files-Edit-file-icon.png"); gtk_button_set_always_show_image(GTK_BUTTON(priv->btn_new_project),TRUE); gtk_button_set_image (GTK_BUTTON(priv->btn_new_project),priv->img_new_project); // priv->btn_open_project = gtk_button_new_with_label("Open Project"); priv->img_open_project = gtk_image_new_from_file ("/home/bijan/Pictures/Icons/folder-open-icon.png"); gtk_button_set_always_show_image(GTK_BUTTON(priv->btn_open_project),TRUE); gtk_button_set_image (GTK_BUTTON(priv->btn_open_project),priv->img_open_project); // priv->btn_import_project = gtk_button_new_with_label("Import Project"); priv->img_import_project = gtk_image_new_from_file ("/home/bijan/Pictures/Icons/import-icon.png"); gtk_button_set_always_show_image(GTK_BUTTON(priv->btn_import_project),TRUE); gtk_button_set_image (GTK_BUTTON(priv->btn_import_project),priv->img_import_project); // priv->btn_import_url = gtk_button_new_with_label ("Import URL"); priv->img_import_url = gtk_image_new_from_file ("/home/bijan/Pictures/Icons/1372885853_folder_apollon.png"); gtk_button_set_always_show_image(GTK_BUTTON(priv->btn_import_url),TRUE); gtk_button_set_image (GTK_BUTTON(priv->btn_import_url),priv->img_import_url); //--------------Create Menu-------------- priv->menu_bar = ijadi_gui_create_menubar (); //------------Create ToolBar------------- priv->toolbar = ijadi_gui_create_toolbar(); //------------Create Layout-------------- //Create Button Box row 1 priv->box_button = gtk_grid_new (); gtk_grid_attach (GTK_GRID(box_button),priv->btn_new_project,0,0,1,1); gtk_grid_attach (GTK_GRID(box_button),priv->btn_open_project,1,0,1,1); gtk_box_pack_start (GTK_BOX(priv->box_button_1),priv->btn_new_project,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(priv->box_button_1),priv->btn_open_project,TRUE,TRUE,0); gtk_widget_set_margin_right(priv->box_button_1,5); gtk_widget_set_margin_left(priv->box_button_1,5); gtk_widget_set_margin_bottom(priv->box_button_1,5); gtk_widget_set_margin_top(priv->box_button_1,5); //Create Button Box row 2 priv->box_button = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start (GTK_BOX(priv->box_button_2),priv->btn_import_project,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(priv->box_button_2),priv->btn_import_url,TRUE,TRUE,0); gtk_widget_set_margin_right(priv->box_button_2,5); gtk_widget_set_margin_left(priv->box_button_2,5); gtk_widget_set_margin_bottom(priv->box_button_2,5); gtk_widget_set_margin_top(priv->box_button_2,5); // priv->box_main = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start (GTK_BOX(priv->box_main),priv->menu_bar,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(priv->box_main),priv->toolbar,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(priv->box_main),priv->img_welcome,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(priv->box_main),priv->box_button_1,TRUE,TRUE,0); gtk_box_pack_start (GTK_BOX(priv->box_main),priv->box_button_2,TRUE,TRUE,0); //Add layout to window gtk_container_add (GTK_CONTAINER (object), priv->box_main); //-----------Connect Signal------------- g_signal_connect (GTK_WIDGET(object), "destroy", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect (priv->btn_new_project, "clicked", G_CALLBACK (ijadi_gui_btn_new_project_clicked), object); //------------------Finalize----------------- gtk_window_set_application (GTK_WINDOW(object),GTK_APPLICATION(IJADI_APP)); return object; }