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;
}
