bool C4AbstractApp::Init(int argc, char * argv[])
{
// Set locale
setlocale(LC_ALL,"");
gtk_init(&argc, &argv);
GdkPixbuf* icon = gdk_pixbuf_new_from_resource("/org/openclonk/engine/oc.ico", NULL);
gtk_window_set_default_icon(icon);
g_object_unref(icon);
// Try to figure out the location of the executable
Priv->argc=argc; Priv->argv=argv;
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
int xrandr_error_base;
if (!XRRQueryExtension(dpy, &Priv->xrandr_event, &xrandr_error_base)
|| !XRRQueryVersion(dpy, &Priv->xrandr_major_version, &Priv->xrandr_minor_version))
{
Priv->xrandr_major_version = -1;
Priv->xrandr_minor_version = 0;
}
if (Priv->xrandr_major_version >= 0)
{
XRRSelectInput(dpy, DefaultRootWindow(dpy), RRScreenChangeNotifyMask);
}
else
Log("The Xrandr extension is missing. Resolution switching will not work.");
#endif
// Custom initialization
return DoInit (argc, argv);
}
/**
* ppg_runtime_init:
* @argc: (inout): A pointer to the programs argc.
* @argv: (inout): A pointer to the programs argv.
*
* Initialize the runtime system for the profiler gui.
*
* Returns: %TRUE if successful; otherwise %FALSE and the program should exit.
* Side effects: Everything.
*/
gboolean
ppg_runtime_init (gint *argc,
gchar ***argv)
{
GOptionContext *context;
GError *error = NULL;
context = g_option_context_new(_("- " PRODUCT_NAME));
g_option_context_add_main_entries(context, option_entries, GETTEXT_PACKAGE);
g_option_context_add_group(context, gtk_get_option_group(TRUE));
g_option_context_add_group(context, ppg_prefs_get_option_group());
if (!g_option_context_parse(context, argc, argv, &error)) {
g_printerr("%s\n", error->message);
g_error_free(error);
return FALSE;
}
ppg_log_init(use_stdount, log_filename);
ppg_monitor_init();
ppg_paths_init();
ppg_prefs_init();
ppg_color_init();
gtk_window_set_default_icon(LOAD_INLINE_PIXBUF(perfkit_pixbuf));
gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(),
ppg_paths_get_icon_dir());
ppg_instruments_init();
ppg_actions_init();
return TRUE;
}
void gtk_open(void)
{
GdkPixbuf *icon;
int argc;
char *args[2];
char **argv;
argc = 1;
argv = args;
argv[0] = "";
argv[1] = NULL;
gtk_do_init(&argc, &argv);
icon = gdk_pixbuf_new_from_xpm_data((const char**)mtr_icon);
gtk_window_set_default_icon(icon);
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_set_application_name("My traceroute");
Window_fill(main_window);
g_signal_connect(GTK_OBJECT(main_window), "delete_event",
GTK_SIGNAL_FUNC(Window_destroy), NULL);
g_signal_connect(GTK_OBJECT(main_window), "destroy",
GTK_SIGNAL_FUNC(Window_destroy), NULL);
gtk_widget_show_all(main_window);
}
GtkWidget* main_window_new(void){
GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW(window),APP_NAME);
gtk_window_set_default_size (GTK_WINDOW(window),800,600);
if (g_file_test (APP_DIR"textedit.png",G_FILE_TEST_EXISTS))
{
GtkWidget *icon = gtk_image_new_from_file (APP_DIR"textedit.png");
gtk_window_set_icon(GTK_WINDOW(window),gtk_image_get_pixbuf(GTK_IMAGE(icon)));
gtk_window_set_default_icon(gtk_image_get_pixbuf(GTK_IMAGE(icon)));
}else if (g_file_test ("textedit.png",G_FILE_TEST_EXISTS)){
GtkWidget *icon = gtk_image_new_from_file ("textedit.png");
gtk_window_set_icon(GTK_WINDOW(window),gtk_image_get_pixbuf(GTK_IMAGE(icon)));
gtk_window_set_default_icon(gtk_image_get_pixbuf(GTK_IMAGE(icon)));
}
return window;
}
static void
setup_default_icon (void)
{
GdkPixbuf *pixbuf;
pixbuf = gdk_pixbuf_new_from_resource ("/gtk-logo-old.png", NULL);
/* We load a resource, so we can guarantee that loading it is successful */
g_assert (pixbuf);
gtk_window_set_default_icon (pixbuf);
g_object_unref (pixbuf);
}
void lshw_ui_init(void)
{
GError *error = NULL;
GtkBuilder *builder = NULL;
GdkPixbuf *icon = NULL;
gchar *uiname = NULL;
mainwindow = NULL;
builder = gtk_builder_new();
uiname = find_file(UIFILE, "ui");
if(!uiname)
{
g_critical( "Could not find UI file: %s", UIFILE );
return;
}
if(!gtk_builder_add_from_file(builder, uiname, &error))
{
g_critical( "Could not create UI: %s", error->message );
g_free( error );
g_object_unref( G_OBJECT( builder ) );
return;
}
g_free(uiname);
mainwindow = GTK_WIDGET( gtk_builder_get_object( builder, "mainwindow" ) );
about = GTK_WIDGET( gtk_builder_get_object( builder, "aboutlshw" ) );
list1 = GTK_WIDGET(gtk_builder_get_object( builder, "treeview1"));
list2 = GTK_WIDGET(gtk_builder_get_object( builder, "treeview2"));
list3 = GTK_WIDGET(gtk_builder_get_object( builder, "treeview3"));
description = GTK_WIDGET(gtk_builder_get_object( builder, "description"));
go_up_button = GTK_WIDGET(gtk_builder_get_object( builder, "upbutton"));
save_button = GTK_WIDGET(gtk_builder_get_object( builder, "savebutton"));
statusbar = GTK_WIDGET(gtk_builder_get_object( builder, "statusbar"));
gtk_builder_connect_signals( builder, mainwindow );
g_object_unref( G_OBJECT( builder ) );
icon = gtk_widget_render_icon(GTK_WIDGET(mainwindow),
"lshw-logo",
GTK_ICON_SIZE_DIALOG,
NULL);
if(GDK_IS_PIXBUF(icon))
{
gtk_window_set_icon(GTK_WINDOW(mainwindow), icon);
gtk_window_set_default_icon(icon);
}
}
static void load_icon(void)
{
GdkPixbuf *pix = NULL;
gchar *filename;
if(program_logo && !g_strcasecmp(program_logo,"none"))
return;
if(program_logo)
filename = g_strdup(program_logo);
else
filename = g_build_filename(program_data,PROGRAM_LOGO,NULL);
if(!g_file_test(filename,G_FILE_TEST_IS_REGULAR))
{
g_free(filename);
return;
}
pix = gdk_pixbuf_new_from_file(filename, NULL);
if(pix)
{
static const size[] = { 16, 32, 48, 64, 128, 256 };
GList *icon = NULL;
int f;
gtk_window_set_default_icon(pix);
g_object_set_data_full(G_OBJECT(topwindow),"logo",pix,g_object_unref);
#if defined( HAVE_IGEMAC )
gtk_osxapplication_set_dock_icon_pixbuf(osxapp,pix);
#endif
for(f=0;f<G_N_ELEMENTS(size);f++)
{
pix = gdk_pixbuf_new_from_file_at_size(filename,size[f],size[f],NULL);
if(pix)
icon = g_list_append(icon, pix);
}
gtk_window_set_default_icon_list(icon);
}
g_free(filename);
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1default_1icon
(
JNIEnv* env,
jclass cls,
jlong _icon
)
{
GdkPixbuf* icon;
// convert parameter icon
icon = (GdkPixbuf*) _icon;
// call function
gtk_window_set_default_icon(icon);
// cleanup parameter icon
}
void gtkbuild_init(int *argc, char ***argv)
{
#ifndef LINKED_GTK
gtkenabled = dynamicgtk_init();
if (gtkenabled < 0) {
gtkenabled = 0;
return;
}
#endif
gtkenabled = gtk_init_check(argc, argv);
if (!gtkenabled) return;
#ifdef RENDERTYPESDL
appicon = gdk_pixbuf_new_from_data((const guchar *)sdlappicon.pixels,
GDK_COLORSPACE_RGB, TRUE, 8, sdlappicon.width, sdlappicon.height,
sdlappicon.width*4, NULL, NULL);
#endif
if (appicon) gtk_window_set_default_icon(appicon);
}
void iceb_start(int argc,char **argv)
{
gchar *str=NULL;
struct passwd *ktor; /*Кто работает*/
int regim;
class iceb_u_str locale;
ktor=getpwuid(getuid());
setlocale(LC_ALL,"");/*Устанавливаются переменные локали из окружающей среды*/
locale.plus(setlocale(LC_MESSAGES,""));
if(iceb_u_polen(locale.ravno(),&kodirovka_iceb,2,'.') != 0)
{
if(iceb_u_SRAV(locale.ravno(),"ru",0) == 0)
kodirovka_iceb.new_plus("koi8r");
if(iceb_u_SRAV(locale.ravno(),"ru_UA",0) == 0)
kodirovka_iceb.new_plus("koi8u");
}
// настройка папок с переводами;
str = bindtextdomain( PACKAGE,PACKAGE_LOCALE_DIR );//установить каталог, содержащий переводы
// кодировка перевода;
str = bind_textdomain_codeset (PACKAGE,kodirovka_iceb.ravno());// Устанавливаем кодировку получаемых сообщений*/
str = textdomain(PACKAGE);// устанавливаем файл из которого будут браться строки для переводов
umask(0117); /*Установка маски для записи и чтения группы*/
gtk_set_locale();
gtk_init( &argc, &argv );
//Делаем обязятельно после gtk_ini
(void)setlocale(LC_NUMERIC,"C"); //Переменная среды определяющая чем разделяется целая и дробная часть числа
//printf("parol=%s imabaz=%s\n",parol,imabaz);
/*Определяем путь на файлы настройки*/
if((putnansi=getenv("PUTNANSI")) == NULL)
{
class iceb_u_str nastr_path;
if( G_DIR_SEPARATOR == '\\') /*Windous*/
{
nastr_path.plus("c:");
nastr_path.plus(G_DIR_SEPARATOR_S);
nastr_path.plus("iceB");
}
else /*Linux*/
{
nastr_path.plus(G_DIR_SEPARATOR_S);
nastr_path.plus("etc");
nastr_path.plus(G_DIR_SEPARATOR_S);
nastr_path.plus("iceB");
}
putnansi=new char[nastr_path.getdlinna()];
strcpy(putnansi,nastr_path.ravno());
}
GdkPixbuf *iconca=gdk_pixbuf_new_from_xpm_data(linuxbuh_icon_xpm);
gtk_window_set_default_icon(iconca);
/*Устанавливаем иконку для всех меню из корневого каталога настроечных файлов*/
/**********
int metka_icon=0;
if(gtk_window_set_default_icon_from_file(iceb_imafnsi("iceB_icon.png"),NULL) == TRUE)
metka_icon=1;
************/
/*Читаем ключи запуска программы*/
iceb_readkey(argc,argv,&parol,&imabaz,&host,®im);
//printf("imabaz=%s host=%s kto=%s parol=%s\n",imabaz,host,kto,parol);
if(sql_openbaz(&bd,imabaz,host,ktor->pw_name,parol) != 0)
iceb_eropbaz(imabaz,ktor->pw_uid,ktor->pw_name,0);
iceb_start_rf();/*читаем файл с командами и выполняем их*/
//printf("База открыта. %.2f\n",10.33);
SQLCURSOR cur;
SQL_str row;
/*Читаем наименование организации*/
char bros[512];
sprintf(bros,"select naikon from Kontragent where kodkon='00'");
if(sql_readkey(&bd,bros,&row,&cur) != 1)
{
iceb_vkk00(NULL);
/***************
iceb_u_str SP;
SP.plus(gettext("Не найден код контрагента 00 !"));
iceb_menu_soob(&SP,NULL);
int i=1+strlen(gettext("Не найден код контрагента 00 !"));
organ=new char[i];
strcpy(organ,gettext("Не найден код контрагента 00 !"));
****************/
}
else
{
int i=strlen(row[0])+1;
organ=new char[i];
strcpy(organ,row[0]);
}
/*Устанавливаем иконку для всех меню из каталога конкретной базы данных*/
//if(metka_icon == 0)
// gtk_window_set_default_icon_from_file(iceb_imafnsi("iceBw_icon.png"),NULL);
}
void
load_interface(cam* cam) {
gchar *title;
GdkPixbuf *logo = NULL;
GtkTreeView* treeview = GTK_TREE_VIEW(glade_xml_get_widget(cam->xml, "treeview_effects"));
GtkCellRenderer* cell;
menu_item_filter_type = g_quark_from_static_string("camorama-menu-item-filter-type");
/* set up the tree view */
cell = gtk_cell_renderer_text_new();
g_object_set(cell, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
gtk_cell_renderer_text_set_fixed_height_from_font(GTK_CELL_RENDERER_TEXT(cell), 1);
gtk_tree_view_insert_column_with_attributes(treeview, -1,
_("Effects"), cell,
"text", CAMORAMA_FILTER_CHAIN_COL_NAME,
NULL);
cam->filter_chain = camorama_filter_chain_new();
gtk_tree_view_set_model(treeview, GTK_TREE_MODEL(cam->filter_chain));
g_object_unref(cam->filter_chain);
g_signal_connect_swapped(treeview, "button-press-event",
G_CALLBACK(treeview_clicked_cb), cam);
g_signal_connect_swapped(treeview, "popup-menu",
G_CALLBACK(treeview_popup_menu_cb), cam);
logo = gtk_icon_theme_load_icon(gtk_icon_theme_get_for_screen(gtk_widget_get_screen(glade_xml_get_widget(cam->xml, "main_window"))), CAMORAMA_STOCK_WEBCAM, 24, 0, NULL);
gtk_window_set_default_icon(logo);
logo = (GdkPixbuf *) create_pixbuf (PACKAGE_DATA_DIR "/pixmaps/camorama.png");
if (logo == NULL) {
printf ("\n\nLOGO NO GO\n\n");
}
if (cam->show_adjustments == FALSE) {
gtk_widget_hide (glade_xml_get_widget
(cam->xml, "adjustments_table"));
gtk_window_resize (GTK_WINDOW
(glade_xml_get_widget
(cam->xml, "main_window")), 320, 240);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(glade_xml_get_widget(cam->xml, "showadjustment_item")), cam->show_adjustments);
if (cam->show_effects == FALSE) {
gtk_widget_hide (glade_xml_get_widget (cam->xml, "scrolledwindow_effects"));
gtk_window_resize (GTK_WINDOW
(glade_xml_get_widget
(cam->xml, "main_window")), 320, 240);
}
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(glade_xml_get_widget(cam->xml, "show_effects")), cam->show_effects);
cam->tray_icon = gtk_status_icon_new_from_stock (CAMORAMA_STOCK_WEBCAM);
update_tooltip (cam);
/* add the status to the plug */
g_object_set_data (G_OBJECT (cam->tray_icon), "available",
GINT_TO_POINTER (1));
g_object_set_data (G_OBJECT (cam->tray_icon), "embedded",
GINT_TO_POINTER (0));
g_signal_connect (cam->tray_icon, "popup-menu",
G_CALLBACK (tray_clicked_callback), cam);
/* connect the signals in the interface
* glade_xml_signal_autoconnect(xml);
* this won't work, can't pass data to callbacks. have to do it individually :(*/
title = g_strdup_printf ("Camorama - %s - %dx%d", cam->vid_cap.name,
cam->x, cam->y);
gtk_window_set_title (GTK_WINDOW
(glade_xml_get_widget (cam->xml, "main_window")),
title);
g_free (title);
gtk_window_set_icon (GTK_WINDOW
(glade_xml_get_widget (cam->xml, "main_window")),
logo);
gtk_window_set_icon (GTK_WINDOW
(glade_xml_get_widget (cam->xml, "prefswindow")),
logo);
glade_xml_signal_connect_data (cam->xml, "on_show_effects_activate",
G_CALLBACK (on_show_effects_activate),
cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"togglebutton1"),
cam->show_adjustments);
glade_xml_signal_connect_data (cam->xml,
"on_show_adjustments_activate",
G_CALLBACK
(on_show_adjustments_activate), cam);
glade_xml_signal_connect_data (cam->xml, "on_large_activate",
G_CALLBACK (on_change_size_activate), cam);
glade_xml_signal_connect_data (cam->xml, "on_medium_activate",
G_CALLBACK (on_change_size_activate), cam);
glade_xml_signal_connect_data (cam->xml, "on_small_activate",
G_CALLBACK (on_change_size_activate), cam);
//glade_xml_signal_connect_data(cam->xml, "capture_func", G_CALLBACK(on_change_size_activate), cam);
glade_xml_signal_connect_data (cam->xml, "capture_func",
G_CALLBACK (capture_func), cam);
glade_xml_signal_connect_data (cam->xml, "gtk_main_quit",
G_CALLBACK (delete_event), NULL);
/* sliders */
glade_xml_signal_connect_data (cam->xml, "contrast_change",
G_CALLBACK (contrast_change), cam);
gtk_range_set_value ((GtkRange *)
glade_xml_get_widget (cam->xml, "slider2"),
(int) (cam->contrast / 256));
glade_xml_signal_connect_data (cam->xml, "brightness_change",
G_CALLBACK (brightness_change), cam);
gtk_range_set_value ((GtkRange *)
glade_xml_get_widget (cam->xml, "slider3"),
(int) (cam->brightness / 256));
glade_xml_signal_connect_data (cam->xml, "colour_change",
G_CALLBACK (colour_change), cam);
gtk_range_set_value ((GtkRange *)
glade_xml_get_widget (cam->xml, "slider4"),
(int) (cam->colour / 256));
glade_xml_signal_connect_data (cam->xml, "hue_change",
G_CALLBACK (hue_change), cam);
gtk_range_set_value ((GtkRange *)
glade_xml_get_widget (cam->xml, "slider5"),
(int) (cam->hue / 256));
glade_xml_signal_connect_data (cam->xml, "wb_change",
G_CALLBACK (wb_change), cam);
gtk_range_set_value ((GtkRange *)
glade_xml_get_widget (cam->xml, "slider6"),
(int) (cam->wb / 256));
/* buttons */
glade_xml_signal_connect_data (cam->xml, "on_status_show",
G_CALLBACK (on_status_show),
(gpointer) cam);
glade_xml_signal_connect_data (cam->xml, "on_quit_activate",
G_CALLBACK (on_quit_activate),
(gpointer) cam);
glade_xml_signal_connect_data (cam->xml, "on_preferences1_activate",
G_CALLBACK (on_preferences1_activate),
(gpointer) cam);
glade_xml_signal_connect_data (cam->xml, "on_about_activate",
G_CALLBACK (on_about_activate),
(gpointer) cam);
/* prefs */
glade_xml_signal_connect_data (cam->xml, "prefs_func",
G_CALLBACK (prefs_func), cam);
/* general */
glade_xml_signal_connect_data (cam->xml, "cap_func",
G_CALLBACK (cap_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"captured_cb"),
cam->cap);
glade_xml_signal_connect_data (cam->xml, "rcap_func",
G_CALLBACK (rcap_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"rcapture"),
cam->rcap);
glade_xml_signal_connect_data (cam->xml, "acap_func",
G_CALLBACK (acap_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"acapture"),
cam->acap);
glade_xml_signal_connect_data (cam->xml, "interval_change",
G_CALLBACK (interval_change), cam);
gtk_spin_button_set_value ((GtkSpinButton *)
glade_xml_get_widget (cam->xml,
"interval_entry"),
(cam->timeout_interval / 60000));
/* local */
dentry = glade_xml_get_widget (cam->xml, "dentry");
entry2 = glade_xml_get_widget (cam->xml, "entry2");
gtk_entry_set_text (GTK_ENTRY
(gnome_file_entry_gtk_entry
(GNOME_FILE_ENTRY (dentry))), cam->pixdir);
gtk_entry_set_text (GTK_ENTRY (entry2), cam->capturefile);
glade_xml_signal_connect_data (cam->xml, "append_func",
G_CALLBACK (append_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"appendbutton"),
cam->timefn);
glade_xml_signal_connect_data (cam->xml, "jpg_func",
G_CALLBACK (jpg_func), cam);
if (cam->savetype == JPEG) {
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"jpgb"), TRUE);
}
glade_xml_signal_connect_data (cam->xml, "png_func",
G_CALLBACK (png_func), cam);
if (cam->savetype == PNG) {
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"pngb"), TRUE);
}
glade_xml_signal_connect_data (cam->xml, "ts_func",
G_CALLBACK (ts_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"tsbutton"),
cam->timestamp);
/* remote */
login_entry = glade_xml_get_widget (cam->xml, "login_entry");
host_entry = glade_xml_get_widget (cam->xml, "host_entry");
pw_entry = glade_xml_get_widget (cam->xml, "pw_entry");
directory_entry = glade_xml_get_widget (cam->xml, "directory_entry");
filename_entry = glade_xml_get_widget (cam->xml, "filename_entry");
gtk_entry_set_text (GTK_ENTRY (host_entry), cam->rhost);
gtk_entry_set_text (GTK_ENTRY (login_entry), cam->rlogin);
gtk_entry_set_text (GTK_ENTRY (pw_entry), cam->rpw);
gtk_entry_set_text (GTK_ENTRY (directory_entry), cam->rpixdir);
gtk_entry_set_text (GTK_ENTRY (filename_entry), cam->rcapturefile);
glade_xml_signal_connect_data (cam->xml, "rappend_func",
G_CALLBACK (rappend_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"timecb"),
cam->rtimefn);
glade_xml_signal_connect_data (cam->xml, "rjpg_func",
G_CALLBACK (rjpg_func), cam);
if (cam->rsavetype == JPEG) {
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"fjpgb"), TRUE);
}
glade_xml_signal_connect_data (cam->xml, "rpng_func",
G_CALLBACK (rpng_func), cam);
if (cam->rsavetype == PNG) {
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"fpngb"), TRUE);
}
glade_xml_signal_connect_data (cam->xml, "rts_func",
G_CALLBACK (rts_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml,
"tsbutton2"),
cam->rtimestamp);
/* timestamp */
glade_xml_signal_connect_data (cam->xml, "customstring_func",
G_CALLBACK (customstring_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml, "cscb"),
cam->usestring);
string_entry = glade_xml_get_widget (cam->xml, "string_entry");
gtk_entry_set_text (GTK_ENTRY (string_entry), cam->ts_string);
glade_xml_signal_connect_data (cam->xml, "drawdate_func",
G_CALLBACK (drawdate_func), cam);
gtk_toggle_button_set_active ((GtkToggleButton *)
glade_xml_get_widget (cam->xml, "tscb"),
cam->usedate);
cam->status = glade_xml_get_widget (cam->xml, "status");
set_sensitive (cam);
gtk_widget_set_sensitive (glade_xml_get_widget
(cam->xml, "string_entry"), cam->usestring);
gtk_widget_set_size_request (glade_xml_get_widget (cam->xml, "da"),
cam->x, cam->y);
prefswindow = glade_xml_get_widget (cam->xml, "prefswindow");
}
int
main(int argc, char *argv[], char *env[])
{
int i;
void configure();
FILE *pfp; /* current profile FP */
GdkPixbuf* icon;
ENTER;
//printf("sizeof(gulong)=%d\n", sizeof(gulong));
setlocale(LC_CTYPE, "");
gtk_set_locale();
gtk_init(&argc, &argv);
XSetLocaleModifiers("");
XSetErrorHandler((XErrorHandler) handle_error);
icon = gdk_pixbuf_new_from_file(IMGPREFIX "star.png", NULL);
if (icon) {
gtk_window_set_default_icon(icon);
g_object_unref(icon);
}
resolve_atoms();
for (i = 1; i < argc; i++) {
if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "--help")) {
usage();
exit(0);
} else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--version")) {
printf("fbpanel %s\n", version);
exit(0);
} else if (!strcmp(argv[i], "--log")) {
i++;
if (i == argc) {
ERR( "fbpanel: missing log level\n");
usage();
exit(1);
} else {
log_level = atoi(argv[i]);
}
} else if (!strcmp(argv[i], "--configure") || !strcmp(argv[i], "-C")) {
config = 1;
} else if (!strcmp(argv[i], "--profile") || !strcmp(argv[i], "-p")) {
i++;
if (i == argc) {
ERR( "fbpanel: missing profile name\n");
usage();
exit(1);
} else {
cprofile = g_strdup(argv[i]);
}
} else {
printf("fbpanel: unknown option - %s\n", argv[i]);
usage();
exit(1);
}
}
gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(),
IMGPREFIX);
signal(SIGUSR1, sig_usr);
do {
if (!(pfp = open_profile(cprofile)))
exit(1);
p = g_new0(panel, 1);
g_return_val_if_fail (p != NULL, 1);
if (!panel_start(p, pfp)) {
ERR( "fbpanel: can't start panel\n");
exit(1);
}
fclose(pfp);
if (config)
configure();
gtk_main();
panel_stop(p);
g_free(p);
} while (force_quit == 0);
exit(0);
}
int main( int argc, char *argv[] )
{
VikWindow *first_window;
GdkPixbuf *main_icon;
gboolean dashdash_already = FALSE;
int i = 0;
GError *error = NULL;
gboolean gui_initialized;
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#if ! GLIB_CHECK_VERSION (2, 32, 0)
g_thread_init ( NULL );
#endif
gdk_threads_init ();
gui_initialized = gtk_init_with_args (&argc, &argv, "files+", entries, NULL, &error);
if (!gui_initialized)
{
/* check if we have an error message */
if (error == NULL)
{
/* no error message, the GUI initialization failed */
const gchar *display_name = gdk_get_display_arg_name ();
(void)g_fprintf (stderr, "Failed to open display: %s\n", (display_name != NULL) ? display_name : " ");
}
else
{
/* yep, there's an error, so print it */
(void)g_fprintf (stderr, "Parsing command line options failed: %s\n", error->message);
g_error_free (error);
(void)g_fprintf (stderr, "Run \"%s --help\" to see the list of recognized options.\n",argv[0]);
}
return EXIT_FAILURE;
}
if (vik_version)
{
(void)g_printf ("%s %s\nCopyright (c) 2003-2008 Evan Battaglia\nCopyright (c) 2008-"THEYEAR" Viking's contributors\n", PACKAGE_NAME, PACKAGE_VERSION);
return EXIT_SUCCESS;
}
#if GLIB_CHECK_VERSION (2, 32, 0)
if (vik_debug)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, log_debug, NULL);
#else
if (!vik_debug)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, mute_log, NULL);
#endif
#if HAVE_X11_XLIB_H
XSetErrorHandler(myXErrorHandler);
#endif
// Discover if this is the very first run
a_vik_very_first_run ();
a_settings_init ();
a_preferences_init ();
/*
* First stage initialization
*
* Should not use a_preferences_get() yet
*
* Since the first time a_preferences_get() is called it loads any preferences values from disk,
* but of course for preferences not registered yet it can't actually understand them
* so subsequent initial attempts to get those preferences return the default value, until the values have changed
*/
a_vik_preferences_init ();
a_layer_defaults_init ();
a_download_init();
curl_download_init();
a_babel_init ();
/* Init modules/plugins */
modules_init();
vik_georef_layer_init ();
maps_layer_init ();
a_mapcache_init ();
a_background_init ();
a_toolbar_init();
vik_routing_prefs_init();
/*
* Second stage initialization
*
* Can now use a_preferences_get()
*/
a_background_post_init ();
a_babel_post_init ();
modules_post_init ();
// May need to initialize the Positonal TimeZone lookup
if ( a_vik_get_time_ref_frame() == VIK_TIME_REF_WORLD )
vu_setup_lat_lon_tz_lookup();
/* Set the icon */
main_icon = gdk_pixbuf_from_pixdata(&viking_pixbuf, FALSE, NULL);
gtk_window_set_default_icon(main_icon);
gdk_threads_enter ();
// Ask for confirmation of default settings on first run
vu_set_auto_features_on_first_run ();
/* Create the first window */
first_window = vik_window_new_window();
vu_check_latest_version ( GTK_WINDOW(first_window) );
// Load startup file first so that subsequent files are loaded on top
// Especially so that new tracks+waypoints will be above any maps in a startup file
if ( a_vik_get_startup_method () == VIK_STARTUP_METHOD_SPECIFIED_FILE ) {
gboolean load_startup_file = TRUE;
// When a viking file is to be loaded via the command line
// then we'll skip loading any startup file
int jj = 0;
while ( ++jj < argc ) {
if ( check_file_magic_vik(argv[jj]) )
load_startup_file = FALSE;
}
if ( load_startup_file )
vik_window_open_file ( first_window, a_vik_get_startup_file(), TRUE );
}
while ( ++i < argc ) {
if ( strcmp(argv[i],"--") == 0 && !dashdash_already )
dashdash_already = TRUE; /* hack to open '-' */
else {
VikWindow *newvw = first_window;
gboolean change_filename = (i == 1);
// Open any subsequent .vik files in their own window
if ( i > 1 && check_file_magic_vik ( argv[i] ) ) {
newvw = vik_window_new_window ();
change_filename = TRUE;
}
vik_window_open_file ( newvw, argv[i], change_filename );
}
}
vik_window_new_window_finish ( first_window );
vu_command_line ( first_window, latitude, longitude, zoom_level_osm, map_id );
gtk_main ();
gdk_threads_leave ();
a_babel_uninit ();
a_toolbar_uninit ();
a_background_uninit ();
a_mapcache_uninit ();
a_dems_uninit ();
a_layer_defaults_uninit ();
a_preferences_uninit ();
a_settings_uninit ();
modules_uninit();
curl_download_uninit();
vu_finalize_lat_lon_tz_lookup ();
// Clean up any temporary files
util_remove_all_in_deletion_list ();
return 0;
}
/* Main entry point */
int main(int argc, char** argv) {
GtkWidget *window;
GtkAccelGroup *group;
struct eid_vwr_ui_callbacks* cb;
pthread_t thread;
GdkPixbuf *logo;
GError* err = NULL;
/* The GNU implementation of setlocale() ignores whatever we
* specify if the LANGUAGE environment variable has a value, so
* ensure that it doesn't
*/
putenv("LANGUAGE=");
bindtextdomain("eid-viewer", DATAROOTDIR "/locale");
textdomain("eid-viewer");
eid_vwr_convert_set_lang(langfromenv());
gtk_init(&argc, &argv);
builder = gtk_builder_new();
if(gtk_builder_add_from_string(builder, VIEWER_GLADE_STRING, strlen(VIEWER_GLADE_STRING), &err) == 0) {
g_critical("Could not parse Glade XML: %s", err->message);
exit(EXIT_FAILURE);
}
window = GTK_WIDGET(gtk_builder_get_object(builder, "mainwin"));
group = gtk_accel_group_new();
gtk_window_add_accel_group(GTK_WINDOW(window), group);
touched_labels = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
bindata_init();
connect_signals(window);
setup_treeview();
certs_init();
cb = eid_vwr_cbstruct();
cb->newsrc = newsrc;
cb->newstringdata = newstringdata;
cb->newbindata = newbindata;
cb->logv = ui_log_init();
cb->newstate = newstate;
cb->pinop_result = pinop_result;
cb->readers_changed = readers_changed;
eid_vwr_createcallbacks(cb);
pthread_create(&thread, NULL, threadmain, NULL);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
logo = gdk_pixbuf_from_pixdata(&logo_128, FALSE, NULL);
G_GNUC_END_IGNORE_DEPRECATIONS
gtk_window_set_default_icon(logo);
gtk_widget_show(window);
if(argc > 1) {
eid_vwr_be_deserialize(argv[1]);
}
gtk_main();
return 0;
}
void
create_main_window (const char *tag, int instance_count)
{
GtkWidget *vbox1;
GtkWidget *menubar1;
GtkWidget *file1;
GtkWidget *file1_menu;
GtkWidget *menu_save;
GtkWidget *menu_patchlist;
GtkWidget *separator1;
GtkWidget *menu_quit;
GtkWidget *help1;
GtkWidget *help1_menu;
GtkWidget *menu_about;
GtkWidget *scrolledwindow1;
GtkWidget *viewport1;
GtkAccelGroup *accel_group;
GdkPixbuf *icon;
if ((icon = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(),
"ghostess", 32, 0, NULL)) != NULL) {
gtk_window_set_default_icon(icon);
g_object_unref(icon);
}
accel_group = gtk_accel_group_new ();
main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_object_set_data (GTK_OBJECT (main_window), "main_window", main_window);
gtk_window_set_title (GTK_WINDOW (main_window), tag);
/* gtk_widget_realize(main_window); // window must be realized for create_logo_pixmap() */
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_ref (vbox1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "vbox1", vbox1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (main_window), vbox1);
menubar1 = gtk_menu_bar_new ();
gtk_widget_ref (menubar1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menubar1", menubar1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menubar1);
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
file1 = gtk_menu_item_new_with_label ("File");
gtk_widget_ref (file1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "file1", file1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (file1);
gtk_container_add (GTK_CONTAINER (menubar1), file1);
file1_menu = gtk_menu_new ();
gtk_widget_ref (file1_menu);
gtk_object_set_data_full (GTK_OBJECT (main_window), "file1_menu", file1_menu,
(GtkDestroyNotify) gtk_widget_unref);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (file1), file1_menu);
menu_save = gtk_menu_item_new_with_label ("Save Configuration...");
gtk_widget_ref (menu_save);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_save", menu_save,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_save);
gtk_container_add (GTK_CONTAINER (file1_menu), menu_save);
gtk_widget_add_accelerator (menu_save, "activate", accel_group,
GDK_S, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
menu_patchlist = gtk_menu_item_new_with_label ("Patchlist Export for Freewheeling...");
gtk_widget_ref (menu_patchlist);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_patchlist", menu_patchlist,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_patchlist);
gtk_container_add (GTK_CONTAINER (file1_menu), menu_patchlist);
gtk_widget_add_accelerator (menu_patchlist, "activate", accel_group,
GDK_P, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
separator1 = gtk_menu_item_new ();
gtk_widget_ref (separator1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "separator1", separator1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (separator1);
gtk_container_add (GTK_CONTAINER (file1_menu), separator1);
gtk_widget_set_sensitive (separator1, FALSE);
menu_quit = gtk_menu_item_new_with_label ("Quit");
gtk_widget_ref (menu_quit);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_quit", menu_quit,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_quit);
gtk_container_add (GTK_CONTAINER (file1_menu), menu_quit);
gtk_widget_add_accelerator (menu_quit, "activate", accel_group,
GDK_Q, GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
help1 = gtk_menu_item_new_with_label ("About");
gtk_widget_ref (help1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "help1", help1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (help1);
gtk_container_add (GTK_CONTAINER (menubar1), help1);
gtk_menu_item_right_justify (GTK_MENU_ITEM (help1));
help1_menu = gtk_menu_new ();
gtk_widget_ref (help1_menu);
gtk_object_set_data_full (GTK_OBJECT (main_window), "help1_menu", help1_menu,
(GtkDestroyNotify) gtk_widget_unref);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (help1), help1_menu);
menu_about = gtk_menu_item_new_with_label ("About ghostess");
gtk_widget_ref (menu_about);
gtk_object_set_data_full (GTK_OBJECT (main_window), "menu_about", menu_about,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (menu_about);
gtk_container_add (GTK_CONTAINER (help1_menu), menu_about);
plugin_hbox = gtk_hbox_new (FALSE, 0);
gtk_widget_ref (plugin_hbox);
gtk_object_set_data_full (GTK_OBJECT (main_window), "plugin_hbox", plugin_hbox,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (plugin_hbox);
if (instance_count > 5) {
scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_ref (scrolledwindow1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "scrolledwindow1", scrolledwindow1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (scrolledwindow1);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_range_set_update_policy (GTK_RANGE (GTK_SCROLLED_WINDOW (scrolledwindow1)->vscrollbar), GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (vbox1), scrolledwindow1, TRUE, TRUE, 0);
gtk_widget_set_size_request(GTK_WIDGET(scrolledwindow1), 400, -1);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_widget_ref (viewport1);
gtk_object_set_data_full (GTK_OBJECT (main_window), "viewport1", viewport1,
(GtkDestroyNotify) gtk_widget_unref);
gtk_widget_show (viewport1);
gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);
gtk_container_add (GTK_CONTAINER (viewport1), plugin_hbox);
} else {
gtk_box_pack_start (GTK_BOX (vbox1), plugin_hbox, TRUE, TRUE, 0);
}
gtk_signal_connect(GTK_OBJECT(main_window), "destroy",
GTK_SIGNAL_FUNC(gtk_main_quit), NULL);
gtk_signal_connect (GTK_OBJECT (main_window), "delete_event",
(GtkSignalFunc)on_delete_event_wrapper,
(gpointer)on_menu_quit_activate);
gtk_signal_connect (GTK_OBJECT (menu_save), "activate",
GTK_SIGNAL_FUNC (on_menu_save_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (menu_patchlist), "activate",
GTK_SIGNAL_FUNC (on_menu_patchlist_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (menu_quit), "activate",
GTK_SIGNAL_FUNC (on_menu_quit_activate),
NULL);
gtk_signal_connect (GTK_OBJECT (menu_about), "activate",
GTK_SIGNAL_FUNC (on_menu_about_activate),
NULL);
gtk_window_add_accel_group (GTK_WINDOW (main_window), accel_group);
}
/**
* Initialize GTK interface.
*/
static nserror nsgtk_init(int argc, char** argv, char **respath)
{
char buf[PATH_MAX];
char *resource_filename;
char *addr = NULL;
nsurl *url;
nserror error;
error = nsgtk_builder_new_from_resname("warning", &warning_builder);
if (error != NSERROR_OK) {
LOG("Unable to initialise warning dialog");
return error;
}
gtk_builder_connect_signals(warning_builder, NULL);
/* set default icon if its available */
error = nsgdk_pixbuf_new_from_resname("netsurf.xpm",
&win_default_icon_pixbuf);
if (error == NSERROR_OK) {
LOG("Seting default window icon");
gtk_window_set_default_icon(win_default_icon_pixbuf);
}
/* Search engine sources */
resource_filename = filepath_find(respath, "SearchEngines");
search_web_init(resource_filename);
if (resource_filename != NULL) {
LOG("Using '%s' as Search Engines file", resource_filename);
free(resource_filename);
}
/* Default favicon */
error = nsgdk_pixbuf_new_from_resname("favicon.png", &favicon_pixbuf);
if (error != NSERROR_OK) {
favicon_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
false, 8, 16, 16);
}
/* arrow down icon */
error = nsgdk_pixbuf_new_from_resname("arrow_down_8x32.png",
&arrow_down_pixbuf);
if (error != NSERROR_OK) {
arrow_down_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
false, 8, 8, 32);
}
/* initialise throbber */
error = nsgtk_throbber_init();
if (error != NSERROR_OK) {
LOG("Unable to initialise throbber.");
return error;
}
/* Initialise completions - cannot fail */
nsgtk_completion_init();
filepath_sfinddef(respath, buf, "mime.types", "/etc/");
gtk_fetch_filetype_init(buf);
save_complete_init();
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.
*/
browser_set_dpi(gdk_screen_get_resolution(gdk_screen_get_default()));
LOG("Set CSS DPI to %d", browser_get_dpi());
/* Initialise top level UI elements */
error = nsgtk_download_init();
if (error != NSERROR_OK) {
LOG("Unable to initialise download window.");
return error;
}
/* If there is a url specified on the command line use it */
if (argc > 1) {
struct stat fs;
if (stat(argv[1], &fs) == 0) {
size_t addrlen;
char *rp = realpath(argv[1], NULL);
assert(rp != NULL);
/* calculate file url length including terminator */
addrlen = SLEN("file://") + strlen(rp) + 1;
addr = malloc(addrlen);
assert(addr != NULL);
snprintf(addr, addrlen, "file://%s", rp);
free(rp);
} else {
addr = strdup(argv[1]);
}
}
if (addr != NULL) {
/* managed to set up based on local launch */
} else if (nsoption_charp(homepage_url) != NULL) {
addr = strdup(nsoption_charp(homepage_url));
} else {
addr = strdup(NETSURF_HOMEPAGE);
}
/* create an initial browser window */
error = nsurl_create(addr, &url);
if (error == NSERROR_OK) {
error = browser_window_create(BW_CREATE_HISTORY,
url,
NULL,
NULL,
NULL);
nsurl_unref(url);
}
free(addr);
return error;
}
static void
saa_main_window_init (SaaMainWindow * w) {
GtkWidget * vbox_win;
// Barre de menu ----------------------------------------------------------
GtkWidget *menubar;
GtkWidget *image;
GtkWidget *mit_fichier;
GtkWidget *mit_fichier_menu;
GtkWidget *it_charger_xml;
GtkWidget *it_enregistrer_xml;
GtkWidget *mit_exporter;
GtkWidget *mit_exporter_menu;
GtkWidget *it_exporter;
GtkWidget *it_exporter_rb;
GtkWidget *it_sep_fichier;
GtkWidget *it_quitter;
GtkWidget *mit_aide;
GtkWidget *mit_aide_menu;
GtkWidget *it_a_propos;
GtkWidget *hbox_win;
GtkWidget *vbox_prop;
// Onglets ----------------------------------------------------------------
GtkWidget *notebook;
GtkWidget *label_page1;
GtkWidget *page1;
GtkWidget *f_uniform;
GtkWidget *lbl_uniform;
GtkWidget *f_traitement;
GtkWidget *lbl_traitement;
GtkWidget *label_page2;
GtkWidget *page2;
GtkWidget *sw;
GtkWidget *label_page3;
GtkWidget *page3;
// Barre d'état -----------------------------------------------------------
GtkWidget *hbox_status;
GtkWidget *statusbar;
GtkWidget *progressbar;
GtkAccelGroup *accel_group;
int i;
const gchar* const * dirs = g_get_system_data_dirs();
gchar * path;
// TODO init_files();
saa_init_files();
g_set_application_name (PACKAGE_NAME);
w->icon = NULL;
for(i=0; dirs[i] && !w->icon; i++) {
path = g_build_filename(dirs[i], "images", "gsolaar-logo.png", NULL);
if(g_file_test(path, G_FILE_TEST_EXISTS)) {
w->icon = gdk_pixbuf_new_from_file(path, NULL);
gtk_window_set_default_icon (w->icon);
}
g_free(path);
}
w->visuel = saa_visuel_creer();
accel_group = gtk_accel_group_new ();
gtk_window_set_title (GTK_WINDOW (w), "GSolaar");
vbox_win = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_win);
gtk_container_add (GTK_CONTAINER (w), vbox_win);
menubar = gtk_menu_bar_new ();
gtk_widget_show (menubar);
gtk_box_pack_start (GTK_BOX (vbox_win), menubar, FALSE, FALSE, 0);
mit_fichier = gtk_menu_item_new_with_mnemonic(_("_File"));
gtk_widget_show (mit_fichier);
gtk_container_add (GTK_CONTAINER (menubar), mit_fichier);
mit_fichier_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mit_fichier), mit_fichier_menu);
// Chargement -------------------------------------------------------------
it_charger_xml = gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, accel_group);
gtk_widget_show (it_charger_xml);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_charger_xml);
// Sauvegarde -------------------------------------------------------------
it_enregistrer_xml = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, accel_group);
gtk_widget_show (it_enregistrer_xml);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_enregistrer_xml);
// Patron -----------------------------------------------------------------
mit_exporter = gtk_image_menu_item_new_with_mnemonic(_("_Export"));
gtk_widget_show(mit_exporter);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), mit_exporter);
image = gtk_image_new_from_stock (GTK_STOCK_CONVERT, GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mit_exporter), image);
mit_exporter_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mit_exporter), mit_exporter_menu);
it_exporter = gtk_image_menu_item_new_with_label (_("Pattern ..."));
gtk_widget_show (it_exporter);
gtk_container_add (GTK_CONTAINER (mit_exporter_menu), it_exporter);
it_exporter_rb = gtk_image_menu_item_new_with_label (_("Ruby script for SketchUp ..."));
gtk_widget_show (it_exporter_rb);
gtk_container_add (GTK_CONTAINER (mit_exporter_menu), it_exporter_rb);
//-------------------------------------------------------------------------
it_sep_fichier = gtk_menu_item_new ();
gtk_widget_show (it_sep_fichier);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_sep_fichier);
gtk_widget_set_sensitive (it_sep_fichier, FALSE);
it_quitter = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, accel_group);
gtk_widget_show (it_quitter);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_quitter);
mit_aide = gtk_menu_item_new_with_mnemonic ("_?");
gtk_widget_show (mit_aide);
gtk_container_add (GTK_CONTAINER (menubar), mit_aide);
mit_aide_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mit_aide), mit_aide_menu);
it_a_propos = gtk_image_menu_item_new_from_stock ( GTK_STOCK_ABOUT, accel_group);
gtk_widget_show (it_a_propos);
gtk_container_add (GTK_CONTAINER (mit_aide_menu), it_a_propos);
//-------------------------------------------------------------------------
hbox_win = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox_win);
gtk_box_pack_start (GTK_BOX (vbox_win), hbox_win, TRUE, TRUE, 0);
vbox_prop = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_prop);
gtk_box_pack_start (GTK_BOX (hbox_win), vbox_prop, TRUE, TRUE, 0);
gtk_widget_set_size_request (vbox_prop, 500, 400);
// Drawing Area
w->area = saa_drawing_area_new_with_visuel (w->visuel);
gtk_widget_show (w->area);
gtk_box_pack_start (GTK_BOX (vbox_prop), w->area, TRUE, TRUE, 0);
gtk_widget_set_size_request (w->area, 600, 400);
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX (hbox_win), notebook, FALSE, FALSE, 0);
label_page1 = gtk_label_new (_("Polyhedron"));
gtk_widget_show (label_page1);
page1 = gtk_vbox_new (FALSE, 5);
gtk_widget_show (page1);
gtk_container_set_border_width (GTK_CONTAINER (page1), 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page1, label_page1);
f_uniform = gtk_frame_new (NULL);
gtk_widget_show (f_uniform);
gtk_box_pack_start (GTK_BOX (page1), f_uniform, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (f_uniform), 5);
gtk_frame_set_label_align (GTK_FRAME (f_uniform), 0.5, 0.5);
lbl_uniform = gtk_label_new (_("Uniform polyhedra"));
gtk_widget_show (lbl_uniform);
gtk_frame_set_label_widget (GTK_FRAME (f_uniform), lbl_uniform);
gtk_label_set_justify (GTK_LABEL (lbl_uniform), GTK_JUSTIFY_LEFT);
// Solid manager
w->manager = saa_solid_manager_new_with_visuel(w->visuel);
gtk_widget_show(w->manager);
gtk_container_add (GTK_CONTAINER (f_uniform), w->manager);
f_traitement = gtk_frame_new (NULL);
gtk_widget_show (f_traitement);
gtk_box_pack_start (GTK_BOX (page1), f_traitement, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (f_traitement), 5);
gtk_frame_set_label_align (GTK_FRAME (f_traitement), 0.5, 0.5);
lbl_traitement = gtk_label_new (_("Treatment"));
gtk_widget_show (lbl_traitement);
gtk_frame_set_label_widget (GTK_FRAME (f_traitement), lbl_traitement);
gtk_label_set_justify (GTK_LABEL (lbl_traitement), GTK_JUSTIFY_LEFT);
// Solid Handler
w->handler = saa_solid_handler_new_with_visuel(w->visuel);
gtk_widget_show(w->handler);
gtk_container_add (GTK_CONTAINER (f_traitement), w->handler);
label_page2 = gtk_label_new (_("Navigation"));
gtk_widget_show (label_page2);
page2 = gtk_vbox_new (FALSE, 5);
gtk_widget_show (page2);
gtk_container_set_border_width (GTK_CONTAINER (page2), 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page2, label_page2);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show(sw);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (page2), sw, TRUE, TRUE, 0);
// Treeview navigator
w->explorer = saa_tree_view_new_with_visuel(w->visuel);
gtk_widget_show(w->explorer);
gtk_container_add (GTK_CONTAINER (sw), w->explorer);
// TODO a deplacer dans window realize
saa_tree_view_update(SAA_TREE_VIEW(w->explorer));
label_page3 = gtk_label_new (_("Display"));
gtk_widget_show (label_page3);
page3 = gtk_vbox_new (FALSE, 5);
gtk_widget_show (page3);
gtk_container_set_border_width (GTK_CONTAINER (page3), 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page3, label_page3);
// Solid display
w->display = saa_solid_display_new_with_visuel(w->visuel);
gtk_widget_show (w->display);
gtk_box_pack_start(GTK_BOX(page3), w->display, TRUE, TRUE, 0);
hbox_status = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox_status);
gtk_box_pack_start (GTK_BOX (vbox_win), hbox_status, FALSE, FALSE, 0);
statusbar = gtk_statusbar_new ();
gtk_widget_show (statusbar);
gtk_box_pack_start (GTK_BOX (hbox_status), statusbar, TRUE, TRUE, 0);
progressbar = gtk_progress_bar_new ();
gtk_widget_show (progressbar);
gtk_box_pack_start (GTK_BOX (hbox_status), progressbar, FALSE, FALSE, 0);
g_signal_connect_swapped ((gpointer)w->manager, "solid-changed",
G_CALLBACK (saa_tree_view_update),
w->explorer);
g_signal_connect_swapped ((gpointer)w->manager, "solid-changed",
G_CALLBACK (gtk_widget_queue_draw),
w->area);
g_signal_connect_swapped ((gpointer)w->display, "solid-changed",
G_CALLBACK (gtk_widget_queue_draw),
w->area);
g_signal_connect_swapped ((gpointer)w->handler, "solid-changed",
G_CALLBACK (saa_tree_view_update),
w->explorer);
g_signal_connect_swapped ((gpointer)w->handler, "solid-changed",
G_CALLBACK (gtk_widget_queue_draw),
w->area);
g_signal_connect_swapped ((gpointer)w->area, "vertex-selected",
G_CALLBACK (saa_tree_view_select_vertex),
w->explorer);
g_signal_connect_swapped ((gpointer)w->area, "edge-selected",
G_CALLBACK (saa_tree_view_select_edge),
w->explorer);
g_signal_connect_swapped ((gpointer)w->area, "wing-selected",
G_CALLBACK (saa_tree_view_select_wing),
w->explorer);
g_signal_connect_swapped ((gpointer)w->explorer, "vertex-selected",
G_CALLBACK (saa_drawing_area_select_vertex),
w->area);
g_signal_connect_swapped ((gpointer)w->explorer, "edge-selected",
G_CALLBACK (saa_drawing_area_select_edge),
w->area);
g_signal_connect_swapped ((gpointer)w->explorer, "wing-selected",
G_CALLBACK (saa_drawing_area_select_wing),
w->area);
g_signal_connect_swapped((gpointer)it_charger_xml, "activate",
G_CALLBACK (saa_main_window_charger_xml_clicked),
w);
g_signal_connect_swapped((gpointer)it_enregistrer_xml, "activate",
G_CALLBACK (saa_main_window_sauver_xml_activate),
w);
g_signal_connect_swapped((gpointer)it_exporter, "activate",
G_CALLBACK (saa_main_window_exporter_activate),
w);
g_signal_connect_swapped((gpointer)it_exporter_rb, "activate",
G_CALLBACK (saa_main_window_exporter_rb_activate),
w);
g_signal_connect_swapped ((gpointer)it_quitter, "activate",
G_CALLBACK (saa_main_window_quitter_activate),
w);
g_signal_connect (G_OBJECT(w), "destroy",
G_CALLBACK (saa_main_window_quitter_activate),
NULL);
g_signal_connect_swapped ((gpointer)it_a_propos, "activate",
G_CALLBACK (saa_main_window_a_propos_activate),
w);
gtk_window_add_accel_group (GTK_WINDOW (w), accel_group);
}
/* **************************************************************************************************************************** */
void change_logo_accueil ( GtkWidget * file_selector )
{
GdkPixbuf * pixbuf;
const gchar *selected_filename;
selected_filename = file_selection_get_filename ( GTK_FILE_CHOOSER ( file_selector ) );
if ( gsb_data_account_get_accounts_amount () )
{
/* on change le logo */
gchar * chemin_logo;
gtk_container_remove ( GTK_CONTAINER ( logo_button ), preview );
chemin_logo = g_strstrip ( g_strdup ( selected_filename ) );
if ( !strlen ( chemin_logo ) )
{
if ( logo_accueil && GTK_IS_WIDGET ( logo_accueil ) )
gtk_widget_hide ( logo_accueil );
preview = gtk_image_new_from_stock ( GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_BUTTON );
}
else
{
/* Update preview */
pixbuf = gdk_pixbuf_new_from_file ( chemin_logo, NULL );
if (!pixbuf)
{
if ( logo_accueil && GTK_IS_WIDGET ( logo_accueil ))
gtk_widget_hide ( logo_accueil );
preview = gtk_image_new_from_stock ( GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_BUTTON );
}
else
{
if ( g_strcmp0 ( g_path_get_dirname ( chemin_logo ), gsb_dirs_get_pixmaps_dir ( ) ) == 0 )
{
gchar *name_logo;
etat.is_pixmaps_dir = TRUE;
name_logo = g_path_get_basename ( chemin_logo );
if ( g_strcmp0 ( name_logo, "grisbi-logo.png" ) != 0 )
etat.name_logo = name_logo;
else
etat.name_logo = NULL;
}
else
{
etat.is_pixmaps_dir = FALSE;
if ( etat.name_logo && strlen ( etat.name_logo ) )
g_free ( etat.name_logo );
etat.name_logo = NULL;
}
gsb_select_icon_set_logo_pixbuf ( pixbuf );
preview = gtk_image_new_from_pixbuf (
gdk_pixbuf_scale_simple (
pixbuf, 48, 48, GDK_INTERP_BILINEAR ) );
/* Update homepage logo */
gtk_widget_destroy ( logo_accueil );
logo_accueil = gtk_image_new_from_pixbuf (
gsb_select_icon_get_logo_pixbuf ( ) );
gtk_box_pack_start ( GTK_BOX ( hbox_title ), logo_accueil, FALSE, FALSE, 0 );
gtk_widget_show ( logo_accueil );
/* modify the icon of grisbi (set in the panel of gnome or other) */
gtk_window_set_default_icon (
gsb_select_icon_get_logo_pixbuf ( ) );
}
g_free ( chemin_logo );
}
gtk_widget_show ( preview );
gtk_container_add ( GTK_CONTAINER ( logo_button ), preview );
/* Mark file as modified */
gsb_file_set_modified ( TRUE );
}
}
int main( int argc, char *argv[] )
{
VikWindow *first_window;
GdkPixbuf *main_icon;
gboolean dashdash_already = FALSE;
int i = 0;
GError *error = NULL;
gboolean gui_initialized;
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#if ! GLIB_CHECK_VERSION (2, 32, 0)
g_thread_init ( NULL );
#endif
gdk_threads_init ();
gui_initialized = gtk_init_with_args (&argc, &argv, "files+", entries, NULL, &error);
if (!gui_initialized)
{
/* check if we have an error message */
if (error == NULL)
{
/* no error message, the GUI initialization failed */
const gchar *display_name = gdk_get_display_arg_name ();
g_fprintf (stderr, "Failed to open display: %s\n", (display_name != NULL) ? display_name : " ");
}
else
{
/* yep, there's an error, so print it */
g_fprintf (stderr, "Parsing command line options failed: %s\n", error->message);
g_error_free (error);
g_fprintf (stderr, "Run \"%s --help\" to see the list of recognized options.\n",argv[0]);
}
return EXIT_FAILURE;
}
if (vik_version)
{
g_printf ("%s %s\nCopyright (c) 2003-2008 Evan Battaglia\nCopyright (c) 2008-2012 Viking's contributors\n", PACKAGE_NAME, PACKAGE_VERSION);
return EXIT_SUCCESS;
}
#if GLIB_CHECK_VERSION (2, 32, 0)
if (vik_debug)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, log_debug, NULL);
#else
if (!vik_debug)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, mute_log, NULL);
#endif
#if HAVE_X11_XLIB_H
XSetErrorHandler(myXErrorHandler);
#endif
// Discover if this is the very first run
a_vik_very_first_run ();
a_settings_init ();
a_preferences_init ();
a_vik_preferences_init ();
a_layer_defaults_init ();
a_download_init();
curl_download_init();
a_babel_init ();
/* Init modules/plugins */
modules_init();
maps_layer_init ();
a_mapcache_init ();
a_background_init ();
#ifdef VIK_CONFIG_GEOCACHES
a_datasource_gc_init();
#endif
vik_routing_prefs_init();
/* Set the icon */
main_icon = gdk_pixbuf_from_pixdata(&viking_pixbuf, FALSE, NULL);
gtk_window_set_default_icon(main_icon);
gdk_threads_enter ();
// Ask for confirmation of default settings on first run
set_auto_features_on_first_run ();
/* Create the first window */
first_window = vik_window_new_window();
check_latest_version ( GTK_WINDOW(first_window) );
while ( ++i < argc ) {
if ( strcmp(argv[i],"--") == 0 && !dashdash_already )
dashdash_already = TRUE; /* hack to open '-' */
else {
VikWindow *newvw = first_window;
gboolean change_filename = (i == 1);
// Open any subsequent .vik files in their own window
if ( i > 1 && check_file_magic_vik ( argv[i] ) ) {
newvw = vik_window_new_window ();
change_filename = TRUE;
}
vik_window_open_file ( newvw, argv[i], change_filename );
}
}
vik_window_new_window_finish ( first_window );
gtk_main ();
gdk_threads_leave ();
a_babel_uninit ();
a_background_uninit ();
a_mapcache_uninit ();
a_dems_uninit ();
a_layer_defaults_uninit ();
a_preferences_uninit ();
a_settings_uninit ();
curl_download_uninit();
return 0;
}
/*
* gtunet_init_gui
*
* Add the components that are not in the xml file.
*/
void
gtunet_init_gui ()
{
int i;
GtkListStore *liststore_adapter;
GtkListStore *liststore_limitation;
GtkTreeIter treeiter;
GtkCellRenderer *renderer;
renderer = gtk_cell_renderer_text_new();
/*
* 1. Init combobox_adapter
*/
/* Get number of ethercards using mytunet API */
ethcard_count = (int)get_ethcards(ethcards, sizeof(ethcards));
liststore_adapter = (GtkListStore *)gtk_builder_get_object
(builder, "liststore_adapter");
/* Add the ethercards to the combobox */
for (i = 0; i < ethcard_count; i++)
{
gtk_list_store_append(liststore_adapter, &treeiter);
gtk_list_store_set(liststore_adapter, &treeiter, 0, ethcards[i].desc, -1);
}
/* Render */
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_adapter),
renderer,
TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_adapter),
renderer,
"text",
0,
NULL);
/* Set the first adapter to be active, usually is lo */
if (ethcard_count != 0)
{
gtk_combo_box_set_active(combobox_adapter, 0);
}
/*
* 2. Init entry_username and entry_password
*/
gtk_entry_set_text(entry_username, user_config.szUsername);
if (save_password)
{
gtk_entry_set_text(entry_password, user_config.szMD5Password);
}
/*
* 3. Init combobox_limitation
*/
liststore_limitation = (GtkListStore *)gtk_builder_get_object
(builder, "liststore_limitation");
gtk_list_store_append(liststore_limitation, &treeiter);
gtk_list_store_set(liststore_limitation, &treeiter, 0, "Campus", -1);
gtk_list_store_append(liststore_limitation, &treeiter);
gtk_list_store_set(liststore_limitation, &treeiter, 0, "Domestic", -1);
gtk_list_store_append(liststore_limitation, &treeiter);
gtk_list_store_set(liststore_limitation, &treeiter, 0, "None", -1);
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combobox_limitation),
renderer,
TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combobox_limitation),
renderer,
"text",
0,
NULL);
gtk_combo_box_set_active(combobox_limitation, 1);
/*
* 4. Init checkbutton_savepassword
*/
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_savepassword),
save_password);
/*
* 5. Init tray_icon and tray_menu
*/
tray_icon = gtunet_create_tray_icon();
tray_menu = gtunet_create_tray_menu();
/*
* 6. Init image_status
*/
gtunet_set_status_from_pixbuf(pixbuf_status_none);
/*
* 7. Init textview_info
*/
textmark_info = gtk_text_buffer_get_insert(textbuffer_info);
/*
* 8. Set window default icon
*/
gtk_window_set_default_icon(pixbuf_gtunet);
gtk_about_dialog_set_logo(about_dialog, pixbuf_gtunet);
}
int main( int argc, char *argv[] )
{
VikWindow *first_window;
GdkPixbuf *main_icon;
gboolean dashdash_already = FALSE;
int i = 0;
GError *error = NULL;
gboolean gui_initialized;
bindtextdomain (GETTEXT_PACKAGE, LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
g_thread_init ( NULL );
gdk_threads_init ();
gui_initialized = gtk_init_with_args (&argc, &argv, "files+", entries, NULL, &error);
if (!gui_initialized)
{
/* check if we have an error message */
if (error == NULL)
{
/* no error message, the GUI initialization failed */
const gchar *display_name = gdk_get_display_arg_name ();
g_fprintf (stderr, "Failed to open display: %s\n", (display_name != NULL) ? display_name : " ");
}
else
{
/* yep, there's an error, so print it */
g_fprintf (stderr, "Parsing command line options failed: %s\n", error->message);
g_error_free (error);
g_fprintf (stderr, "Run \"%s --help\" to see the list of recognized options.\n",argv[0]);
}
return EXIT_FAILURE;
}
if (vik_version)
{
g_printf ("%s %s, Copyright (c) 2003-2007 Evan Battaglia\n", PACKAGE_NAME, PACKAGE_VERSION);
return EXIT_SUCCESS;
}
if (!vik_debug)
g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, mute_log, NULL);
curl_download_init();
a_preferences_init ();
a_vik_preferences_init ();
/* Init modules/plugins */
modules_init();
a_mapcache_init ();
a_background_init ();
#ifdef VIK_CONFIG_GEOCACHES
a_datasource_gc_init();
#endif
/* Set the icon */
main_icon = gdk_pixbuf_from_pixdata(&viking_pixbuf, FALSE, NULL);
gtk_window_set_default_icon(main_icon);
/* Create the first window */
first_window = new_window();
gdk_threads_enter ();
while ( ++i < argc ) {
if ( strcmp(argv[i],"--") == 0 && !dashdash_already )
dashdash_already = TRUE; /* hack to open '-' */
else
vik_window_open_file ( first_window, argv[i], argc == 2 );
}
gtk_main ();
gdk_threads_leave ();
a_background_uninit ();
a_mapcache_uninit ();
a_dems_uninit ();
a_preferences_uninit ();
return 0;
}
int CUIHandler::CreateMainWnd()
{
GtkWidget* menubar;
GtkWidget* filemenu, *helpmenu;
GtkWidget* file, *quit;
GtkWidget* help, *about;
GtkWidget* vbox, *hbox;
GtkWidget* align;
GtkToolItem* toolitem;
GtkWidget* frame;
GtkWidget* status_menu;
GtkWidget* status_menu_item;
GtkWidget *hseparator;
GtkWidget *statusbarHBox;
GtkWidget *statusbarFrameConnection;
GtkWidget *statusbarAlignmentConnection;
GtkWidget *statusbarHBoxConnection;
GtkWidget *statusbarFrameFps;
GtkWidget *statusbarAlignmentFps;
GtkWidget *statusbarFrameResolution;
GtkWidget *statusbarAlignmentResolution;
// set up tray icon
trayIcon = gtk_status_icon_new_from_pixbuf(disconnectedTrayIcon);
gtk_status_icon_set_tooltip(trayIcon, TRAY_TOOLTIP_DISCONNECTED);
gtk_status_icon_set_visible(trayIcon, TRUE);
g_signal_connect(G_OBJECT(trayIcon), "popup-menu", G_CALLBACK(status_popup), NULL);
g_signal_connect(G_OBJECT(trayIcon), "activate", G_CALLBACK(status_activate), NULL);
// set up main mainWindow
mainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(mainWindow), "delete_event", G_CALLBACK(delete_event), NULL);
g_signal_connect(G_OBJECT(mainWindow), "destroy", G_CALLBACK(destroy), NULL);
g_signal_connect(G_OBJECT(mainWindow), "window_state_event", G_CALLBACK(track_minimize), NULL);
gtk_window_set_title(GTK_WINDOW(mainWindow), SMARTCAM_WND_TITLE);
gtk_container_set_border_width(GTK_CONTAINER(mainWindow), 1);
gtk_window_set_resizable(GTK_WINDOW(mainWindow), FALSE);
gtk_widget_set_size_request(mainWindow, MAIN_WND_WIDTH, MAIN_WND_HEIGHT);
gtk_window_set_position(GTK_WINDOW(mainWindow), GTK_WIN_POS_NONE);
gtk_window_set_gravity(GTK_WINDOW (mainWindow), GDK_GRAVITY_CENTER);
gtk_window_set_default_icon(connectedTrayIcon);
GdkPixbuf* icon;
GList* icon_list = NULL;
icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/16x16/apps/smartcam.png", NULL);
icon_list = g_list_append(icon_list, icon);
icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/22x22/apps/smartcam.png", NULL);
icon_list = g_list_append(icon_list, icon);
icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/24x24/apps/smartcam.png", NULL);
icon_list = g_list_append(icon_list, icon);
icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/32x32/apps/smartcam.png", NULL);
icon_list = g_list_append(icon_list, icon);
icon = gdk_pixbuf_new_from_file(DATADIR "/icons/hicolor/48x48/apps/smartcam.png", NULL);
icon_list = g_list_append(icon_list, icon);
gtk_window_set_default_icon_list(icon_list);
g_list_foreach(icon_list, (GFunc)g_object_unref, NULL );
g_list_free(icon_list);
// create menubar
menubar = gtk_menu_bar_new();
filemenu = gtk_menu_new();
file = gtk_menu_item_new_with_mnemonic("_File");
miSettings = gtk_image_menu_item_new_with_label("Settings");
gtk_image_menu_item_set_image(
GTK_IMAGE_MENU_ITEM(miSettings),
gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU));
g_signal_connect(G_OBJECT(miSettings), "activate", G_CALLBACK(OnSettingsClicked), (gpointer) NULL);
quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);
g_signal_connect(G_OBJECT(quit), "activate", G_CALLBACK(destroy), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), filemenu);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), miSettings);
gtk_menu_shell_append(GTK_MENU_SHELL(filemenu), quit);
helpmenu = gtk_menu_new();
help = gtk_menu_item_new_with_mnemonic("_Help");
about = gtk_image_menu_item_new_from_stock(GTK_STOCK_ABOUT, NULL);
g_signal_connect(about, "activate", G_CALLBACK(show_about_dialog), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), helpmenu);
gtk_menu_shell_append(GTK_MENU_SHELL(helpmenu), about);
// create toolbar
toolbar = gtk_toolbar_new();
gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU);
g_object_set(G_OBJECT(toolbar), "can-focus", FALSE, NULL);
tbSettings = gtk_tool_button_new_from_stock(GTK_STOCK_PREFERENCES);
g_signal_connect(G_OBJECT(tbSettings), "clicked", G_CALLBACK(OnSettingsClicked), NULL);
g_object_set(G_OBJECT(tbSettings), "tooltip-text", "Settings", NULL);
g_object_set(G_OBJECT(tbSettings), "can-focus", FALSE, NULL);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbSettings, 0);
tbDisconnect = gtk_tool_button_new_from_stock(GTK_STOCK_DISCONNECT);
g_signal_connect(G_OBJECT(tbDisconnect), "clicked", G_CALLBACK(OnDisconnectClicked), NULL);
g_object_set(G_OBJECT(tbDisconnect), "tooltip-text", "Disconnect", NULL);
g_object_set(G_OBJECT(tbDisconnect), "can-focus", FALSE, NULL);
g_object_set(G_OBJECT(tbDisconnect), "sensitive", FALSE, NULL); // disable disconnect
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tbDisconnect, 1);
// create preview frame
vbox = gtk_vbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);
gtk_container_add(GTK_CONTAINER(mainWindow), vbox);
align = gtk_alignment_new(0.5, 0.5, 0, 0);
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
image = gtk_image_new_from_pixbuf(logoIcon);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), align, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(align), frame);
gtk_container_add(GTK_CONTAINER(frame), image);
// set up status bar
hseparator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), hseparator, FALSE, FALSE, 0);
statusbarHBox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), statusbarHBox, FALSE, FALSE, 0);
statusbarFrameConnection = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (statusbarHBox), statusbarFrameConnection, TRUE, TRUE, 0);
gtk_widget_set_size_request (statusbarFrameConnection, 55, 25);
gtk_frame_set_label_align (GTK_FRAME (statusbarFrameConnection), 0, 0);
gtk_frame_set_shadow_type (GTK_FRAME (statusbarFrameConnection), GTK_SHADOW_IN);
statusbarAlignmentConnection = gtk_alignment_new (0, 0.5, 1, 1);
gtk_container_add (GTK_CONTAINER (statusbarFrameConnection), statusbarAlignmentConnection);
gtk_alignment_set_padding (GTK_ALIGNMENT (statusbarAlignmentConnection), 0, 0, 3, 0);
statusbarHBoxConnection = gtk_hbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (statusbarAlignmentConnection), statusbarHBoxConnection);
if(pSmartEngine->GetSettings().connectionType == CONN_BLUETOOTH)
{
statusbarImageConnection = gtk_image_new_from_pixbuf(btStatusIcon);
}
else
{
statusbarImageConnection = gtk_image_new_from_pixbuf(inetStatusIcon);
}
gtk_box_pack_start (GTK_BOX (statusbarHBoxConnection), statusbarImageConnection, FALSE, FALSE, 0);
gtk_misc_set_alignment (GTK_MISC (statusbarImageConnection), 0, 0.5);
statusbarLabelConnection = gtk_label_new ("Disconnected");
gtk_box_pack_start (GTK_BOX (statusbarHBoxConnection), statusbarLabelConnection, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (statusbarLabelConnection), 0, 0.5);
statusbarFrameFps = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (statusbarHBox), statusbarFrameFps, TRUE, TRUE, 0);
gtk_widget_set_size_request (statusbarFrameFps, 17, 25);
gtk_frame_set_shadow_type (GTK_FRAME (statusbarFrameFps), GTK_SHADOW_IN);
statusbarAlignmentFps = gtk_alignment_new (0, 0.5, 1, 1);
gtk_container_add (GTK_CONTAINER (statusbarFrameFps), statusbarAlignmentFps);
gtk_alignment_set_padding (GTK_ALIGNMENT (statusbarAlignmentFps), 0, 0, 3, 0);
statusbarLabelFps = gtk_label_new (CUIHandler::STATUS_LABEL_FPS);
gtk_container_add (GTK_CONTAINER (statusbarAlignmentFps), statusbarLabelFps);
gtk_misc_set_alignment (GTK_MISC (statusbarLabelFps), 0, 0.5);
statusbarFrameResolution = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (statusbarHBox), statusbarFrameResolution, TRUE, TRUE, 0);
gtk_widget_set_size_request (statusbarFrameResolution, 92, 25);
gtk_frame_set_shadow_type (GTK_FRAME (statusbarFrameResolution), GTK_SHADOW_IN);
statusbarAlignmentResolution = gtk_alignment_new (0, 0.5, 1, 1);
gtk_container_add (GTK_CONTAINER (statusbarFrameResolution), statusbarAlignmentResolution);
gtk_alignment_set_padding (GTK_ALIGNMENT (statusbarAlignmentResolution), 0, 0, 3, 0);
statusbarLabelResolution = gtk_label_new (CUIHandler::STATUS_LABEL_RESOLUTION);
gtk_container_add (GTK_CONTAINER (statusbarAlignmentResolution), statusbarLabelResolution);
gtk_misc_set_alignment (GTK_MISC (statusbarLabelResolution), 0, 0.5);
gtk_widget_show_all(mainWindow);
return 0;
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *ltable1;
GtkWidget *btnplay;
GtkWidget *btnsetting;
GtkWidget *btnquit;
GtkWidget *listwindow;
GdkBitmap *splash_mask;
GdkPixmap *splash_image;
GtkWidget *x_splash_image;
GdkPixbuf *icon_image;
GtkWidget *listgames;
GtkTreeSelection *selection;
if(argv[1])
{
chdir(argv[1]);
printf("[LAUNCHER] Using Directory %s\n", argv[1]);
}
sprintf(engine_game, "data");
gtk_init(&argc, &argv);
launcher_settings_load();
GdkGeometry hints;
hints.min_width = 444;
hints.max_width = 444;
hints.min_height = 225;
hints.max_height = 1080;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "NGUNIX Launcher");
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_container_set_border_width(GTK_CONTAINER(window), 2);
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &hints, (GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
gtk_widget_realize(window);
icon_image = gdk_pixbuf_new_from_xpm_data((const char**)icon_xpm);
gtk_window_set_default_icon (icon_image);
ltable1 = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), ltable1);
splash_image = gdk_pixmap_create_from_xpm_d(window->window, &splash_mask, NULL, (gchar **)splash_xpm );
if(!access("./splash.xpm", R_OK))
x_splash_image = gtk_image_new_from_file("./splash.xpm");
else
x_splash_image = gtk_image_new_from_pixmap(splash_image, splash_mask);
gtk_fixed_put(GTK_FIXED(ltable1), x_splash_image, 0, 0);
btnplay = gtk_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
btnsetting = gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
btnquit = gtk_button_new_from_stock(GTK_STOCK_QUIT);
gtk_fixed_put(GTK_FIXED(ltable1), btnplay, 0, 118);
gtk_widget_set_size_request(btnplay, 146, 40);
gtk_fixed_put(GTK_FIXED(ltable1), btnsetting, 148, 118);
gtk_widget_set_size_request(btnsetting, 144, 40);
gtk_fixed_put(GTK_FIXED(ltable1), btnquit, 148+146, 118);
gtk_widget_set_size_request(btnquit, 144, 40);
listwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_fixed_put(GTK_FIXED(ltable1), listwindow, 0, 118+41);
listgames = gtk_tree_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (listwindow), listgames);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(listwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(listwindow, 440, 300);
launcher_init_list(listgames);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listgames));
gtk_widget_show_all(window);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(selection, "changed", G_CALLBACK(launcher_list_changed), listgames);
gtk_signal_connect (GTK_OBJECT (btnplay), "clicked", GTK_SIGNAL_FUNC (launcher_start),NULL);
gtk_signal_connect (GTK_OBJECT (btnsetting), "clicked", GTK_SIGNAL_FUNC (launcher_settings_window),NULL);
gtk_signal_connect (GTK_OBJECT (btnquit), "clicked", GTK_SIGNAL_FUNC (gtk_main_quit),NULL);
g_signal_connect(G_OBJECT(window), "configure-event", G_CALLBACK(resize_list), (gpointer)listwindow);
printf("[LAUNCHER] Scanning directories....\n");
launcher_cachefolders(listgames);
printf(".......... %d folder(s) found\n", iGameCnt);
gtk_main();
return 0;
}
