static void
egg_set_desktop_file_internal (const char *desktop_file_path,
gboolean set_defaults)
{
GError *error = NULL;
G_LOCK (egg_desktop_file);
if (egg_desktop_file)
egg_desktop_file_free (egg_desktop_file);
egg_desktop_file = egg_desktop_file_new (desktop_file_path, &error);
if (error)
{
g_warning ("Could not load desktop file '%s': %s",
desktop_file_path, error->message);
g_error_free (error);
}
if (set_defaults && egg_desktop_file != NULL) {
/* Set localized application name and default window icon */
if (egg_desktop_file->name)
g_set_application_name (egg_desktop_file->name);
if (egg_desktop_file->icon)
{
if (g_path_is_absolute (egg_desktop_file->icon))
gtk_window_set_default_icon_from_file (egg_desktop_file->icon, NULL);
else
gtk_window_set_default_icon_name (egg_desktop_file->icon);
}
}
G_UNLOCK (egg_desktop_file);
}
/**
* charge le fichier de configuration et initialise les variabes.
*
*
*
* */
gboolean gsb_grisbi_init_app ( void )
{
gboolean first_use = FALSE;
gchar *string;
#ifdef HAVE_PLUGINS
gsb_plugins_scan_dir ( gsb_dirs_get_plugins_dir ( ) );
#endif
/* create the icon of grisbi (set in the panel of gnome or other) */
string = g_build_filename ( gsb_dirs_get_pixmaps_dir ( ), "grisbi-logo.png", NULL );
if ( g_file_test ( string, G_FILE_TEST_EXISTS ) )
gtk_window_set_default_icon_from_file ( string, NULL );
g_free (string);
/* initialisation of the variables */
gsb_color_initialise_couleurs_par_defaut ( );
init_variables ();
register_import_formats ();
/* firt use ? */
if ( ! gsb_file_config_load_config () )
first_use = TRUE;
return first_use;
}
/**************************************************************** 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));
}
int main(int argc, char **argv)
{
GtkWidget *window;
char *cmd;
gtk_init(&argc, &argv);
gtk_window_set_default_icon_from_file(
DATA_DIR "/pixmaps/stoken-gui.png", NULL);
cmd = parse_cmdline(argc, argv, IS_GUI);
/* check for a couple of error conditions */
if (common_init(cmd))
error_dialog("Application error",
"Unable to initialize crypto library.");
if (!current_token)
error_dialog("Missing token",
"Please use 'stoken import' to add a new seed.");
if (securid_devid_required(current_token))
error_dialog("Unsupported token",
"Please use 'stoken' to handle tokens encrypted with a device ID.");
/* check for token expiration */
token_days_left = securid_check_exp(current_token, time(NULL));
if (!opt_force && !opt_small) {
if (token_days_left < 0)
error_dialog("Token expired",
"Please obtain a new token from your administrator.");
if (token_days_left < EXP_WARN_DAYS) {
char msg[BUFLEN];
sprintf(msg, "This token will expire in %d day%s.",
token_days_left,
token_days_left == 1 ? "" : "s");
warning_dialog(NULL, "Expiration warning", msg);
}
}
/* request password / PIN, if missing */
if (request_credentials(current_token) != ERR_NONE)
return 1;
token_interval = securid_token_interval(current_token);
token_uses_pin = securid_pin_required(current_token);
window = opt_small ? create_small_app_window() : create_app_window();
update_tokencode(NULL);
gtk_widget_show_all(window);
g_timeout_add(250, update_tokencode, NULL);
gtk_main();
return 0;
}
void init_Calc(Calc_win *calc,GtkBuilder *builder) {
// passando os objetos do xml para a struct
calc->janela = GTK_WIDGET (gtk_builder_get_object(builder,"calcWin"));
calc->button_0 =GTK_WIDGET (gtk_builder_get_object (builder, "button_0"));
calc->button_1 =GTK_WIDGET (gtk_builder_get_object (builder, "button_1"));
calc->button_2 =GTK_WIDGET (gtk_builder_get_object (builder, "button_2"));
calc->button_3 =GTK_WIDGET (gtk_builder_get_object (builder, "button_3"));
calc->button_4 =GTK_WIDGET (gtk_builder_get_object (builder, "button_4"));
calc->button_5 =GTK_WIDGET (gtk_builder_get_object (builder, "button_5"));
calc->button_6 =GTK_WIDGET (gtk_builder_get_object (builder, "button_6"));
calc->button_7 =GTK_WIDGET (gtk_builder_get_object (builder, "button_7"));
calc->button_8 =GTK_WIDGET (gtk_builder_get_object (builder, "button_8"));
calc->button_9 =GTK_WIDGET (gtk_builder_get_object (builder, "button_9"));
calc->button_div =GTK_WIDGET (gtk_builder_get_object (builder, "button_div"));
calc->button_mult =GTK_WIDGET (gtk_builder_get_object (builder, "button_mult"));
calc->button_sub =GTK_WIDGET (gtk_builder_get_object (builder, "button_sub"));
calc->button_soma =GTK_WIDGET (gtk_builder_get_object (builder, "button_soma"));
calc->button_mod =GTK_WIDGET (gtk_builder_get_object (builder, "button_mod"));
calc->button_exp =GTK_WIDGET (gtk_builder_get_object (builder, "button_exp"));
calc->button_ce =GTK_WIDGET (gtk_builder_get_object (builder, "button_ce"));
calc->button_igual =GTK_WIDGET (gtk_builder_get_object (builder, "button_igual"));
calc->button_vigula = GTK_WIDGET (gtk_builder_get_object (builder, "button_vigula"));
calc->painel_resultado =GTK_WIDGET (gtk_builder_get_object (builder, "painel_resultado"));
calc->fixed1 = GTK_WIDGET (gtk_builder_get_object (builder, "fixed1"));
calc->painel_parcial = GTK_WIDGET (gtk_builder_get_object (builder, "painel_parcial"));
// declarando a tarefa de cada botão
g_signal_connect (G_OBJECT (calc->janela), "destroy", G_CALLBACK (gtk_main_quit),(gpointer)calc->janela);
g_signal_connect (G_OBJECT (calc->button_0), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_1), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_2), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_3), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_4), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_5), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_6), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_7), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_8), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_9), "clicked", G_CALLBACK (inserir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_igual), "clicked", G_CALLBACK (resultado),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_ce), "clicked", G_CALLBACK (limpar),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_soma), "clicked", G_CALLBACK (soma),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_sub), "clicked", G_CALLBACK (subtrair),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_exp), "clicked", G_CALLBACK (expoente),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_div), "clicked", G_CALLBACK (dividir),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_mult), "clicked", G_CALLBACK (multiplicar),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_mod), "clicked", G_CALLBACK (oprMod),(gpointer)calc);
g_signal_connect (G_OBJECT (calc->button_vigula), "clicked", G_CALLBACK (virgulaPress),(gpointer)calc);
GError *er;
gtk_window_set_default_icon_from_file ("gnome-calculator.png",er); // icone do programa
g_object_unref (G_OBJECT (builder));
gtk_entry_set_text(GTK_ENTRY(calc->painel_resultado),"0");// iniciando painel com valor zero
}
static void
initialize_main_loop (void)
{
GtpEngineList site_configuration_engines;
#if THREADS_SUPPORTED
thread_events_queue = g_async_queue_new ();
thread_events = g_source_new (&thread_events_functions, sizeof (GSource));
g_source_set_callback (thread_events, thread_event_callback, NULL, NULL);
g_source_attach (thread_events, NULL);
#endif
quarry_stock_init ();
user_real_name = g_get_real_name ();
configuration_init (gtk_configuration_sections,
NUM_GTK_CONFIGURATION_SECTIONS);
/* Try to read site configuration file. Later,
* configuration_write_to_file() will effectively copy all
* site-default settings to user's configuration, with any changes
* she has made.
*
* Site configuration file is meant for distributions, to
* e.g. automatically register GNU Go with Quarry.
*/
configuration_read_from_file (gtk_configuration_sections,
NUM_GTK_CONFIGURATION_SECTIONS,
PACKAGE_DATA_DIR "/quarry.cfg");
gtp_engine_list_init (&site_configuration_engines);
string_list_steal_items (&site_configuration_engines, >p_engines);
configuration_file = g_build_path (G_DIR_SEPARATOR_S,
g_get_home_dir (), ".quarry", NULL);
configuration_read_from_file (gtk_configuration_sections,
NUM_GTK_CONFIGURATION_SECTIONS,
configuration_file);
configuration_combine_string_lists (>p_engines,
&site_configuration_engines,
(G_STRUCT_OFFSET
(GtpEngineListItem,
site_configuration_name)));
gtk_preferences_init ();
#if GTK_2_2_OR_LATER
gtk_window_set_default_icon_from_file (DATA_DIR "/pixmaps/quarry.png", NULL);
#endif
}
void
ephy_web_application_setup_from_profile_directory (const char *profile_directory)
{
const char *program_name;
const char *id;
char *app_icon;
char *desktop_basename;
char *desktop_filename;
GDesktopAppInfo *desktop_info;
g_assert (profile_directory != NULL);
program_name = ephy_web_application_get_program_name_from_profile_directory (profile_directory);
if (!program_name)
exit (1);
g_set_prgname (program_name);
id = get_app_id_from_program_name (program_name);
if (!id)
exit (1);
/* Get display name from desktop file */
desktop_basename = get_app_desktop_filename (id);
desktop_filename = g_build_filename (profile_directory, desktop_basename, NULL);
desktop_info = g_desktop_app_info_new_from_filename (desktop_filename);
if (!desktop_info) {
g_warning ("Required desktop file not present at %s", desktop_filename);
exit (1);
}
g_set_application_name (g_app_info_get_name (G_APP_INFO (desktop_info)));
app_icon = g_build_filename (profile_directory, EPHY_WEB_APP_ICON_NAME, NULL);
gtk_window_set_default_icon_from_file (app_icon, NULL);
/* We need to re-set this because we have already parsed the
* options, which inits GTK+ and sets this as a side effect.
*/
gdk_set_program_class (program_name);
g_free (app_icon);
g_free (desktop_basename);
g_free (desktop_filename);
g_object_unref (desktop_info);
}
static void
gth_application_init (GthApplication *app)
{
#ifdef GDK_WINDOWING_X11
GDesktopAppInfo *app_info;
app_info = g_desktop_app_info_new ("gthumb.desktop");
if (app_info == NULL)
return;
if (g_desktop_app_info_has_key (app_info, "Name")) {
char *app_name;
app_name = g_desktop_app_info_get_string (app_info, "Name");
g_set_application_name (app_name);
g_free (app_name);
}
if (g_desktop_app_info_has_key (app_info, "Icon")) {
char *icon;
icon = g_desktop_app_info_get_string (app_info, "Icon");
if (g_path_is_absolute (icon))
gtk_window_set_default_icon_from_file (icon, NULL);
else
gtk_window_set_default_icon_name (icon);
g_free (icon);
}
g_object_unref (app_info);
#else
/* manually set name and icon */
g_set_application_name (_("gThumb"));
gtk_window_set_default_icon_name ("gthumb");
#endif
}
// app bmd_activate callback - creates the window
static void
bmd_activate (GtkApplication* app,
gpointer user_data)
{
GtkWidget *vbox;
bmd_widgets *a = (bmd_widgets *) user_data;
/* create window, etc */
a->window = gtk_application_window_new (a->app);
gtk_window_set_title (GTK_WINDOW (a->window), "Book Management");
gtk_container_set_border_width (GTK_CONTAINER (a->window), 5);
gtk_window_set_default_size (GTK_WINDOW (a->window), 800, 400);
gtk_window_set_default_icon_from_file ("bmd_icon.png", NULL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 5);
gtk_container_add (GTK_CONTAINER (a->window), vbox);
/* moved the creation of the program to a dedicated function */
construct_editablecells (app, GTK_WIDGET (vbox), (gpointer) a);
gtk_widget_show_all (a->window);
}
int
main(int argc, char **argv)
{
char *message;
int result;
gtk_init(&argc, &argv);
gtk_window_set_default_icon_from_file ("/usr/share/pixmaps/ssh-askpass-gnome.png", NULL);
if (argc > 1) {
message = g_strjoinv(" ", argv + 1);
} else {
message = g_strdup("Enter your OpenSSH passphrase:");
}
setvbuf(stdout, 0, _IONBF, 0);
result = passphrase_dialog(message);
g_free(message);
return (result);
}
// app bmd_activate callback - creates the window
static void
bmd_activate (GtkApplication* app,
gpointer user_data)
{
GtkWidget *box;
GtkWidget *hbox;
GtkWidget *pbutton, *nbutton;
bmd_widgets *a = (bmd_widgets *) user_data;
// create the window and set a title
a->window = gtk_application_window_new (a->app);
gtk_window_set_title (GTK_WINDOW (a->window), "Demo");
gtk_window_set_resizable (GTK_WINDOW (a->window), FALSE);
gtk_window_set_default_icon_from_file ("bmd_icon.png", NULL);
// create a grid to be used as layout container
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (a->window), box);
// create the inner horizontal box
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start (GTK_BOX (box), hbox, TRUE, TRUE, 0);
// PREV button
pbutton = gtk_button_new_with_mnemonic ("_Prev");
gtk_box_pack_start (GTK_BOX (hbox), pbutton, TRUE, TRUE, 2);
g_signal_connect (pbutton, "clicked", G_CALLBACK (bmd_prev_clicked), (gpointer) a);
// NEXT button
nbutton = gtk_button_new_with_mnemonic ("_Next");
gtk_box_pack_start (GTK_BOX (hbox), nbutton, TRUE, TRUE, 2);
g_signal_connect (nbutton, "clicked", G_CALLBACK (bmd_next_clicked), (gpointer) a);
/* moved the creation of the program to a dedicated function */
bmd_construct_imagedemo (app, GTK_WIDGET (box), (gpointer) a);
gtk_widget_show_all (a->window);
}
void
ephy_web_application_setup_from_desktop_file (GDesktopAppInfo *desktop_info)
{
GAppInfo *app_info;
const char *wm_class;
GIcon *icon;
g_assert (G_IS_DESKTOP_APP_INFO (desktop_info));
app_info = G_APP_INFO (desktop_info);
g_set_prgname (g_app_info_get_name (app_info));
g_set_application_name (g_app_info_get_display_name (app_info));
icon = g_app_info_get_icon (app_info);
if (G_IS_FILE_ICON (icon)) {
GFile *file = g_file_icon_get_file (G_FILE_ICON (icon));
char *path = file ? g_file_get_path (file) : NULL;
if (path) {
gtk_window_set_default_icon_from_file (path, NULL);
g_free (path);
}
g_clear_object (&file);
} else if (G_IS_THEMED_ICON (icon)) {
const char * const *names = g_themed_icon_get_names (G_THEMED_ICON (icon));
if (names)
gtk_window_set_default_icon_name (names[0]);
}
g_clear_object (&icon);
/* We need to re-set this because we have already parsed the
* options, which inits GTK+ and sets this as a side effect.
*/
wm_class = g_desktop_app_info_get_startup_wm_class (desktop_info);
if (wm_class)
gdk_set_program_class (wm_class);
}
int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *menubar;
time_t now;
struct tm *tm;
GThread *gth = NULL; /* thread id */
gboolean run_flag = TRUE; /* used as exit flag for threads */
int i;
putenv("UBUNTU_MENUPROXY=");
//init_trees();
gdk_color_parse("#FFFF00", &color_yellow);
gdk_color_parse("#FFFFFF", &color_white);
gdk_color_parse("#404040", &color_grey);
gdk_color_parse("#00FF00", &color_green);
gdk_color_parse("#007700", &color_darkgreen);
gdk_color_parse("#0000FF", &color_blue);
gdk_color_parse("#FF0000", &color_red);
gdk_color_parse("#770000", &color_darkred);
gdk_color_parse("#000000", &color_black);
font = pango_font_description_from_string("Sans bold 12");
#ifdef WIN32
installation_dir = g_win32_get_package_installation_directory_of_module(NULL);
#else
gbr_init(NULL);
installation_dir = gbr_find_prefix(NULL);
#endif
program_path = argv[0];
current_directory[0] = 0;
if (current_directory[0] == 0)
strcpy(current_directory, ".");
conffile = g_build_filename(g_get_user_data_dir(), "judoproxy.ini", NULL);
/* create video download dir */
video_dir = g_build_filename(g_get_home_dir(), "rpivideos", NULL);
g_print("Video dir = %s\n", video_dir);
g_mkdir_with_parents(video_dir, 0755);
keyfile = g_key_file_new();
g_key_file_load_from_file(keyfile, conffile, 0, NULL);
now = time(NULL);
tm = localtime(&now);
current_year = tm->tm_year+1900;
srand(now); //srandom(now);
my_address = now + getpid()*10000;
gtk_init (&argc, &argv);
main_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "JudoProxy");
gtk_widget_set_size_request(window, FRAME_WIDTH, FRAME_HEIGHT);
gchar *iconfile = g_build_filename(installation_dir, "etc", "judoproxy.png", NULL);
gtk_window_set_default_icon_from_file(iconfile, NULL);
g_free(iconfile);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
main_vbox = gtk_grid_new();
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
gtk_widget_show(main_vbox);
/* menubar */
menubar = get_menubar_menu(window);
gtk_widget_show(menubar);
gtk_grid_attach(GTK_GRID(main_vbox), menubar, 0, 0, 1, 1);
gtk_widget_set_hexpand(menubar, TRUE);
/* judoka info */
//name_box = gtk_label_new("?");
//gtk_box_pack_start(GTK_BOX(main_vbox), name_box, FALSE, TRUE, 0);
//GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
//gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 0);
notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
gtk_widget_set_hexpand(notebook, TRUE);
//gtk_widget_set_vexpand(notebook, TRUE);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
/*
GtkWidget *camera_table = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(camera_table), 10);
gtk_grid_set_row_spacing(GTK_GRID(camera_table), 10);
*/
for (i = 0; i < NUM_TATAMIS; i++) {
gchar buf[32];
GtkWidget *data_table = gtk_grid_new();
connections[i].scrolled_window = data_table;
//connections[i].scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(connections[i].scrolled_window), 10);
snprintf(buf, sizeof(buf), "T%d [--]", i+1);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), connections[i].scrolled_window,
gtk_label_new(buf));
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("Camera")), 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("JudoTimer")), 4, 0, 2, 1);
GtkWidget *reload = gtk_button_new_with_label(_("Reload"));
gtk_grid_attach(GTK_GRID(data_table), reload, 0, 1, 1, 1);
connections[i].in_addr = gtk_entry_new();
connections[i].out_addr = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(connections[i].in_addr), 15);
gtk_entry_set_width_chars(GTK_ENTRY(connections[i].out_addr), 15);
gtk_grid_attach(GTK_GRID(data_table), connections[i].in_addr, 2, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), connections[i].out_addr, 6, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(" "), 0, 1, 1, 1);
//gtk_container_add(GTK_CONTAINER(connections[i].scrolled_window), data_table);
g_signal_connect (connections[i].out_addr, "activate",
G_CALLBACK(enter_callback),
gint_to_ptr(i));
g_signal_connect (connections[i].in_addr, "activate",
G_CALLBACK(camera_ip_enter_callback),
gint_to_ptr(i));
#ifdef WEBKIT
g_signal_connect (reload, "clicked",
G_CALLBACK(reload_web),
gint_to_ptr(i));
#else
g_signal_connect (reload, "clicked",
G_CALLBACK(select_camera_video),
gint_to_ptr(i));
#endif
}
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), notebook, NULL, GTK_POS_BOTTOM, 1, 1);
progress_bar = gtk_progress_bar_new();
gtk_grid_attach_next_to(GTK_GRID(main_vbox), progress_bar, NULL, GTK_POS_BOTTOM, 1, 1);
GtkWidget *w = GTK_WIDGET(gtk_scrolled_window_new(NULL, NULL));
#ifdef WEBKIT
web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
webkit_web_view_set_transparent(web_view, TRUE);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(web_view));
gtk_widget_set_vexpand(GTK_WIDGET(web_view), TRUE);
WebKitWebSettings *web_settings = webkit_web_settings_new();
//g_object_set(G_OBJECT(web_settings), "enable-java-applet", FALSE, NULL);
//g_object_set(G_OBJECT(web_settings), "enable-plugins", FALSE, NULL);
webkit_web_view_set_settings(web_view, web_settings);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1);
gtk_widget_grab_focus(GTK_WIDGET(web_view));
//webkit_web_view_load_uri(web_view, "http://www.hs.fi");
webkit_web_view_load_uri(web_view, "http://www.quirksmode.org/html5/tests/video.html");
g_signal_connect(web_view, "download-requested", G_CALLBACK(download_req), NULL);
//g_signal_connect(web_view, "load-changed", G_CALLBACK(load_changed), NULL);
#else
/* HTML page */
html_page = create_html_page();
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(html_page), NULL, GTK_POS_BOTTOM, 1, 1);
/* Video display */
camera_image = gtk_image_new();
gtk_widget_set_size_request(GTK_WIDGET(camera_image), 640, 360);
GtkWidget *event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), camera_image);
gtk_widget_set_events(event_box, gtk_widget_get_events(event_box) |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
/*GDK_POINTER_MOTION_MASK |*/
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK);
g_signal_connect(G_OBJECT(event_box),
"button_press_event",
G_CALLBACK(button_press_callback),
camera_image);
g_signal_connect(G_OBJECT(event_box),
"button_release_event",
G_CALLBACK(button_release_callback),
camera_image);
g_signal_connect(G_OBJECT(event_box),
"motion-notify-event",
G_CALLBACK(button_notify_callback),
camera_image);
gtk_widget_show(camera_image);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(event_box));
gtk_widget_set_vexpand(GTK_WIDGET(event_box), TRUE);
gtk_widget_set_hexpand(GTK_WIDGET(event_box), TRUE);
gtk_widget_set_vexpand(GTK_WIDGET(camera_image), TRUE);
gtk_widget_set_hexpand(GTK_WIDGET(camera_image), TRUE);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1);
#endif
/* timers */
timer = g_timer_new();
gtk_widget_show_all(window);
set_preferences();
change_language(NULL, NULL, gint_to_ptr(language));
open_comm_socket();
scan_interfaces();
/* Create a bg thread using glib */
gpointer proxy_ssdp_thread(gpointer args);
g_snprintf(ssdp_id, sizeof(ssdp_id), "JudoProxy");
static gint run[NUM_CONNECTIONS];
for (i = 0; i < NUM_CONNECTIONS; i++) {
char tname[16];
run[i] = i;
sprintf(tname, "Connection%d", i);
gth = g_thread_new(tname,
(GThreadFunc)connection_thread,
&run[i]);
}
gth = g_thread_new("SSDP",
(GThreadFunc)proxy_ssdp_thread,
(gpointer)&run_flag);
gth = g_thread_new("CameraVideo",
camera_video,
(gpointer)&run_flag);
gth = gth; // make compiler happy
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
cursor = gdk_cursor_new(GDK_HAND2);
//gdk_window_set_cursor(GTK_WIDGET(main_window)->window, cursor);
//g_timeout_add(100, timeout_ask_for_data, NULL);
g_timeout_add(1000, check_table, NULL);
g_timeout_add(100, show_camera_video, NULL);
//g_idle_add(show_camera_video, NULL);
/* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or
* mouse event). */
gtk_main();
for (i = 0; i < NUM_CONNECTIONS; i++)
run[i] = -1;
run_flag = FALSE; /* flag threads to stop and exit */
//g_thread_join(gth); /* wait for thread to exit */
return 0;
}
/**
* Initialize GTK interface.
*/
static void gui_init(int argc, char** argv, char **respath)
{
char buf[PATH_MAX];
const char *addr = NETSURF_HOMEPAGE;
char *resource_filename;
/* check user options */
check_options(respath);
/* find the languages file */
languages_file_location = filepath_find(respath, "languages");
if ((languages_file_location == NULL) ||
(strlen(languages_file_location) < 10)) {
die("Unable to find resources.\n");
}
/* Obtain resources path location.
*
* Uses the directory the languages file was found in,
* @todo find and slaughter all references to this!
*/
res_dir_location = calloc(1, strlen(languages_file_location) - 8);
memcpy(res_dir_location,
languages_file_location,
strlen(languages_file_location) - 9);
LOG(("Using '%s' for resource path", res_dir_location));
/* initialise the glade templates */
nsgtk_init_glade(respath);
/* set default icon if its available */
resource_filename = filepath_find(respath, "netsurf.xpm");
if (resource_filename != NULL) {
gtk_window_set_default_icon_from_file(resource_filename, NULL);
free(resource_filename);
}
/* Search engine sources */
search_engines_file_location = filepath_find(respath, "SearchEngines");
LOG(("Using '%s' as Search Engines file", search_engines_file_location));
/* Default Icon */
search_default_ico_location = filepath_find(respath, "default.ico");
LOG(("Using '%s' as default search ico", search_default_ico_location));
/* Default favicon */
resource_filename = filepath_find(respath, "favicon.png");
if (resource_filename != NULL) {
favicon_pixbuf = gdk_pixbuf_new_from_file(resource_filename, NULL);
free(resource_filename);
if (favicon_pixbuf == NULL) {
favicon_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, false, 8, 16,16);
}
}
/* Toolbar inicies file */
toolbar_indices_file_location = filepath_find(respath, "toolbarIndices");
LOG(("Using '%s' as custom toolbar settings file", toolbar_indices_file_location));
/* load throbber images */
if (nsgtk_throbber_init(respath, THROBBER_FRAMES) == false)
die("Unable to load throbber image.\n");
/* Initialise completions - cannot fail */
nsgtk_completion_init();
filepath_sfinddef(respath, buf, "mime.types", "/etc/");
gtk_fetch_filetype_init(buf);
urldb_load(nsoption_charp(url_file));
urldb_load_cookies(nsoption_charp(cookie_file));
/* The tree view system needs to know the screen's DPI, so we
* find that out here, rather than when we create a first browser
* window.
*/
nscss_screen_dpi = FLTTOFIX(gdk_screen_get_resolution(
gdk_screen_get_default()));
LOG(("Set CSS DPI to %f", FIXTOFLT(nscss_screen_dpi)));
if (nsgtk_history_init(glade_file_location->history) == false)
die("Unable to initialise history window.\n");
if (nsgtk_download_init(glade_file_location->downloads) == false)
die("Unable to initialise download window.\n");
if (nsgtk_cookies_init(glade_file_location->cookies) == false)
die("Unable to initialise cookies window.\n");
if (nsgtk_hotlist_init(glade_file_location->hotlist) == false)
die("Unable to initialise hotlist window.\n");
sslcert_init(tree_content_icon_name);
if (nsoption_charp(homepage_url) != NULL) {
addr = nsoption_charp(homepage_url);
}
if (2 <= argc)
addr = argv[1];
/* Last step of initialization. Opens the main browser window. */
browser_window_create(addr, 0, 0, true, false);
}
GtkWidget *gui_build_interface(void)
{
GtkWidget *vbox;
GtkWidget *menubar;
GtkActionGroup *action_group;
GtkAccelGroup *accel_group;
GError *error = NULL;
gchar *icon_file;
player_init();
gmap = guimap_new();
register_pixmaps();
app_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* The name of the application */
gtk_window_set_title(GTK_WINDOW(app_window), _("Pioneers"));
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(app_window), vbox);
action_group = gtk_action_group_new("MenuActions");
gtk_action_group_set_translation_domain(action_group, PACKAGE);
gtk_action_group_add_actions(action_group, entries,
G_N_ELEMENTS(entries), app_window);
gtk_action_group_add_toggle_actions(action_group, toggle_entries,
G_N_ELEMENTS(toggle_entries),
app_window);
ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
accel_group = gtk_ui_manager_get_accel_group(ui_manager);
gtk_window_add_accel_group(GTK_WINDOW(app_window), accel_group);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string
(ui_manager, ui_description, -1, &error)) {
g_message("building menus failed: %s", error->message);
g_error_free(error);
return NULL;
}
icon_file =
g_build_filename(DATADIR, "pixmaps", PIONEERS_ICON_FILE, NULL);
if (g_file_test(icon_file, G_FILE_TEST_EXISTS)) {
gtk_window_set_default_icon_from_file(icon_file, NULL);
} else {
/* Missing pixmap, main icon file */
g_warning("Pixmap not found: %s", icon_file);
}
g_free(icon_file);
color_chat_enabled =
config_get_int_with_default("settings/color_chat", TRUE);
color_messages_enabled =
config_get_int_with_default("settings/color_messages", TRUE);
log_set_func_message_color_enable(color_messages_enabled);
set_color_summary(config_get_int_with_default
("settings/color_summary", TRUE));
set_silent_mode(config_get_int_with_default
("settings/silent_mode", FALSE));
set_announce_player(config_get_int_with_default
("settings/announce_player", TRUE));
legend_page_enabled =
config_get_int_with_default("settings/legend_page", FALSE);
menubar = gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
toolbar = gtk_ui_manager_get_widget(ui_manager, "/MainToolbar");
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), build_main_interface(), TRUE,
TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), build_status_bar(), FALSE, FALSE,
0);
gtk_toggle_action_set_active(GTK_TOGGLE_ACTION
(gtk_ui_manager_get_action
(ui_manager,
"ui/MainMenu/SettingsMenu/ShowHideToolbar")),
config_get_int_with_default
("settings/show_toolbar", TRUE));
g_signal_connect(G_OBJECT(app_window), "key_press_event",
G_CALLBACK(hotkeys_handler), NULL);
gtk_widget_show(app_window);
frontend_gui_register_action(getAction(GUI_CONNECT), GUI_CONNECT);
frontend_gui_register_action(getAction(GUI_DISCONNECT),
GUI_DISCONNECT);
#ifdef ADMIN_GTK
/** @todo RC 2005-05-26 Admin interface: Not tested */
frontend_gui_register_action(gtk_ui_manager_get_action
(manager,
"ui/MainMenu/GameMenu/GameAdmin"),
GUI_ADMIN);
#endif
frontend_gui_register_action(getAction(GUI_CHANGE_NAME),
GUI_CHANGE_NAME);
frontend_gui_register_action(getAction(GUI_ROLL), GUI_ROLL);
frontend_gui_register_action(getAction(GUI_TRADE), GUI_TRADE);
frontend_gui_register_action(getAction(GUI_UNDO), GUI_UNDO);
frontend_gui_register_action(getAction(GUI_FINISH), GUI_FINISH);
frontend_gui_register_action(getAction(GUI_ROAD), GUI_ROAD);
frontend_gui_register_action(getAction(GUI_SHIP), GUI_SHIP);
frontend_gui_register_action(getAction(GUI_MOVE_SHIP),
GUI_MOVE_SHIP);
frontend_gui_register_action(getAction(GUI_BRIDGE), GUI_BRIDGE);
frontend_gui_register_action(getAction(GUI_SETTLEMENT),
GUI_SETTLEMENT);
frontend_gui_register_action(getAction(GUI_CITY), GUI_CITY);
frontend_gui_register_action(getAction(GUI_BUY_DEVELOP),
GUI_BUY_DEVELOP);
frontend_gui_register_action(getAction(GUI_CITY_WALL),
GUI_CITY_WALL);
#if 0
frontend_gui_register_destroy(gtk_ui_manager_get_action
(manager, "GameQuit"), GUI_QUIT);
#endif
gui_toolbar_show_button("BuildShip", FALSE);
gui_toolbar_show_button("MoveShip", FALSE);
gui_toolbar_show_button("BuildBridge", FALSE);
gui_toolbar_show_accelerators(config_get_int_with_default
("settings/toolbar_show_accelerators",
TRUE));
gtk_ui_manager_ensure_update(ui_manager);
gtk_widget_show(app_window);
g_signal_connect(G_OBJECT(app_window), "delete_event",
G_CALLBACK(quit_cb), NULL);
return app_window;
}
int main(int argc, char *argv[])
{
gchar *filename;
gboolean default_used;
GtkWidget *notebook;
GtkActionGroup *action_group;
GtkUIManager *ui_manager;
GtkWidget *vbox;
GtkWidget *menubar;
GtkAccelGroup *accel_group;
GError *error = NULL;
gchar *icon_file;
GOptionContext *context;
default_game = g_build_filename(get_pioneers_dir(), "default.game",
NULL);
/* Gtk+ handles the locale, we must bind the translations */
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, LOCALEDIR);
textdomain(PACKAGE);
bind_textdomain_codeset(PACKAGE, "UTF-8");
GtkOSXApplication *theApp = g_object_new(GTK_TYPE_OSX_APPLICATION, NULL);
context =
/* Long description in the command line: --help */
g_option_context_new(_("- Editor for games of Pioneers"));
g_option_context_add_main_entries(context, commandline_entries,
GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
g_option_context_parse(context, &argc, &argv, &error);
if (error != NULL) {
g_print("%s\n", error->message);
g_error_free(error);
return 1;
}
if (show_version) {
g_print(_("Pioneers version:"));
g_print(" ");
g_print(FULL_VERSION);
g_print("\n");
return 0;
}
if (filenames != NULL)
filename = g_strdup(filenames[0]);
else
filename = NULL;
toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(toplevel), "delete_event",
G_CALLBACK(exit_cb), NULL);
action_group = gtk_action_group_new("MenuActions");
gtk_action_group_set_translation_domain(action_group, PACKAGE);
gtk_action_group_add_actions(action_group, entries,
G_N_ELEMENTS(entries), toplevel);
ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
accel_group = gtk_ui_manager_get_accel_group(ui_manager);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_group);
error = NULL;
if (!gtk_ui_manager_add_ui_from_string(ui_manager, ui_description,
-1, &error)) {
g_message(_("Building menus failed: %s"), error->message);
g_error_free(error);
return 1;
}
config_init("pioneers-editor");
icon_file =
g_build_filename(g_get_user_runtime_dir(), "pixmaps", MAINICON_FILE, NULL);
if (g_file_test(icon_file, G_FILE_TEST_EXISTS)) {
gtk_window_set_default_icon_from_file(icon_file, NULL);
} else {
/* Missing pixmap, main icon file */
g_warning("Pixmap not found: %s", icon_file);
}
g_free(icon_file);
themes_init();
colors_init();
notebook = gtk_notebook_new();
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), build_map(),
/* Tab page name */
gtk_label_new(_("Map")));
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
build_settings(GTK_WINDOW(toplevel)),
/* Tab page name */
gtk_label_new(_("Settings")));
terrain_menu = build_terrain_menu();
roll_menu = build_roll_menu();
port_menu = build_port_menu();
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(toplevel), vbox);
menubar = gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 0);
if (filename == NULL) {
filename =
config_get_string("editor/last-game", &default_used);
if (default_used
|| !g_file_test(filename, G_FILE_TEST_EXISTS)) {
g_free(filename);
filename = NULL;
}
}
load_game(filename, FALSE);
g_free(filename);
if (params == NULL)
return 1;
gtk_widget_show_all(toplevel);
gtk_accel_map_load(g_getenv("ACCEL_MAP"));
gtk_widget_hide (menubar);
gtk_osxapplication_set_menu_bar(theApp, GTK_MENU_SHELL(menubar));
gtk_osxapplication_ready(theApp);
gtk_main();
config_finish();
guimap_delete(gmap);
g_free(default_game);
g_option_context_free(context);
return 0;
}
int main(int argc, char **argv)
{
gboolean listen = FALSE;
int n;
const char *profile = NULL;
const char *colour_scheme = NULL;
char *logo_filename;
gboolean persist = FALSE;
gboolean open_configlet = FALSE;
gboolean dbus_ok;
GdkScreen *scrn;
char *disp_name;
g_set_application_name(_("roxterm-config"));
global_options_init_appdir(argc, argv);
#if ENABLE_NLS
setlocale(LC_ALL, "");
bindtextdomain(PACKAGE, global_options_appdir ?
g_strdup_printf("%s/locale", global_options_appdir) : LOCALEDIR);
textdomain(PACKAGE);
#endif
gtk_init(&argc, &argv);
scrn = gdk_screen_get_default();
disp_name = gdk_screen_make_display_name(scrn);
logo_filename = logo_find();
gtk_window_set_default_icon_from_file(logo_filename, NULL);
g_free(logo_filename);
for (n = 1; n < argc; ++n)
{
if (!strcmp(argv[n], "--listen"))
listen = TRUE;
else if (!strncmp(argv[n], "--EditProfile=", 14))
profile = argv[n] + 14;
else if (!strncmp(argv[n], "--EditColourScheme=", 19))
colour_scheme = argv[n] + 19;
else if (!strcmp(argv[n], "--Configlet"))
open_configlet = TRUE;
}
if (!open_configlet)
open_configlet = !profile && !colour_scheme && !listen;
dbus_ok = rtdbus_init();
if (dbus_ok && optsdbus_init())
{
/* Defer to another instance */
if (profile)
{
if (optsdbus_send_edit_profile_message(profile, disp_name))
profile = NULL;
}
if (colour_scheme)
{
if (optsdbus_send_edit_colour_scheme_message(colour_scheme,
disp_name))
{
colour_scheme = NULL;
}
}
if (open_configlet)
{
if (optsdbus_send_edit_opts_message("Configlet", "", disp_name))
{
open_configlet = FALSE;
}
}
}
if (profile)
{
profilegui_open(profile, scrn);
persist = TRUE;
}
if (colour_scheme)
{
colourgui_open(colour_scheme, scrn);
persist = TRUE;
}
if (open_configlet)
{
if (configlet_open(scrn))
persist = TRUE;
}
if (dbus_ok && listen)
persist = TRUE;
g_free(disp_name);
if (persist)
gtk_main();
return 0;
}
/**
* @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;
}
int main (int argc, char *argv[])
{
#ifndef WIN32
// Do not run as root.
if (getuid () == 0) {
cout << "Bibledit-Xiphos has not been designed to run with root privileges." << endl;
return 1;
}
#endif
// The necessary g* initializers, in the proper order.
g_thread_init(NULL);
g_type_init ();
gtk_init (&argc, &argv);
gchar * iconfile = g_build_filename (PACKAGE_DATA_DIR, "bibledit-xiphos.xpm", NULL);
gtk_window_set_default_icon_from_file(iconfile, NULL);
g_free (iconfile);
// Initialize variables.
event_id_rescan_bus = 0;
last_message_id = "0";
quit = false;
// Read settings.
GKeyFile *keyfile = g_key_file_new();
gchar * key_file_name = registry_file_name ();
g_key_file_load_from_file(keyfile, key_file_name, G_KEY_FILE_NONE, NULL);
g_free (key_file_name);
GtkBuilder *gtkbuilder;
gtkbuilder = gtk_builder_new ();
gchar * filename = g_build_filename (PACKAGE_DATA_DIR, "gtkbuilder.xml", NULL);
gtk_builder_add_from_file (gtkbuilder, filename, NULL);
g_free (filename);
window = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "window"));
g_signal_connect ((gpointer) window, "delete_event", G_CALLBACK (quit_program), NULL);
gtk_widget_show_all (window);
entry_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_url"));
gchar * url = g_key_file_get_string (keyfile, "settings", "bibledit-web-url", NULL);
if (!url) {
url = strdup ("http://localhost/bibledit");
}
gtk_entry_set_text (GTK_ENTRY (entry_url), url);
g_free (url);
g_signal_connect((gpointer) entry_url, "changed", G_CALLBACK(on_entry_url_changed), NULL);
button_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_url"));
g_signal_connect((gpointer) button_url, "clicked", G_CALLBACK(on_button_url_clicked), NULL);
label_url = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_url"));
entry_user = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "entry_user"));
gchar * user = g_key_file_get_string (keyfile, "settings", "bibledit-web-user", NULL);
if (!user) {
user = strdup ("");
}
gtk_entry_set_text (GTK_ENTRY (entry_user), user);
g_free (user);
g_signal_connect((gpointer) entry_user, "changed", G_CALLBACK(on_entry_user_changed), NULL);
label_xiphos_process = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_xiphos_process"));
label_id = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_id"));
label_command = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_command"));
label_body = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_body"));
label_xiphos = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "label_xiphos"));
button_hide = GTK_WIDGET (gtk_builder_get_object (gtkbuilder, "button_hide"));
g_signal_connect((gpointer) button_hide, "clicked", G_CALLBACK(on_button_hide_clicked), NULL);
g_key_file_free (keyfile);
// We use asynchronous transport, so that we can send several messages simultanously.
session = soup_session_async_new_with_options (SOUP_SESSION_USER_AGENT, "bibledit-xiphos/1.0", NULL);
start_xiphos_web_listener ();
// Obtain a connection to the Session Bus.
GError *error = NULL;
sigcon = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
if(sigcon) {
con = dbus_g_connection_get_connection(sigcon);
} else {
printf ("%s\n", error->message);
fflush (stdout);
g_error_free(error);
return 1;
}
// Request our name on the DBus.
if (con) {
DBusError *dbuserror = NULL;
int retval = dbus_bus_request_name(con, "org.bibledit.xiphos", 0, dbuserror);
if (retval != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
if (dbus_error_is_set(dbuserror)) {
printf ("%s\n", dbuserror->message);
fflush (stdout);
dbus_error_free(dbuserror);
}
}
}
// Connect to a couple of signals that indicate applications have started or have exited.
// Then a rescan of the bus can show whether the programs that we're interested in run.
proxy = NULL;
if (sigcon)
proxy = dbus_g_proxy_new_for_name(sigcon, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus");
if (proxy) {
dbus_g_proxy_add_signal(proxy, "NameAcquired", G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "NameAcquired", G_CALLBACK (on_name_acquired), NULL, NULL);
dbus_g_proxy_add_signal(proxy, "NameOwnerChanged", G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "NameOwnerChanged", G_CALLBACK (on_name_owner_changed), NULL, NULL);
dbus_g_proxy_add_signal(proxy, "NameLost", G_TYPE_STRING, G_TYPE_INVALID);
dbus_g_proxy_connect_signal(proxy, "NameLost", G_CALLBACK (on_name_lost), NULL, NULL);
}
// Signal trapping for doing a clean exit.
signal(SIGINT, sigproc);
signal(SIGQUIT, sigquit);
// Main loop.
gtk_main();
// Destroy any pending timeout.
destroy_source(event_id_rescan_bus);
// Abort the session including the listeners
soup_session_abort (session);
// The connection obtained through dbus_g_connection_get_connection does not have its reference count incremented.
// Therefore it should not be unreferenced.
// dbus_connection_unref(con);
// Destroy the proxy.
if (proxy) {
g_object_unref(proxy);
}
// Well done.
return 0;
}
