extern "C" void Sys_FPrintf_VA( int level, const char *text, va_list args ) {
char buf[BUFFER_SIZE];
buf[0] = 0;
vsnprintf( buf, BUFFER_SIZE, text, args );
buf[BUFFER_SIZE - 1] = 0;
const unsigned int length = strlen( buf );
if ( g_qeglobals.hLogFile ) {
#ifdef _WIN32
_write( g_qeglobals.hLogFile, buf, length );
_commit( g_qeglobals.hLogFile );
#endif
#if defined ( __linux__ ) || defined ( __APPLE__ )
write( g_qeglobals.hLogFile, buf, length );
#endif
}
if ( level != SYS_NOCON ) {
// TTimo: FIXME: killed the console to avoid GDI leak fuckup
if ( g_qeglobals_gui.d_edit != NULL ) {
GtkTextBuffer* buffer = gtk_text_view_get_buffer( GTK_TEXT_VIEW( g_qeglobals_gui.d_edit ) );
GtkTextIter iter;
gtk_text_buffer_get_end_iter( buffer, &iter );
static GtkTextMark* end = gtk_text_buffer_create_mark( buffer, "end", &iter, FALSE );
const GdkColor yellow = { 0, 0xb0ff, 0xb0ff, 0x0000 };
const GdkColor red = { 0, 0xffff, 0x0000, 0x0000 };
const GdkColor black = { 0, 0x0000, 0x0000, 0x0000 };
static GtkTextTag* error_tag = gtk_text_buffer_create_tag( buffer, "red_foreground", "foreground-gdk", &red, NULL );
static GtkTextTag* warning_tag = gtk_text_buffer_create_tag( buffer, "yellow_foreground", "foreground-gdk", &yellow, NULL );
static GtkTextTag* standard_tag = gtk_text_buffer_create_tag( buffer, "black_foreground", "foreground-gdk", &black, NULL );
GtkTextTag* tag;
switch ( level )
{
case SYS_WRN:
tag = warning_tag;
break;
case SYS_ERR:
tag = error_tag;
break;
case SYS_STD:
case SYS_VRB:
default:
tag = standard_tag;
break;
}
gtk_text_buffer_insert_with_tags( buffer, &iter, buf, length, tag, NULL );
gtk_text_view_scroll_mark_onscreen( GTK_TEXT_VIEW( g_qeglobals_gui.d_edit ), end );
// update console widget immediatly if we're doing something time-consuming
if ( !g_bScreenUpdates && GTK_WIDGET_REALIZED( g_qeglobals_gui.d_edit ) ) {
gtk_grab_add( g_qeglobals_gui.d_edit );
while ( gtk_events_pending() )
gtk_main_iteration();
gtk_grab_remove( g_qeglobals_gui.d_edit );
}
}
}
}
/**
* Attempts to initialize the graphical video display. Returns 0 on
* success, -1 on failure.
*/
int
InitVideo(FCEUGI *gi)
{
// XXX soules - const? is this necessary?
const SDL_VideoInfo *vinf;
int error, flags = 0;
int doublebuf, xstretch, ystretch, xres, yres, show_fps;
FCEUI_printf("Initializing video...");
// load the relevant configuration variables
g_config->getOption("SDL.Fullscreen", &s_fullscreen);
g_config->getOption("SDL.DoubleBuffering", &doublebuf);
#ifdef OPENGL
g_config->getOption("SDL.OpenGL", &s_useOpenGL);
#endif
g_config->getOption("SDL.SpecialFilter", &s_sponge);
g_config->getOption("SDL.XStretch", &xstretch);
g_config->getOption("SDL.YStretch", &ystretch);
g_config->getOption("SDL.LastXRes", &xres);
g_config->getOption("SDL.LastYRes", &yres);
g_config->getOption("SDL.ClipSides", &s_clipSides);
g_config->getOption("SDL.NoFrame", &noframe);
g_config->getOption("SDL.ShowFPS", &show_fps);
// check the starting, ending, and total scan lines
FCEUI_GetCurrentVidSystem(&s_srendline, &s_erendline);
s_tlines = s_erendline - s_srendline + 1;
// check if we should auto-set x/y resolution
// check for OpenGL and set the global flags
#if OPENGL
if(s_useOpenGL && !s_sponge) {
flags = SDL_OPENGL;
}
#endif
// initialize the SDL video subsystem if it is not already active
if(!SDL_WasInit(SDL_INIT_VIDEO)) {
error = SDL_InitSubSystem(SDL_INIT_VIDEO);
if(error) {
FCEUD_PrintError(SDL_GetError());
return -1;
}
}
s_inited = 1;
// shows the cursor within the display window
SDL_ShowCursor(1);
// determine if we can allocate the display on the video card
vinf = SDL_GetVideoInfo();
if(vinf->hw_available) {
flags |= SDL_HWSURFACE;
}
// get the monitor's current resolution if we do not already have it
if(s_nativeWidth < 0) {
s_nativeWidth = vinf->current_w;
}
if(s_nativeHeight < 0) {
s_nativeHeight = vinf->current_h;
}
// check to see if we are showing FPS
FCEUI_SetShowFPS(show_fps);
// check if we are rendering fullscreen
if(s_fullscreen) {
int no_cursor;
g_config->getOption("SDL.NoFullscreenCursor", &no_cursor);
flags |= SDL_FULLSCREEN;
SDL_ShowCursor(!no_cursor);
}
else {
SDL_ShowCursor(1);
}
if(noframe) {
flags |= SDL_NOFRAME;
}
// gives the SDL exclusive palette control... ensures the requested colors
flags |= SDL_HWPALETTE;
// enable double buffering if requested and we have hardware support
#ifdef OPENGL
if(s_useOpenGL) {
FCEU_printf("Initializing with OpenGL (Disable with '--opengl 0').\n");
if(doublebuf) {
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
}
} else
#endif
if(doublebuf && (flags & SDL_HWSURFACE)) {
flags |= SDL_DOUBLEBUF;
}
if(s_fullscreen) {
int desbpp, autoscale;
g_config->getOption("SDL.BitsPerPixel", &desbpp);
g_config->getOption("SDL.AutoScale", &autoscale);
if (autoscale)
{
double auto_xscale = GetXScale(xres);
double auto_yscale = GetYScale(yres);
double native_ratio = ((double)NWIDTH) / s_tlines;
double screen_ratio = ((double)xres) / yres;
int keep_ratio;
g_config->getOption("SDL.KeepRatio", &keep_ratio);
// Try to choose resolution
if (screen_ratio < native_ratio)
{
// The screen is narrower than the original. Maximizing width will not clip
auto_xscale = auto_yscale = GetXScale(xres);
if (keep_ratio)
auto_yscale = GetYScale(yres);
}
else
{
auto_yscale = auto_xscale = GetYScale(yres);
if (keep_ratio)
auto_xscale = GetXScale(xres);
}
s_exs = auto_xscale;
s_eys = auto_yscale;
}
else
{
g_config->getOption("SDL.XScale", &s_exs);
g_config->getOption("SDL.YScale", &s_eys);
}
g_config->getOption("SDL.SpecialFX", &s_eefx);
#ifdef OPENGL
if(!s_useOpenGL) {
s_exs = (int)s_exs;
s_eys = (int)s_eys;
} else {
desbpp = 0;
}
if((s_useOpenGL && !xstretch) || !s_useOpenGL)
#endif
if(xres < (NWIDTH * s_exs) || s_exs <= 0.01) {
FCEUD_PrintError("xscale out of bounds.");
KillVideo();
return -1;
}
#ifdef OPENGL
if((s_useOpenGL && !ystretch) || !s_useOpenGL)
#endif
if(yres < s_tlines * s_eys || s_eys <= 0.01) {
FCEUD_PrintError("yscale out of bounds.");
KillVideo();
return -1;
}
#ifdef OPENGL
s_screen = SDL_SetVideoMode(s_useOpenGL ? s_nativeWidth : xres,
s_useOpenGL ? s_nativeHeight : yres,
desbpp, flags);
#else
s_screen = SDL_SetVideoMode(xres, yres, desbpp, flags);
#endif
if(!s_screen) {
FCEUD_PrintError(SDL_GetError());
return -1;
}
} else {
int desbpp;
g_config->getOption("SDL.BitsPerPixel", &desbpp);
g_config->getOption("SDL.XScale", &s_exs);
g_config->getOption("SDL.YScale", &s_eys);
g_config->getOption("SDL.SpecialFX", &s_eefx);
// -Video Modes Tag-
if(s_sponge) {
if(s_sponge <= 3 && s_sponge >= 1)
{
s_exs = s_eys = 2;
} else if (s_sponge >=4 && s_sponge <= 5)
{
s_exs = s_eys = 3;
} else if (s_sponge >= 6 && s_sponge <= 8)
{
s_exs = s_eys = s_sponge - 4;
}
else if(s_sponge == 9)
{
s_exs = s_eys = 3;
}
else
{
s_exs = s_eys = 1;
}
if(s_sponge == 3) {
xres = 301 * s_exs;
}
s_eefx = 0;
if(s_sponge == 1 || s_sponge == 4) {
desbpp = 32;
}
}
int scrw = NWIDTH * s_exs;
if(s_sponge == 3) {
scrw = 301 * s_exs;
}
#ifdef OPENGL
if(!s_useOpenGL) {
s_exs = (int)s_exs;
s_eys = (int)s_eys;
}
if(s_exs <= 0.01) {
FCEUD_PrintError("xscale out of bounds.");
KillVideo();
return -1;
}
if(s_eys <= 0.01) {
FCEUD_PrintError("yscale out of bounds.");
KillVideo();
return -1;
}
if(s_sponge && s_useOpenGL) {
FCEUD_PrintError("scalers not compatible with openGL mode.");
KillVideo();
return -1;
}
#endif
#if defined(_GTK) && defined(SDL_VIDEO_DRIVER_X11) && defined(GDK_WINDOWING_X11)
if(noGui == 0)
{
while (gtk_events_pending())
gtk_main_iteration_do(FALSE);
char SDL_windowhack[128];
sprintf(SDL_windowhack, "SDL_WINDOWID=%u", (unsigned int)GDK_WINDOW_XID(gtk_widget_get_window(evbox)));
SDL_putenv(SDL_windowhack);
// init SDL video
if (SDL_WasInit(SDL_INIT_VIDEO))
SDL_QuitSubSystem(SDL_INIT_VIDEO);
if ( SDL_InitSubSystem(SDL_INIT_VIDEO) < 0 )
{
fprintf(stderr, "Couldn't init SDL video: %s\n", SDL_GetError());
gtk_main_quit();
}
}
#endif
s_screen = SDL_SetVideoMode(scrw, (int)(s_tlines * s_eys),
desbpp, flags);
if(!s_screen) {
FCEUD_PrintError(SDL_GetError());
return -1;
}
#ifdef _GTK
if(noGui == 0)
{
GtkRequisition req;
gtk_widget_size_request(GTK_WIDGET(MainWindow), &req);
gtk_window_resize(GTK_WINDOW(MainWindow), req.width, req.height);
}
#endif
}
s_curbpp = s_screen->format->BitsPerPixel;
if(!s_screen) {
FCEUD_PrintError(SDL_GetError());
KillVideo();
return -1;
}
#if 0
// XXX soules - this would be creating a surface on the video
// card, but was commented out for some reason...
s_BlitBuf = SDL_CreateRGBSurface(SDL_HWSURFACE, 256, 240,
s_screen->format->BitsPerPixel,
s_screen->format->Rmask,
s_screen->format->Gmask,
s_screen->format->Bmask, 0);
#endif
FCEU_printf(" Video Mode: %d x %d x %d bpp %s\n",
s_screen->w, s_screen->h, s_screen->format->BitsPerPixel,
s_fullscreen ? "full screen" : "");
if(s_curbpp != 8 && s_curbpp != 16 && s_curbpp != 24 && s_curbpp != 32) {
FCEU_printf(" Sorry, %dbpp modes are not supported by FCE Ultra. Supported bit depths are 8bpp, 16bpp, and 32bpp.\n", s_curbpp);
KillVideo();
return -1;
}
// if the game being run has a name, set it as the window name
if(gi)
{
if(gi->name) {
SDL_WM_SetCaption((const char *)gi->name, (const char *)gi->name);
} else {
SDL_WM_SetCaption(FCEU_NAME_AND_VERSION,"FCE Ultra");
}
}
// create the surface for displaying graphical messages
#ifdef LSB_FIRST
s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data,
32, 32, 24, 32 * 3,
0xFF, 0xFF00, 0xFF0000, 0x00);
#else
s_IconSurface = SDL_CreateRGBSurfaceFrom((void *)fceu_playicon.pixel_data,
32, 32, 24, 32 * 3,
0xFF0000, 0xFF00, 0xFF, 0x00);
#endif
SDL_WM_SetIcon(s_IconSurface,0);
s_paletterefresh = 1;
// XXX soules - can't SDL do this for us?
// if using more than 8bpp, initialize the conversion routines
if(s_curbpp > 8) {
InitBlitToHigh(s_curbpp >> 3,
s_screen->format->Rmask,
s_screen->format->Gmask,
s_screen->format->Bmask,
s_eefx, s_sponge, 0);
#ifdef OPENGL
if(s_useOpenGL)
{
int openGLip;
g_config->getOption("SDL.OpenGLip", &openGLip);
if(!InitOpenGL(NOFFSET, 256 - (s_clipSides ? 8 : 0),
s_srendline, s_erendline + 1,
s_exs, s_eys, s_eefx,
openGLip, xstretch, ystretch, s_screen))
{
FCEUD_PrintError("Error initializing OpenGL.");
KillVideo();
return -1;
}
}
#endif
}
/* Updates mserv data (rating only) of @track using filename @name to
look up mserv information.
Return TRUE if successfully updated (or disabled), FALSE if not */
gboolean update_mserv_data_from_file(gchar *name, Track *track) {
gboolean success = TRUE;
if (!name || !track)
return FALSE;
if (g_file_test(name, G_FILE_TEST_IS_DIR))
return FALSE;
if (!g_file_test(name, G_FILE_TEST_EXISTS)) {
gchar *buf = g_strdup_printf(_("Local filename not valid (%s)"), name);
display_mserv_problems(track, buf);
g_free(buf);
return FALSE;
}
if (prefs_get_int("mserv_use")) {
/* try getting the user's rating from the mserv db */
gchar *music_root = prefs_get_string("path_mserv_music_root");
gchar *trackinfo_root = prefs_get_string("path_mserv_trackinfo_root");
/* we expect music_root and trackinfo_root to be initialized */
if (!music_root)
music_root = g_strdup("");
if (!trackinfo_root)
trackinfo_root = g_strdup("");
success = FALSE;
/* printf("mroot %s troot %s fname %s\n", music_root, trackinfo_root, name); */
/* first, check if the file is in the mserv music directory */
if (*music_root == 0 || strstr(name, music_root)) {
gchar *infoname =
g_strdup_printf("%s%c%s.trk", trackinfo_root, G_DIR_SEPARATOR, &(name[strlen(music_root)]));
/* printf("trying %s\n", infoname); */
FILE *fp = fopen(infoname, "r");
if (fp) {
/* printf("opened\n");*/
gchar buff[PATH_MAX];
gchar *username = prefs_get_string("mserv_username");
guint usernamelen;
g_return_val_if_fail (username, (fclose (fp), FALSE));
usernamelen = strlen(username);
while (fgets(buff, PATH_MAX, fp)) {
/* printf("username %s (%d) read %s\n",
* prefs_get_string("mserv_username"), usernamelen,
* buff);*/
if (strncmp(buff, username, usernamelen) == 0 && buff[usernamelen] == (gchar) '=') {
/* found it */
track->rating = atoi(&buff[usernamelen + 1]) * ITDB_RATING_STEP;
/* printf("found it, = %d\n",
orig_track->rating/ITDB_RATING_STEP); */
success = TRUE;
break; /* while(fgets(... */
}
}
fclose(fp);
g_free(username);
if (!success) {
gchar *username = prefs_get_string("mserv_username");
gchar *buf = g_strdup_printf(_("No information found for user '%s' in '%s'"), username, infoname);
display_mserv_problems(track, buf);
g_free(buf);
g_free(username);
}
}
else {
gchar *buf = g_strdup_printf(_("mserv data file (%s) not available for track (%s)"), infoname, name);
display_mserv_problems(track, buf);
g_free(buf);
}
g_free(infoname);
}
else {
gchar *buf = g_strdup_printf(_("Track (%s) not in mserv music root directory (%s)"), name, music_root);
display_mserv_problems(track, buf);
g_free(buf);
}
g_free(music_root);
g_free(trackinfo_root);
}
while (widgets_blocked && gtk_events_pending())
gtk_main_iteration();
return success;
}
void
open_grf_file (const char *fname)
{
char *title, *tmp;
GrfError err;
Grf *newgrf;
GList *list, *cols;
if (!g_file_test (fname, G_FILE_TEST_EXISTS)) {
show_error (_("File %s does not exist."), fname);
return;
}
mainWin.busy (true);
mainWin.status (_("Loading..."));
while (gtk_events_pending ()) gtk_main_iteration ();
newgrf = grf_open (fname, "r", &err);
if (!newgrf) {
char *base;
base = g_path_get_basename (fname);
mainWin.status ("");
gdk_window_set_cursor (W(main)->window, NULL);
show_error (_("Error while opening %s:\n%s"),
base, grf_strerror (err));
g_free (base);
return;
}
if (document.grf)
grf_free (document.grf);
document.grf = newgrf;
document.filename = fname;
title = g_strdup_printf (_("%s - GRF Tool"), fname);
gtk_window_set_title (GTK_WINDOW (W(main)), title);
g_free (title);
gtk_list_store_clear (GTK_LIST_STORE (filelist));
cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (W(filelist)));
for (list = cols; list; list = list->next) {
GtkTreeViewColumn *col = (GtkTreeViewColumn *) list->data;
gtk_tree_view_column_set_sort_indicator (col, FALSE);
}
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (filelist),
GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, GTK_SORT_ASCENDING);
g_list_free (cols);
fill_filelist ();
tmp = g_path_get_basename (fname);
title = g_strdup_printf (_("%s: %ld files"), tmp, (long int)document.grf->nfiles);
mainWin.status (title);
g_free (tmp);
g_free (title);
gtk_widget_set_sensitive (W(extract), TRUE);
mainWin.busy (false);
}
void
main_loop ()
{
#if HAVE_SDL
SDL_Event event[1];
#endif
#if HAVE_FREEGLUT
// Passing the GTK+ signals to the FreeGLUT main loop
glutIdleFunc ((void (*)) gtk_main_iteration);
// Setting our draw resize function as the FreeGLUT reshape function
glutReshapeFunc (draw_resize);
// Setting our draw function as the FreeGLUT display function
glutDisplayFunc (draw);
// FreeGLUT main loop
glutMainLoop ();
#else
#if HAVE_SDL
while (1)
{
while (gtk_events_pending ())
gtk_main_iteration ();
while (SDL_PollEvent (event))
{
if (event->type == SDL_QUIT)
return;
if (event->type == SDL_WINDOWEVENT
&& event->window.event == SDL_WINDOWEVENT_SIZE_CHANGED)
draw_resize (event->window.data1, event->window.data2);
}
#elif HAVE_GLFW
while (!glfwWindowShouldClose (window))
{
while (gtk_events_pending ())
gtk_main_iteration ();
glfwPollEvents ();
#endif
draw ();
}
#endif
}
/**
* \fn int main(int argn, char **argc)
* \brief Main function
* \param argn
* \brief Arguments number.
* \param argc
* \brief Array of arguments.
* \return 0 on success.
*/
int
main (int argn, char **argc)
{
GLenum glew_status;
// PARALELLIZING INIT
#ifdef G_OS_WIN32
SYSTEM_INFO sysinfo;
GetSystemInfo (&sysinfo);
nthreads = sysinfo.dwNumberOfProcessors;
#else
nthreads = (int) sysconf (_SC_NPROCESSORS_CONF);
#endif
// END
// Initing locales
#if DEBUG
printf ("Initing locales\n");
fflush (stdout);
#endif
bindtextdomain ("fractal", "./po");
bind_textdomain_codeset ("fractal", "UTF-8");
textdomain ("fractal");
// Initing graphic window
#if HAVE_FREEGLUT
#if DEBUG
printf ("Initing FreeGLUT window\n");
fflush (stdout);
#endif
glutInit (&argn, argc);
glutInitDisplayMode (GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowSize (window_width, window_height);
glutCreateWindow ("fractal");
#elif HAVE_SDL
#if DEBUG
printf ("Initing SDL window\n");
fflush (stdout);
#endif
SDL_Init (SDL_INIT_VIDEO);
window = SDL_CreateWindow ("fractal",
SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
window_width, window_height,
SDL_WINDOW_RESIZABLE | SDL_WINDOW_OPENGL);
if (!window)
{
printf ("ERROR! unable to create the window: %s\n", SDL_GetError ());
return 1;
}
SDL_GL_SetAttribute (SDL_GL_CONTEXT_MAJOR_VERSION, 2);
if (!SDL_GL_CreateContext (window))
{
printf ("ERROR! SDL_GL_CreateContext: %s\n", SDL_GetError ());
return 1;
}
#elif HAVE_GLFW
#if DEBUG
printf ("Initing GLFW window\n");
fflush (stdout);
#endif
if (!glfwInit ())
{
printf ("ERROR! unable to init GLFW\n");
return 1;
}
window
= glfwCreateWindow (window_width, window_height, "fractal", NULL, NULL);
if (!window)
{
printf ("ERROR! unable to open the window\n");
glfwTerminate ();
return 1;
}
glfwMakeContextCurrent (window);
#endif
// Initing GLEW
#if DEBUG
printf ("Initing GLEW\n");
fflush (stdout);
#endif
glew_status = glewInit ();
if (glew_status != GLEW_OK)
{
printf ("ERROR! glewInit: %s\n", glewGetErrorString (glew_status));
return 1;
}
// Initing FreeType
if (FT_Init_FreeType (&ft))
{
printf("ERROR! could not init freetype library\n");
return 1;
}
// Initing GTK+
#if DEBUG
printf ("Initing GTK+\n");
fflush (stdout);
#endif
gtk_init (&argn, &argc);
// Initing logo
#if DEBUG
printf ("Initing logo\n");
fflush (stdout);
#endif
logo_new ("logo.png");
// Initing drawing data
#if DEBUG
printf ("Initing drawing data\n");
fflush (stdout);
#endif
if (!draw_init ())
return 1;
// Creating the main GTK+ window
#if DEBUG
printf ("Creating simulator dialog\n");
fflush (stdout);
#endif
dialog_simulator_create (dialog_simulator);
#if DEBUG
printf ("Main loop\n");
fflush (stdout);
#endif
main_loop ();
// Freeing memory
#if HAVE_GLFW
glfwDestroyWindow (window);
glfwTerminate ();
#endif
return 0;
}
gint init(void* arg) {
gint x;
gint y;
DISCOVERED* d;
char *res;
char wisdom_directory[1024];
char wisdom_file[1024];
fprintf(stderr,"init\n");
audio_get_cards(0);
audio_get_cards(1);
cursor_arrow=gdk_cursor_new(GDK_ARROW);
cursor_watch=gdk_cursor_new(GDK_WATCH);
GdkWindow *gdk_splash_window = gtk_widget_get_window(splash_window);
gdk_window_set_cursor(gdk_splash_window,cursor_watch);
init_radio();
// check if wisdom file exists
res=getcwd(wisdom_directory, sizeof(wisdom_directory));
strcpy(&wisdom_directory[strlen(wisdom_directory)],"/");
strcpy(wisdom_file,wisdom_directory);
strcpy(&wisdom_file[strlen(wisdom_file)],"wdspWisdom");
splash_status("Checking FFTW Wisdom file ...");
if(access(wisdom_file,F_OK)<0) {
int rc=sem_init(&wisdom_sem, 0, 0);
rc=pthread_create(&wisdom_thread_id, NULL, wisdom_thread, (void *)wisdom_directory);
while(sem_trywait(&wisdom_sem)<0) {
splash_status(wisdom_get_status());
while (gtk_events_pending ())
gtk_main_iteration ();
usleep(100000); // 100ms
}
}
while(!start) {
gdk_window_set_cursor(gdk_splash_window,cursor_watch);
selected_device=0;
devices=0;
splash_status("Old Protocol ... Discovering Devices");
old_discovery();
splash_status("New Protocol ... Discovering Devices");
new_discovery();
#ifdef LIMESDR
splash_status("LimeSDR ... Discovering Devices");
lime_discovery();
#endif
splash_status("Discovery");
if(devices==0) {
gdk_window_set_cursor(gdk_splash_window,cursor_arrow);
fprintf(stderr,"No devices found!\n");
GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
discovery_dialog = gtk_message_dialog_new (GTK_WINDOW(splash_window),
flags,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK_CANCEL,
"No devices found! Retry Discovery?");
gtk_widget_override_font(discovery_dialog, pango_font_description_from_string("FreeMono 18"));
gint result=gtk_dialog_run (GTK_DIALOG (discovery_dialog));
gtk_widget_destroy(discovery_dialog);
if(result==GTK_RESPONSE_CANCEL) {
_exit(0);
}
} else {
fprintf(stderr,"%s: found %d devices.\n", (char *)arg, devices);
gdk_window_set_cursor(gdk_splash_window,cursor_arrow);
GtkDialogFlags flags=GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT;
discovery_dialog = gtk_dialog_new_with_buttons ("Discovered",
GTK_WINDOW(splash_window),
flags,
#ifdef GPIO
"Configure GPIO",
GTK_RESPONSE_YES,
#endif
"Discover",
GTK_RESPONSE_REJECT,
"Exit",
GTK_RESPONSE_CLOSE,
NULL);
gtk_widget_override_font(discovery_dialog, pango_font_description_from_string("FreeMono 18"));
GtkWidget *content;
content=gtk_dialog_get_content_area(GTK_DIALOG(discovery_dialog));
GtkWidget *grid=gtk_grid_new();
gtk_grid_set_row_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_column_homogeneous(GTK_GRID(grid),TRUE);
gtk_grid_set_row_spacing (GTK_GRID(grid),10);
int i;
char version[16];
char text[128];
for(i=0;i<devices;i++) {
d=&discovered[i];
fprintf(stderr,"%p protocol=%d name=%s\n",d,d->protocol,d->name);
if(d->protocol==ORIGINAL_PROTOCOL) {
sprintf(version,"%d.%d",
d->software_version/10,
d->software_version%10);
} else {
sprintf(version,"%d.%d.%d",
d->software_version/100,
(d->software_version%100)/10,
d->software_version%10);
}
switch(d->protocol) {
case ORIGINAL_PROTOCOL:
case NEW_PROTOCOL:
sprintf(text,"%s (%s %s) %s (%02X:%02X:%02X:%02X:%02X:%02X) on %s\n",
d->name,
d->protocol==ORIGINAL_PROTOCOL?"old":"new",
version,
inet_ntoa(d->info.network.address.sin_addr),
d->info.network.mac_address[0],
d->info.network.mac_address[1],
d->info.network.mac_address[2],
d->info.network.mac_address[3],
d->info.network.mac_address[4],
d->info.network.mac_address[5],
d->info.network.interface_name);
break;
#ifdef LIMESDR
case LIMESDR_PROTOCOL:
/*
sprintf(text,"%s (%s %s)\n",
d->name,
"lime",
version);
*/
sprintf(text,"%s\n",
d->name);
break;
#endif
}
GtkWidget *label=gtk_label_new(text);
gtk_widget_override_font(label, pango_font_description_from_string("FreeMono 12"));
gtk_widget_show(label);
gtk_grid_attach(GTK_GRID(grid),label,0,i,3,1);
GtkWidget *start_button=gtk_button_new_with_label("Start");
gtk_widget_override_font(start_button, pango_font_description_from_string("FreeMono 18"));
gtk_widget_show(start_button);
gtk_grid_attach(GTK_GRID(grid),start_button,3,i,1,1);
g_signal_connect(start_button,"pressed",G_CALLBACK(start_cb),(gpointer)d);
// if not available then cannot start it
if(d->status!=STATE_AVAILABLE) {
gtk_button_set_label(GTK_BUTTON(start_button),"In Use");
gtk_widget_set_sensitive(start_button, FALSE);
}
// if not on the same subnet then cannot start it
if((d->info.network.interface_address.sin_addr.s_addr&d->info.network.interface_netmask.sin_addr.s_addr) != (d->info.network.address.sin_addr.s_addr&d->info.network.interface_netmask.sin_addr.s_addr)) {
gtk_button_set_label(GTK_BUTTON(start_button),"Subnet!");
gtk_widget_set_sensitive(start_button, FALSE);
}
}
gtk_container_add (GTK_CONTAINER (content), grid);
gtk_widget_show_all(discovery_dialog);
gint result=gtk_dialog_run(GTK_DIALOG(discovery_dialog));
if(result==GTK_RESPONSE_CLOSE) {
_exit(0);
}
if(!start) {
gtk_widget_destroy(discovery_dialog);
}
#ifdef GPIO
if(result==GTK_RESPONSE_YES) {
configure_gpio(splash_window);
}
#endif
}
}
gdk_window_set_cursor(gdk_splash_window,cursor_watch);
splash_status("Initializing wdsp ...");
fprintf(stderr,"selected radio=%p device=%d\n",radio,radio->device);
protocol=radio->protocol;
device=radio->device;
switch(radio->protocol) {
case ORIGINAL_PROTOCOL:
case NEW_PROTOCOL:
sprintf(property_path,"%02X-%02X-%02X-%02X-%02X-%02X.props",
radio->info.network.mac_address[0],
radio->info.network.mac_address[1],
radio->info.network.mac_address[2],
radio->info.network.mac_address[3],
radio->info.network.mac_address[4],
radio->info.network.mac_address[5]);
break;
#ifdef LIMESDR
case LIMESDR_PROTOCOL:
sprintf(property_path,"limesdr.props");
break;
#endif
}
radioRestoreState();
fprintf(stderr,"malloc samples\n");
if(radio->protocol==NEW_PROTOCOL) {
samples=malloc(display_width*sizeof(float)*2*4); // 192 -> 48
} else {
samples=malloc(display_width*sizeof(float)*2);
}
//splash_status("Initializing wdsp ...");
fprintf(stderr,"wdsp_init\n");
wdsp_init(0,display_width,radio->protocol);
switch(radio->protocol) {
case ORIGINAL_PROTOCOL:
splash_status("Initializing old protocol ...");
fprintf(stderr,"old_protocol_init\n");
old_protocol_init(0,display_width);
break;
case NEW_PROTOCOL:
splash_status("Initializing new protocol ...");
fprintf(stderr,"new_protocol_init\n");
new_protocol_init(0,display_width);
break;
#ifdef LIMESDR
case LIMESDR_PROTOCOL:
splash_status("Initializing lime protocol ...");
lime_protocol_init(0,display_width);
break;
#endif
}
fprintf(stderr,"gpio_init\n");
splash_status("Initializing GPIO ...");
#ifdef GPIO
if(gpio_init()<0) {
}
#endif
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "pihpsdr");
gtk_window_set_position(GTK_WINDOW(window),GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
g_signal_connect (window, "delete-event", G_CALLBACK (main_delete), NULL);
fixed=gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed);
y=0;
fprintf(stderr,"vfo_height=%d\n",VFO_HEIGHT);
vfo = vfo_init(VFO_WIDTH,VFO_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),vfo,0,0);
rit_control = rit_init(RIT_WIDTH,MENU_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),rit_control,VFO_WIDTH,y);
fprintf(stderr,"menu_height=%d\n",MENU_HEIGHT);
//menu = menu_init(MENU_WIDTH,MENU_HEIGHT,window);
menu = new_menu_init(MENU_WIDTH-RIT_WIDTH,MENU_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),menu,VFO_WIDTH+((MENU_WIDTH/3)*2),y);
fprintf(stderr,"meter_height=%d\n",METER_HEIGHT);
meter = meter_init(METER_WIDTH,METER_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),meter,VFO_WIDTH+MENU_WIDTH,y);
y+=VFO_HEIGHT;
if(display_panadapter) {
int height=PANADAPTER_HEIGHT;
if(!display_waterfall) {
height+=WATERFALL_HEIGHT;
if(!display_sliders) {
height+=SLIDERS_HEIGHT;
}
if(!display_toolbar) {
height+=TOOLBAR_HEIGHT;
}
} else {
if(!display_sliders) {
height+=SLIDERS_HEIGHT/2;
}
}
fprintf(stderr,"panadapter_height=%d\n",height);
panadapter = panadapter_init(display_width,height);
gtk_fixed_put(GTK_FIXED(fixed),panadapter,0,VFO_HEIGHT);
y+=height;
}
if(display_waterfall) {
int height=WATERFALL_HEIGHT;
if(!display_panadapter) {
height+=PANADAPTER_HEIGHT;
}
if(!display_sliders) {
if(display_panadapter) {
height+=SLIDERS_HEIGHT/2;
} else {
height+=SLIDERS_HEIGHT;
}
}
if(!display_toolbar) {
height+=TOOLBAR_HEIGHT;
}
fprintf(stderr,"waterfall_height=%d\n",height);
waterfall = waterfall_init(display_width,height);
gtk_fixed_put(GTK_FIXED(fixed),waterfall,0,y);
y+=height;
}
#ifdef PSK
int psk_height=PSK_WATERFALL_HEIGHT;
if(!display_sliders) {
psk_height+=SLIDERS_HEIGHT/2;
}
if(!display_toolbar) {
psk_height+=TOOLBAR_HEIGHT/2;
}
psk_waterfall = psk_waterfall_init(display_width,psk_height);
gtk_fixed_put(GTK_FIXED(fixed),psk_waterfall,0,VFO_HEIGHT);
psk = init_psk();
gtk_fixed_put(GTK_FIXED(fixed),psk,0,VFO_HEIGHT+psk_height);
#endif
if(display_sliders) {
fprintf(stderr,"sliders_height=%d\n",SLIDERS_HEIGHT);
sliders = sliders_init(display_width,SLIDERS_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),sliders,0,y);
y+=SLIDERS_HEIGHT;
}
if(display_toolbar) {
fprintf(stderr,"toolbar_height=%d\n",TOOLBAR_HEIGHT);
toolbar = toolbar_init(display_width,TOOLBAR_HEIGHT,window);
gtk_fixed_put(GTK_FIXED(fixed),toolbar,0,y);
y+=TOOLBAR_HEIGHT;
}
splash_close();
gtk_widget_show_all (window);
if(full_screen) {
gtk_window_fullscreen(GTK_WINDOW(window));
}
GdkWindow *gdk_window = gtk_widget_get_window(window);
gdk_window_set_cursor(gdk_window,cursor_arrow);
// start the receiver
SetChannelState(CHANNEL_RX0,1,1);
//update_timer_id=gdk_threads_add_timeout(1000/updates_per_second, update, NULL);
update_timer_id=gdk_threads_add_timeout_full(G_PRIORITY_HIGH_IDLE,1000/updates_per_second, update, NULL, NULL);
// save every 30 seconds
save_timer_id=gdk_threads_add_timeout(30000, save_cb, NULL);
if(protocol!=NEW_PROTOCOL) {
setFrequency(getFrequency());
}
#ifdef PSK
if(mode==modePSK) {
show_psk();
} else {
show_waterfall();
}
#endif
g_idle_add(vfo_update,(gpointer)NULL);
return 0;
}
// wait_gtk_events: Waits for all pending gtk events
// to be handled before continuing execution
// ---------------------------------------------- >>
void wait_gtk_events()
{
while(gtk_events_pending())
gtk_main_iteration();
}
void WebViewTest::quitMainLoopAfterProcessingPendingEvents()
{
while (gtk_events_pending())
gtk_main_iteration();
quitMainLoop();
}
int
create_nasa_mapfile (double lat, double lon, int test, char *fn)
{
/* lat,lon= koordinates */
/* test= test if maps are present */
/* fn = filename of the generated file */
int fdout, uc = 0;
int scale, e, xsize_e, xsize_w;
int xstart, ystart, y, x_w, x_e;
double mylon;
GtkWidget *myprogress, *text, *vbox;
char textbuf[40];
char *basename;
if (!havenasamaps)
return -1;
scale = 2614061;
mylon = lon;
g_strlcpy (fn, "nofile.sorry", 255);
/* return if no map found */
if (lon > 0)
{
xstart = (int) (21600.0 * (lon / 180.0));
if (((xstart < 1280) || (xstart > 20320)) && (fdin_w < 0))
return -1;
if (fdin_e < 0)
return -1;
}
else
{
lon = 180.0 + lon;
xstart = (int) (21600.0 * (lon / 180.0));
if (((xstart < 1280) || (xstart > 20320)) && (fdin_e < 0))
return -1;
if (fdin_w < 0)
return -1;
}
if (!test)
{
fdout = open (outfilename, O_RDWR | O_TRUNC | O_CREAT | O_BINARY, 0644);
if (fdout < 0)
{
fprintf (stderr,
_("Could not create output map file \"%s\"!\n"),
outfilename);
return -1;
}
nasawindow = gtk_window_new (GTK_WINDOW_POPUP);
vbox = gtk_vbox_new (FALSE, 6);
gtk_container_add (GTK_CONTAINER (nasawindow), vbox);
gtk_window_set_position (GTK_WINDOW (nasawindow),
GTK_WIN_POS_CENTER);
/* g_signal_connect (window, "destroy", */
/* G_CALLBACK (gtk_widget_destroyed), &window); */
gtk_window_set_title (GTK_WINDOW (nasawindow),
_("Creating map..."));
gtk_container_set_border_width (GTK_CONTAINER (nasawindow), 20);
myprogress = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (myprogress), 0.0);
gtk_box_pack_start (GTK_BOX (vbox), myprogress, TRUE, TRUE, 2);
text = gtk_label_new (
_("Creating a temporary map from NASA satellite images"));
gtk_box_pack_start (GTK_BOX (vbox), text, TRUE, TRUE, 2);
/* gtk_widget_show_all (nasawindow); */
gtk_widget_show_all (nasawindow);
if (debug)
fprintf (stdout,
_("Converting map for latitude: %f and longitude: %f ...\n"),
lat, lon);
/* if (lon < 0.0) */
/* lon = 180.0 + lon; */
g_strlcpy (fn, "top_NASA_IMAGE.ppm", 255);
g_snprintf (mybuffer, sizeof (mybuffer),
"P6\n# CREATOR: GpsDrive\n1280 1024\n255\n");
e = write (fdout, mybuffer, strlen (mybuffer));
uc = e;
lon = mylon;
xstart = (int) (21600.0 * (lon / 180.0));
ystart = 3 * 21600 * (int) (10800 - 10800.0 * (lat / 90.0));
/* fprintf (stdout, "xstart: %d, ystart: %d\n", xstart, ystart); */
xstart -= 640;
ystart = ystart - 512 * 21600 * 3;
x_w = x_e = -1;
xsize_w = xsize_e = 1280;
if (xstart < 0)
{
x_w = 21600 + xstart;
x_e = 1280 - x_w;
if (x_e < -20320)
x_e = -1;
else if (x_e < 0)
x_e = 0;
if (x_w < -20320)
x_w = -1;
else if (x_w < 0)
x_w = 0;
xsize_w = 21600 - x_w;
xsize_e = 1280 - xsize_w;
}
else if (xstart > 20320)
{
x_w = (xstart + 1280) - 21600;
x_e = 1280 - x_w;
if (x_e < 20320)
x_e = -1;
if (x_e < 0)
x_e = 0;
xsize_w = x_w;
xsize_e = 1280 - xsize_w;
}
else
{
if (mylon >= 0.0)
x_e = xstart;
else
x_w = xstart;
}
if (xsize_w > 1280)
xsize_w = 1280;
if (xsize_e > 1280)
xsize_e = 1280;
x_w *= 3;
x_e *= 3;
for (y = 0; y < 1024; y++)
{
if ((y % 32) == 0)
{
gtk_progress_bar_set_fraction
(GTK_PROGRESS_BAR (myprogress),
y / 1024.0);
g_snprintf (textbuf, sizeof (textbuf), "%d%%",
(int) (100.0 * y / 1024));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR
(myprogress),
textbuf);
while (gtk_events_pending ())
gtk_main_iteration ();
}
if (x_w != -3)
{
e = lseek (fdin_w,
x_w + ystart + y * 21600 * 3,
SEEK_SET);
e = read (fdin_w, mybuffer, xsize_w * 3);
e = write (fdout, mybuffer, xsize_w * 3);
uc += e;
}
if (x_e != -3)
{
e = lseek (fdin_e,
x_e + ystart + y * 21600 * 3,
SEEK_SET);
e = read (fdin_e, mybuffer, xsize_e * 3);
e = write (fdout, mybuffer, xsize_e * 3);
uc += e;
}
}
/* fprintf (stderr, "wrote %d bytes (%.1f MB) to mapfile\n", uc, */
/* uc / (1024.0 * 1024.0)); */
gtk_widget_destroy (GTK_WIDGET (nasawindow));
close (fdout);
basename = g_path_get_basename(outfilename);
g_strlcpy (mybuffer, basename, sizeof (mybuffer));
g_free(basename);
fprintf (stdout,
_("\nYou can permanently add this map file with following "
"line in your\n"
"map_koord.txt (rename the file!):\n"));
fprintf (stdout, "\n%s %f %f %d\n", mybuffer, lat, lon, scale);
} /* End of if !test */
return scale;
}
/*!
* main loop. Accept contribution from clients and dispatch digest of
* the frame to all clients
*/
void
serve_dispatch (global_option_type * global_option)
{
global_status_type global_status;
int client_index;
/*
* Initialize global_status fields
*/
global_status.frame_number = 1;
global_status.number_identified_players = 0;
global_status.number_allocation_request = 0;
#if defined(GTK)
gtk_stop_asked = 0;
#endif
for (client_index = 0; client_index < MAX_NUMBER_PLAYER; client_index++)
{
global_status.player_status[client_index] = UNIDENTIFIED;
}
global_status.server_socket = SDLNet_UDP_Open (global_option->server_port);
if (global_status.server_socket == NULL)
{
printf_screen ("Couldn't open UDP socket on port %d.\nCheck privileges and availability.\n",
global_option->server_port);
return;
}
/* global_status.server_socket is ready to serve our needs :) */
global_status.current_packet = SDLNet_AllocPacket (CLIENT_PACKET_SIZE);
if (global_status.current_packet == NULL)
{
SDLNet_UDP_Close (global_status.server_socket);
printf_screen ("Failed to allocate a buffer for receiving client packets (size: %d bytes) (Not enough memory ?)",
CLIENT_PACKET_SIZE);
return;
}
global_status.digest_packet = SDLNet_AllocPacket (SERVER_PACKET_SIZE);
if (global_status.digest_packet == NULL)
{
SDLNet_UDP_Close (global_status.server_socket);
SDLNet_FreePacket (global_status.digest_packet);
printf_screen ("Failed to allocate a buffer for sending packets (size: %d bytes) (Not enough memory ?)",
SERVER_PACKET_SIZE);
return;
}
/* Allocate enough space for a single socket */
global_status.server_socket_set = SDLNet_AllocSocketSet (1);
if (global_status.server_socket_set == NULL)
{
SDLNet_UDP_Close (global_status.server_socket);
SDLNet_FreePacket (global_status.current_packet);
SDLNet_FreePacket (global_status.digest_packet);
printf_screen ("Couldn't allocate a socket set (not enough memory ?).\n");
return;
}
if (SDLNet_UDP_AddSocket (global_status.server_socket_set, global_status.server_socket) !=
1)
{
SDLNet_UDP_Close (global_status.server_socket);
SDLNet_FreePacket (global_status.current_packet);
SDLNet_FreePacket (global_status.digest_packet);
SDLNet_FreeSocketSet (global_status.server_socket_set);
printf_screen ("Error when adding socket to socket set.\n");
return;
}
/* Identification loop */
/*
* We're expecting identification packets until we've filled all slots, then
* we can proceed to the real meat
*/
for (;;)
{
int number_ready_socket;
#if defined(DEBUG)
printf_screen ("Waiting for identification\n");
#endif
if (read_incoming_server_packet (&global_status))
{
identify_client (&global_status, global_option);
if (count_remaining_slot (&global_status, global_option) == 0)
{
/* Perfect, we've finished the identification of all slots */
break;
}
printf_screen("%d slots open.\n", count_remaining_slot (&global_status, global_option));
/* Going back to the identification loop */
continue;
}
#if defined(GTK)
gtk_iteration = GTK_SERVER_SOCKET_RATIO;
do {
number_ready_socket =
SDLNet_CheckSockets (global_status.server_socket_set, SERVER_SOCKET_TIMEOUT / GTK_SERVER_SOCKET_RATIO);
while (gtk_events_pending())
{
if (gtk_main_iteration())
{
gtk_stop_asked = 1;
}
}
} while ( (number_ready_socket == 0) && (--gtk_iteration != 0) && !gtk_stop_asked);
#else
number_ready_socket =
SDLNet_CheckSockets (global_status.server_socket_set, SERVER_SOCKET_TIMEOUT);
#endif
if (gtk_stop_asked)
{
break;
}
if (number_ready_socket == -1)
{
printf_screen ("Error in socket waiting (disconnection ?).\n");
break;
}
if (number_ready_socket == 1)
{
#if defined(DEBUG)
printf_screen ("Got a packet\n");
#endif
/* We're awaiting a packet in the server socket */
if (read_incoming_server_packet (&global_status))
{
/*
* If we haven't identified all clients yet, we're trying to use the current packet
* to improve our knowledge of the typography
*/
identify_client (&global_status, global_option);
if (count_remaining_slot (&global_status, global_option) == 0)
{
/* Perfect, we've finished the identification of all slots */
break;
}
printf_screen("%d slots open.\n", count_remaining_slot (&global_status, global_option));
}
}
}
if (!gtk_stop_asked)
{
printf_screen ("Identification finished\n");
#if defined(DEBUG)
for (client_index = 0; client_index < MAX_NUMBER_PLAYER; client_index++)
{
printf_screen ("Mapping[%d] = { { 0x%08X, %d }, %d }\n", client_index,
global_status.input_mapping[client_index].address.host,
global_status.input_mapping[client_index].address.port,
global_status.input_mapping[client_index].remote_input_device);
}
#endif
switch (global_option->type_server)
{
case LAN_PROTOCOL_TYPE:
serve_clients_lan_protocol(&global_status, global_option);
break;
case INTERNET_PROTOCOL_TYPE:
serve_clients_internet_protocol(&global_status, global_option);
break;
default:
printf_screen("Internal error, unknown internal server type : %d\n", global_option->type_server);
break;
}
} // gtk_stop_asked
/*
* Free resources
*/
SDLNet_FreePacket (global_status.current_packet);
SDLNet_FreePacket (global_status.digest_packet);
SDLNet_FreeSocketSet (global_status.server_socket_set);
SDLNet_UDP_Close (global_status.server_socket);
global_status.server_socket = NULL;
}
void Pass (void)
{
/* The next 4 lines must be there. */
while (gtk_events_pending ())
{
gtk_main_iteration ();
}
if (ichangestuff == 0)
{
Play ("click.mp3", 0);
}
if ((((ifilestuff == 0) && ((biscomputer == 0) || (wiscomputer == 0))
&& (iyesno == 0)) && (((((Modulo (imoves, 2) == 0) && (iiamblack == 1)) ||
((Modulo (imoves, 2) != 0) && (iiamblack == 0))) && (inet == 1)) ||
(inet == 0))) && (imoving == 0))
{
imoving = 1;
if (inet == 1)
{
SendData (1, "pass");
}
if (Modulo (imoves, 2) == 0)
{
JudgeBoard ('w');
}
else
{
JudgeBoard ('b');
}
pass[ihistory] = 1;
iscorewhite = ScoreWhite ();
iscoreblack = ScoreBlack ();
if (Modulo (imoves, 2) != 0)
{
if ((iscorewhite > iscoreblack) || (pass[ihistory - 1] == 1))
{
if (iscorewhite > iscoreblack)
{
iduh = 1;
}
EndGame ();
}
else
{
if (wiscomputer == 1)
{
Computer ('w');
JudgeBoard ('b');
}
}
}
else
{
if ((iscoreblack > iscorewhite) || (pass[ihistory - 1] == 1))
{
if (iscoreblack > iscorewhite)
{
iduh = 1;
}
EndGame ();
}
else
{
if (biscomputer == 1)
{
Computer ('b');
JudgeBoard ('w');
}
}
}
imoving = 0;
}
else
{
if (inet == 1)
{
Message ("It is not your move.", 3, 0);
}
}
}
bool pApplication::pendingEvents() {
return gtk_events_pending();
}
int main(int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *button_clear, *button_azel, *button_freq, *button_offset;
GtkWidget *button_help;
GdkColor color;
int i, ii;
int yr, da, hr, mn, sc;
double secstart;
char buf[64];
GdkGeometry geometry;
GdkWindowHints geo_mask;
// GdkRectangle update_rect;
sprintf(d1.catnam, "srt.cat");
sprintf(d1.hlpnam, "srt.hlp");
for (i = 0; i < argc - 1; i++) {
sscanf(argv[i], "%63s", buf);
if (strstr(buf, "-c") && strlen(buf) == 2)
sscanf(argv[i + 1], "%63s", d1.catnam);
if (strstr(buf, "-h") && strlen(buf) == 2)
sscanf(argv[i + 1], "%63s", d1.hlpnam);
}
// d1.azelport = 0x3f8; // com1 default for old SRT
d1.ver = 4; // SRT software version
d1.secs = readclock();
d1.run = 1;
d1.record = 0;
d1.entry1 = d1.entry2 = d1.entry3 = d1.entry5 = d1.entry6 = d1.entry8 = d1.helpwindow = d1.vwindow = 0;
d1.plot = 0;
d1.start_time = 0.0;
d1.start_sec = 0.0;
d1.speed_up = 0;
d1.ppos = 0;
d1.printout = 1;
d1.debug = 0;
d1.freq = 1420.4; // default
d1.bw = 0; // set to 2.4 for TV dongle 10 MHz for ADC card in init
d1.fbw = 0; // set in init or srt.cat
d1.nblk = 5; // number of blocks in vspectra
d1.record_int_sec = 0;
d1.freqcorr = 0; // frequency correction for L.O. may be needed for TV dongle
d1.freqchng = 0;
d1.clearint = 0;
d1.record_clearint = 0;
d1.noclearint = 0;
d1.nfreq = NSPEC;
d1.plotsec = 1;
d1.displ = 1;
d1.noisecal = 0;
// used for old SRT mount and controller
// d1.ptoler = 1;
// d1.countperstep = 10000; // default large number for no stepping
// d1.elcounts_per_deg = (52.0 * 27.0 / 120.0); // default for H-180
// d1.azcounts_per_deg = 8.0 * 32.0 * 60.0 / (360.0 * 9.0); // default for CASSIMOUNT
// d1.rod = 1; // default to rod as on CASSIMOUNT
// d1.rod1 = 14.25; // rigid arm length
// d1.rod2 = 16.5; // distance from pushrod upper joint to el axis
// d1.rod3 = 2.0; // pushrod collar offset
// d1.rod4 = 110.0; // angle at horizon
// d1.rod5 = 30.0; // pushrod counts per inch
d1.azelsim = d1.radiosim = d1.fftsim = 0;
d1.mainten = 0;
d1.stowatlim = 1;
d1.rms = -1; // display max not rms
d1.calcons = 1.0;
d1.caldone = 0;
d1.nrfi = 0;
d1.rfisigma = 6; // level for RFI reporting to screen
d1.tload = 300.0;
d1.tspill = 20.0;
d1.beamw = 5.0;
d1.comerr = 0;
d1.limiterr = 0;
d1.restfreq = 1420.406; /* H-line restfreq */
d1.delay = 0;
d1.azoff = 0.0;
d1.eloff = 0.0;
d1.drift = 0;
d1.tstart = 0;
d1.tsys = 100.0; // expected on cold sky
d1.pwroff = 0.0;
d1.tant = 100.0;
d1.calpwr = 0;
d1.yfac = 0;
d1.calon = 0;
d1.calmode = 0;
d1.docal = 0;
d1.tcal = 290; // absorber or bushes
d1.sourn = 0;
d1.track = 0;
d1.scan = 0;
d1.bsw = 0;
d1.nbsw = 1;
d1.obsn = 0;
d1.stopproc = 0;
d1.fstatus = 0;
d1.cmdfl = 0;
d1.south = 1;
d1.hgt = 0;
d1.dongle = 0; // set to zero initially - set to 1 in Init_Device if dongle
d1.npoly = 25; // number of terms in polynomial fit of bandpass
pwrst = pwrprev = 0.0;
soutrack[0] = 0;
sprintf(d1.cmdfnam, "cmd.txt");
sprintf(d1.datadir, "./"); // default to local directory
if (!catfile())
return 0;
d1.foutstatus = 0;
// to get permission su root chown root srtn then chmod u+s srtn then exit
if (!d1.azelsim) {
if (d1.printout)
printf("initializing antenna controller\n");
i = rot2(&d1.aznow, &d1.elnow, -1, buf); // initialize
i = rot2(&d1.aznow, &d1.elnow, 1, buf); // read
if (i < 0) {
printf("Couldn't talk to antenna controller\n");
return 0;
}
} else {
if (d1.stowatlim) {
d1.azprev = d1.azlim1;
d1.elprev = d1.ellim1;
} else {
d1.azprev = d1.stowaz;
d1.elprev = d1.stowel;
}
}
setgid(getgid());
setuid(getuid());
if (d1.mainten == 0) {
if (d1.stowatlim) {
d1.azcmd = d1.azlim1;
d1.elcmd = d1.ellim1;
} else {
d1.azcmd = d1.stowaz;
d1.elcmd = d1.stowel;
}
d1.azcount = 0;
d1.elcount = 0;
d1.stow = 1;
}
if (d1.azlim1 > d1.azlim2) {
d1.south = 0; // dish pointing North for southern hemisphere
if (d1.azlim2 < 360.0)
d1.azlim2 += 360.0;
}
if (!d1.radiosim)
Init_Device(0);
if (d1.displ) {
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
geometry.min_width = 500;
geometry.min_height = 300;
geo_mask = GDK_HINT_MIN_SIZE;
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geometry, geo_mask);
//Table size determines number of buttons across the top
table = gtk_table_new(30, NUMBUTTONS, TRUE);
drawing_area = gtk_drawing_area_new();
gtk_window_set_default_size(GTK_WINDOW(window), 800, 600);
color.red = 0xffff;
color.blue = 0xffff;
color.green = 0xffff;
gtk_widget_show(drawing_area);
gtk_table_attach_defaults(GTK_TABLE(table), drawing_area, 0, NUMBUTTONS, 3, 30);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(quit), NULL);
gtk_container_add(GTK_CONTAINER(window), table);
g_signal_connect(G_OBJECT(drawing_area), "expose_event", (GtkSignalFunc) expose_event, NULL);
g_signal_connect(G_OBJECT(drawing_area), "configure_event", (GtkSignalFunc) configure_event, NULL);
g_signal_connect(G_OBJECT(drawing_area), "button_press_event",
(GtkSignalFunc) button_press_event, NULL);
gtk_widget_set_events(drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
button_clear = gtk_button_new_with_label("clear");
button_stow = gtk_button_new_with_label("stow");
button_azel = gtk_button_new_with_label("azel");
button_npoint = gtk_button_new_with_label("npoint");
button_bsw = gtk_button_new_with_label("beamsw");
button_freq = gtk_button_new_with_label("freq");
button_offset = gtk_button_new_with_label("offset");
button_record = gtk_button_new_with_label("record");
button_cmdfl = gtk_button_new_with_label("cmdfl");
button_cal = gtk_button_new_with_label("cal");
button_help = gtk_button_new_with_label("help");
button_exit = gtk_button_new_with_label("exit");
g_signal_connect(G_OBJECT(button_clear), "clicked", G_CALLBACK(button_clear_clicked), NULL);
g_signal_connect(G_OBJECT(button_stow), "clicked", G_CALLBACK(button_stow_clicked), NULL);
g_signal_connect(G_OBJECT(button_azel), "clicked", G_CALLBACK(button_azel_clicked), NULL);
g_signal_connect(G_OBJECT(button_npoint), "clicked", G_CALLBACK(button_npoint_clicked), NULL);
g_signal_connect(G_OBJECT(button_bsw), "clicked", G_CALLBACK(button_bsw_clicked), NULL);
g_signal_connect(G_OBJECT(button_freq), "clicked", G_CALLBACK(button_freq_clicked), NULL);
g_signal_connect(G_OBJECT(button_offset), "clicked", G_CALLBACK(button_offset_clicked), NULL);
g_signal_connect(G_OBJECT(button_record), "clicked", G_CALLBACK(button_record_clicked), NULL);
g_signal_connect(G_OBJECT(button_cmdfl), "clicked", G_CALLBACK(button_cmdfl_clicked), NULL);
g_signal_connect(G_OBJECT(button_cal), "clicked", G_CALLBACK(button_cal_clicked), NULL);
g_signal_connect(G_OBJECT(button_help), "clicked", G_CALLBACK(button_help_clicked), NULL);
g_signal_connect(G_OBJECT(button_exit), "clicked", G_CALLBACK(button_exit_clicked), NULL);
// test setting up tooltips instead of the "enter"/"leave" used below
tooltips = gtk_tooltips_new();
gtk_tooltips_set_tip(tooltips, button_clear,
"click to clear integration and reset time plot to 1/4-scale", NULL);
gtk_tooltips_set_tip(tooltips, button_stow, "click to stow antenna", NULL);
gtk_tooltips_set_tip(tooltips, button_azel, "click to enter az el coordinates", NULL);
gtk_tooltips_set_tip(tooltips, button_npoint, "click to start npoint scan", NULL);
gtk_tooltips_set_tip(tooltips, button_bsw, "click to start beam switch", NULL);
gtk_tooltips_set_tip(tooltips, button_freq, "click to enter new frequency in MHz [bandwidth] [nfreq]",
NULL);
gtk_tooltips_set_tip(tooltips, button_offset, "click to enter offsets", NULL);
if (!d1.cmdfl)
gtk_tooltips_set_tip(tooltips, button_cmdfl, "click to start cmd file", NULL);
else
gtk_tooltips_set_tip(tooltips, button_cmdfl, "click to stop cmd file", NULL);
gtk_tooltips_set_tip(tooltips, button_cal, "click to start calibration", NULL);
gtk_tooltips_set_tip(tooltips, button_help, "click to open help window", NULL);
record_tooltip();
gtk_table_attach(GTK_TABLE(table), button_clear, 0, 1, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_stow, 1, 2, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_azel, 2, 3, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_npoint, 3, 4, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_bsw, 4, 5, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_freq, 5, 6, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_offset, 6, 7, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_record, 7, 8, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_cmdfl, 8, 9, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_cal, 9, 10, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_help, 10, 11, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button_exit, 11, 12, 0, 2, GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show(button_clear);
gtk_widget_show(button_stow);
gtk_widget_show(button_azel);
gtk_widget_show(button_npoint);
gtk_widget_show(button_bsw);
gtk_widget_show(button_freq);
gtk_widget_show(button_offset);
gtk_widget_show(button_record);
gtk_widget_show(button_cmdfl);
gtk_widget_show(button_cal);
gtk_widget_show(button_help);
gtk_widget_show(button_exit);
gtk_widget_show(table);
gtk_widget_show(window);
clearpaint();
}
ii = 0;
if (d1.printout) {
toyrday(d1.secs, &yr, &da, &hr, &mn, &sc);
printf("%4d:%03d:%02d:%02d:%02d %3s ", yr, da, hr, mn, sc, d1.timsource);
}
zerospectra(0);
for (i = 0; i < d1.nfreq; i++)
bspec[i] = 1;
secstart = d1.nsecstart = -1;
d1.secs = readclock();
while (d1.run) {
zerospectra(1);
if (d1.clearint) {
if (d1.displ)
cleararea();
zerospectra(0);
d1.clearint = 0;
}
if (d1.freqchng) {
if (d1.dongle)
Init_Device(1);
if (d1.printout) {
toyrday(d1.secs, &yr, &da, &hr, &mn, &sc);
printf("%4d:%03d:%02d:%02d:%02d %3s ", yr, da, hr, mn, sc, d1.timsource);
}
if (!d1.radiosim) {
sleep(1);
}
zerospectra(0);
d1.freqchng = 0;
}
if (d1.docal) {
if (d1.docal == 1) {
sprintf(d1.recnote, "* calibration started\n");
outfile(d1.recnote);
}
if (d1.bsw) {
d1.bsw = 0;
d1.azoff = 0.0;
}
if (d1.scan) {
d1.scan = 0;
d1.eloff = d1.azoff = 0.0;
}
if (d1.slew)
d1.slew = 0;
if (d1.docal == 1)
cal(0);
d1.docal = 2;
cal(1);
if (d1.integ >= NCAL) {
cal(2);
d1.docal = 0;
}
}
if (d1.displ)
cleararea();
azel(d1.azcmd, d1.elcmd); // allow time after cal
if (d1.comerr == -1)
return 0;
if (!d1.slew) {
pwr = 0.0;
}
if (!d1.slew)
vspectra();
d1.secs = readclock();
aver();
d1.integ2++;
if (d1.record_int_sec && d1.integ2 >= d1.record_int_sec) {
outfile(" ");
if (d1.record_clearint && d1.track && !d1.bsw && !d1.scan)
d1.clearint = 1;
d1.integ2 = 0;
}
if (d1.displ) {
if (!d1.plot)
Repaint();
while (gtk_events_pending() || d1.stopproc == 1) {
gtk_main_iteration();
d1.plot = 0;
}
}
if (!d1.displ && d1.domap)
scanplot();
}
return 0;
}
void DisplayChangesGui::display(const vector <ustring>& differences)
{
// Store position of scrollled window.
GtkAdjustment * adjustment = gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolledwindow));
int scrollbar_position = gtk_adjustment_get_value (adjustment);
// Variable for holding the number of modifications.
unsigned int modification_count = 0;
// Temporally removing the view from the buffer speeds loading text up a huge lot.
g_object_ref(textbuffer);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(textview), NULL);
// Clear buffer.
clear();
// Load text.
for (unsigned int i = 0; i < differences.size(); i++) {
GtkTextIter iter;
GtkTextTag *tag = NULL;
ustring line = differences[i];
while (!line.empty()) {
// Handle insertion or deletion flag for the next character.
tag = NULL;
ustring character = line.substr (0, 1);
if (!strcmp (character.c_str(), INSERTION_FLAG)) {
tag = heavy_weight_tag;
}
if (!strcmp (character.c_str(), DELETION_FLAG)) {
tag = strike_through_tag;
}
if (tag) {
line.erase (0, 1);
// Another modification.
modification_count++;
}
// Print one character with optional markup.
character = line.substr (0, 1);
gtk_text_buffer_get_end_iter(textbuffer, &iter);
gtk_text_buffer_insert_with_tags(textbuffer, &iter, character.c_str(), -1, tag, NULL);
line.erase(0, 1);
}
// End of line.
gtk_text_buffer_get_end_iter(textbuffer, &iter);
gtk_text_buffer_insert(textbuffer, &iter, "\n", 1);
}
// Reconnect the view to the buffer.
gtk_text_view_set_buffer(GTK_TEXT_VIEW(textview), textbuffer);
g_object_unref(textbuffer);
// Show modification count.
ustring message = _("Number of modifications: ");
message.append (convert_to_string (modification_count));
gtk_label_set_text (GTK_LABEL (label), message.c_str());
// Restore scrollled window's position.
// The window will then show the same block of text as before loading. This makes editing the text easier.
while (gtk_events_pending())
gtk_main_iteration();
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolledwindow));
gtk_adjustment_set_value (adjustment, scrollbar_position);
}
/* - updates sizes, names, etc */
static gint
canvas_node_update(node_id_t * node_id, canvas_node_t * canvas_node,
GList **delete_list)
{
node_t *node;
gdouble node_size;
static clock_t start = 0;
clock_t end;
gdouble cpu_time_used;
char *nametmp = NULL;
node = nodes_catalog_find(node_id);
/* Remove node if node is too old or if capture is stopped */
if (!node || !display_node (node))
{
/* adds current to list of canvas nodes to delete */
*delete_list = g_list_prepend( *delete_list, node_id);
g_my_debug ("Queing canvas node to remove.");
need_reposition = TRUE;
return FALSE;
}
switch (pref.node_size_variable)
{
case INST_TOTAL:
node_size = get_node_size (node->node_stats.stats.average);
break;
case INST_INBOUND:
node_size = get_node_size (node->node_stats.stats_in.average);
break;
case INST_OUTBOUND:
node_size = get_node_size (node->node_stats.stats_out.average);
break;
case INST_PACKETS:
node_size = get_node_size (node->node_stats.pkt_list.length);
break;
case ACCU_TOTAL:
node_size = get_node_size (node->node_stats.stats.accumulated);
break;
case ACCU_INBOUND:
node_size = get_node_size (node->node_stats.stats_in.accumulated);
break;
case ACCU_OUTBOUND:
node_size = get_node_size (node->node_stats.stats_out.accumulated);
break;
case ACCU_PACKETS:
node_size = get_node_size (node->node_stats.stats.accu_packets);
break;
case ACCU_AVG_SIZE:
node_size = get_node_size (node->node_stats.stats.avg_size);
break;
default:
node_size = get_node_size (node->node_stats.stats_out.average);
g_warning (_("Unknown value or node_size_variable"));
}
/* limit the maximum size to avoid overload */
if (node_size > MAX_NODE_SIZE)
node_size = MAX_NODE_SIZE;
if (node->main_prot[pref.stack_level])
{
canvas_node->color = protohash_color(node->main_prot[pref.stack_level]);
gnome_canvas_item_set (canvas_node->node_item,
"x1", -node_size / 2,
"x2", node_size / 2,
"y1", -node_size / 2,
"y2", node_size / 2,
"fill_color_gdk", &(canvas_node->color), NULL);
}
else
{
guint32 black = 0x000000ff;
gnome_canvas_item_set (canvas_node->node_item,
"x1", -node_size / 2,
"x2", node_size / 2,
"y1", -node_size / 2,
"y2", node_size / 2,
"fill_color_rgba", black, NULL);
}
/* We check the name of the node, and update the canvas node name
* if it has changed (useful for non blocking dns resolving) */
/*TODO why is it exactly that sometimes it is NULL? */
if (canvas_node->text_item)
{
g_object_get (G_OBJECT (canvas_node->text_item),
"text", &nametmp,
NULL);
if (strcmp (nametmp, node->name->str))
{
gnome_canvas_item_set (canvas_node->text_item,
"text", node->name->str,
NULL);
gnome_canvas_item_request_update (canvas_node->text_item);
}
g_free (nametmp);
}
/* Processor time check. If too much time has passed, update the GUI */
end = clock ();
cpu_time_used = ((gdouble) (end - start)) / CLOCKS_PER_SEC;
if (cpu_time_used > 0.05)
{
/* Force redraw */
while (gtk_events_pending ())
gtk_main_iteration ();
start = end;
}
return FALSE; /* False means keep on calling the function */
} /* update_canvas_nodes */
int hs20_web_browser(const char *url)
{
GtkWidget *scroll;
SoupSession *s;
WebKitWebView *view;
WebKitWebSettings *settings;
struct browser_context ctx;
memset(&ctx, 0, sizeof(ctx));
if (!gtk_init_check(NULL, NULL))
return -1;
s = webkit_get_default_session();
g_object_set(G_OBJECT(s), "ssl-ca-file",
"/etc/ssl/certs/ca-certificates.crt", NULL);
g_object_set(G_OBJECT(s), "ssl-strict", FALSE, NULL);
ctx.win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_role(GTK_WINDOW(ctx.win), "Hotspot 2.0 client");
gtk_window_set_default_size(GTK_WINDOW(ctx.win), 800, 600);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
g_signal_connect(G_OBJECT(ctx.win), "destroy",
G_CALLBACK(win_cb_destroy), &ctx);
view = WEBKIT_WEB_VIEW(webkit_web_view_new());
g_signal_connect(G_OBJECT(view), "notify::progress",
G_CALLBACK(view_cb_notify_progress), &ctx);
g_signal_connect(G_OBJECT(view), "notify::load-status",
G_CALLBACK(view_cb_notify_load_status), &ctx);
g_signal_connect(G_OBJECT(view), "resource-request-starting",
G_CALLBACK(view_cb_resource_request_starting), &ctx);
g_signal_connect(G_OBJECT(view), "mime-type-policy-decision-requested",
G_CALLBACK(view_cb_mime_type_policy_decision), &ctx);
g_signal_connect(G_OBJECT(view), "download-requested",
G_CALLBACK(view_cb_download_requested), &ctx);
g_signal_connect(G_OBJECT(view), "hovering-over-link",
G_CALLBACK(view_cb_hovering_over_link), &ctx);
g_signal_connect(G_OBJECT(view), "title-changed",
G_CALLBACK(view_cb_title_changed), &ctx);
gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(view));
gtk_container_add(GTK_CONTAINER(ctx.win), GTK_WIDGET(scroll));
gtk_widget_grab_focus(GTK_WIDGET(view));
gtk_widget_show_all(ctx.win);
settings = webkit_web_view_get_settings(view);
g_object_set(G_OBJECT(settings), "user-agent",
"Mozilla/5.0 (X11; U; Unix; en-US) "
"AppleWebKit/537.15 (KHTML, like Gecko) "
"hs20-client/1.0", NULL);
g_object_set(G_OBJECT(settings), "auto-load-images", TRUE, NULL);
webkit_web_view_load_uri(view, url);
gtk_main();
gtk_widget_destroy(ctx.win);
while (gtk_events_pending())
gtk_main_iteration();
free(ctx.hover_link);
free(ctx.title);
return ctx.success;
}
int MsdDevice::Configure(int port, const std::string& api, void *data)
{
GtkWidget *ro_frame, *ro_label, *rs_hbox, *rs_label, *rs_cb, *vbox;
GtkWidget *dlg = gtk_dialog_new_with_buttons (
"Mass Storage Settings", GTK_WINDOW (data), GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (dlg), TRUE);
GtkWidget *dlg_area_box = gtk_dialog_get_content_area (GTK_DIALOG (dlg));
ro_frame = gtk_frame_new (NULL);
gtk_box_pack_start (GTK_BOX (dlg_area_box), ro_frame, TRUE, FALSE, 5);
ro_label = gtk_label_new ("Select USB image:");
gtk_frame_set_label_widget (GTK_FRAME (ro_frame), ro_label);
gtk_label_set_use_markup (GTK_LABEL (ro_label), TRUE);
vbox = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (ro_frame), vbox);
rs_hbox = gtk_hbox_new (FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), rs_hbox, FALSE, TRUE, 0);
GtkWidget *entry = gtk_entry_new ();
gtk_entry_set_max_length (GTK_ENTRY (entry), MAX_PATH); //TODO max length
std::string var;
if (LoadSetting(port, APINAME, N_CONFIG_PATH, var))
gtk_entry_set_text(GTK_ENTRY(entry), var.c_str());
g_signal_connect (entry, "changed", G_CALLBACK (entryChanged), NULL);
GtkWidget *button = gtk_button_new_with_label ("Browse");
gtk_button_set_image(GTK_BUTTON (button), gtk_image_new_from_icon_name ("gtk-open", GTK_ICON_SIZE_BUTTON));
g_signal_connect (button, "clicked", G_CALLBACK (fileChooser), entry);
gtk_box_pack_start (GTK_BOX (rs_hbox), entry, TRUE, TRUE, 5);
gtk_box_pack_start (GTK_BOX (rs_hbox), button, FALSE, FALSE, 5);
gtk_widget_show_all (dlg);
gint result = gtk_dialog_run (GTK_DIALOG (dlg));
std::string path = gtk_entry_get_text(GTK_ENTRY(entry));
gtk_widget_destroy (dlg);
// Wait for all gtk events to be consumed ...
while (gtk_events_pending ())
gtk_main_iteration_do (FALSE);
if (result == GTK_RESPONSE_OK)
{
if(SaveSetting(port, APINAME, N_CONFIG_PATH, path))
return RESULT_OK;
else
return RESULT_FAILED;
}
return RESULT_CANCELED;
}
int main(int argc, char **argv)
{
struct gtkwave_dual_ipc_t *dual_ctx;
char buf[257], buf2[257];
int shmid;
GtkWidget *main_vbox, *mainwindow, *vpan;
int i;
int split_point = -1;
#ifdef __MINGW32__
char mapName[65];
HANDLE hMapFile;
#endif
GtkWidget *xsocket[2] = { NULL, NULL };
WAVE_LOCALE_FIX
if(!gtk_init_check(&argc, &argv))
{
printf("Could not initialize GTK! Is DISPLAY env var/xhost set?\n\n");
exit(255);
}
#ifdef __CYGWIN__
fprintf(stderr, "TWINWAVE| If the viewer crashes with a Bad system call error,\n");
fprintf(stderr, "TWINWAVE| make sure that Cygserver is enabled.\n");
#endif
for(i=0;i<argc;i++)
{
if(!strcmp(argv[i], "+"))
{
split_point = i;
break;
}
if(!strcmp(argv[i], "++"))
{
split_point = i;
use_embedded = 0;
break;
}
}
if(split_point < 0)
{
printf("Usage:\n------\n%s arglist1 separator arglist2\n\n"
"The '+' between argument lists splits and creates one window.\n"
"The '++' between argument lists splits and creates two windows.\n"
"\n", argv[0]);
exit(255);
}
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Initializing");
#ifndef MAC_INTEGRATION
gtk_widget_set_usize(GTK_WIDGET(mainwindow), 820, 800);
#else
gtk_widget_set_usize(GTK_WIDGET(mainwindow), 400,32); /* quartz doesn't retarget into mainwindow */
#endif
gtk_widget_show(mainwindow);
gtk_signal_connect(GTK_OBJECT(mainwindow), "destroy", GTK_SIGNAL_FUNC(quit_callback), "WM destroy");
xsocket[0] = gtk_socket_new ();
xsocket[1] = gtk_socket_new ();
gtk_widget_show (xsocket[0]);
gtk_widget_show (xsocket[1]);
gtk_signal_connect(GTK_OBJECT(xsocket[0]), "plug-removed", GTK_SIGNAL_FUNC(plug_removed), NULL);
main_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(mainwindow), main_vbox);
gtk_widget_show(main_vbox);
vpan = gtk_vpaned_new ();
gtk_widget_show (vpan);
gtk_box_pack_start (GTK_BOX (main_vbox), vpan, TRUE, TRUE, 1);
gtk_paned_pack1 (GTK_PANED (vpan), xsocket[0], TRUE, FALSE);
gtk_signal_connect(GTK_OBJECT(xsocket[1]), "plug-removed", GTK_SIGNAL_FUNC(plug_removed), NULL);
gtk_paned_pack2 (GTK_PANED (vpan), xsocket[1], TRUE, FALSE);
#ifdef __MINGW32__
shmid = getpid();
sprintf(mapName, "twinwave%d", shmid);
hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 2 * sizeof(struct gtkwave_dual_ipc_t), mapName);
if(hMapFile != NULL)
{
dual_ctx = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 2 * sizeof(struct gtkwave_dual_ipc_t));
if(dual_ctx)
{
memset(dual_ctx, 0, 2 * sizeof(struct gtkwave_dual_ipc_t));
memcpy(&dual_ctx[0].matchword, DUAL_MATCHWORD, 4);
memcpy(&dual_ctx[1].matchword, DUAL_MATCHWORD, 4);
/* child 0 */
{
int idx;
int n_items = split_point + 5;
int slen;
char **arglist = calloc(n_items, sizeof(char *));
char *mylist;
STARTUPINFO si;
PROCESS_INFORMATION pi;
BOOL rc;
memset(&si, 0, sizeof(STARTUPINFO));
memset(&pi, 0, sizeof(PROCESS_INFORMATION));
sprintf(buf, "0+%08X", shmid);
#ifdef MINGW_USE_XID
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[0])));
#else
sprintf(buf2, "%x", 0);
#endif
arglist[0] = "gtkwave.exe";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=1;i<split_point;i++)
{
arglist[i+4] = argv[i];
}
arglist[i+4] = NULL;
slen = 1;
for(idx=0;idx<i+4;idx++)
{
slen += strlen(arglist[idx]);
slen++;
}
mylist = calloc(1, slen);
for(idx=0;idx<i+4;idx++)
{
strcat(mylist, arglist[idx]);
strcat(mylist, " ");
}
si.cb = sizeof(si);
rc = CreateProcess(
arglist[0],
mylist,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi);
if(!rc)
{
fprintf(stderr, "Child 0 failed '%s' '%s'\n", arglist[0], mylist);
exit(255);
}
free(mylist);
free(arglist);
}
/* child 1 */
{
int idx;
int n_items = argc - split_point + 5;
int slen;
char **arglist = calloc(n_items, sizeof(char *));
char *mylist;
STARTUPINFO si;
PROCESS_INFORMATION pi;
BOOL rc;
memset(&si, 0, sizeof(STARTUPINFO));
memset(&pi, 0, sizeof(PROCESS_INFORMATION));
sprintf(buf, "1+%08X", shmid);
#ifdef MINGW_USE_XID
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[1])));
#else
sprintf(buf2, "%x", 0);
#endif
arglist[0] = "gtkwave.exe";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=split_point+1;i<argc;i++)
{
arglist[i-split_point+4] = argv[i];
}
i-=split_point;
arglist[i+4] = NULL;
slen = 1;
for(idx=0;idx<i+4;idx++)
{
slen += strlen(arglist[idx]);
slen++;
}
mylist = calloc(1, slen);
for(idx=0;idx<i+4;idx++)
{
strcat(mylist, arglist[idx]);
strcat(mylist, " ");
}
si.cb = sizeof(si);
rc = CreateProcess(
arglist[0],
mylist,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi);
if(!rc)
{
fprintf(stderr, "Child 1 failed '%s' '%s'\n", arglist[0], mylist);
exit(255);
}
free(mylist);
free(arglist);
}
for(;;)
{
Sleep(1000 / 5);
while (gtk_events_pending()) gtk_main_iteration();
if((!dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #1");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(!dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #2");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave");
break;
}
}
#ifdef MINGW_USE_XID
gtk_main();
#endif
}
}
#else
shmid = shmget(0, 2 * sizeof(struct gtkwave_dual_ipc_t), IPC_CREAT | 0600 );
if(shmid >=0)
{
struct shmid_ds ds;
dual_ctx = shmat(shmid, NULL, 0);
if(dual_ctx)
{
memset(dual_ctx, 0, 2 * sizeof(struct gtkwave_dual_ipc_t));
memcpy(&dual_ctx[0].matchword, DUAL_MATCHWORD, 4);
memcpy(&dual_ctx[1].matchword, DUAL_MATCHWORD, 4);
#ifdef __linux__
shmctl(shmid, IPC_RMID, &ds); /* mark for destroy */
#endif
if(fork())
{
if(fork())
{
struct timeval tv;
for(;;)
{
tv.tv_sec = 0;
tv.tv_usec = 1000000 / 5;
select(0, NULL, NULL, NULL, &tv);
while (gtk_events_pending()) gtk_main_iteration();
if((!dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #1");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(!dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #2");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave");
break;
}
}
#ifndef __linux__
while (gtk_events_pending()) gtk_main_iteration();
sleep(2);
shmctl(shmid, IPC_RMID, &ds); /* mark for destroy */
#endif
if(use_embedded)
{
gtk_main();
}
}
else
{
int n_items = split_point + 5;
char **arglist = calloc(n_items, sizeof(char *));
sprintf(buf, "0+%08X", shmid);
if(use_embedded)
{
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[0])));
}
else
{
sprintf(buf2, "%x", 0);
}
arglist[0] = "gtkwave";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=1;i<split_point;i++)
{
arglist[i+4] = argv[i];
}
arglist[i+4] = NULL;
execvp(arglist[0], arglist);
fprintf(stderr, "Child failed\n");
exit(255);
}
}
else
{
int n_items = argc - split_point + 5;
char **arglist = calloc(n_items, sizeof(char *));
sprintf(buf, "1+%08X", shmid);
if(use_embedded)
{
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[1])));
}
else
{
sprintf(buf2, "%x", 0);
}
arglist[0] = "gtkwave";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=split_point+1;i<argc;i++)
{
arglist[i-split_point+4] = argv[i];
}
i-=split_point;
arglist[i+4] = NULL;
execvp(arglist[0], arglist);
fprintf(stderr, "Child failed\n");
exit(255);
}
}
}
#endif
return(0);
}
static void
gimp_thumb_box_create_thumbnails (GimpThumbBox *box,
gboolean force)
{
Gimp *gimp = box->imagefile->gimp;
GimpProgress *progress = GIMP_PROGRESS (box);
GimpFileDialog *dialog = NULL;
GtkWidget *toplevel;
GSList *list;
gint n_uris;
gint i;
if (gimp->config->thumbnail_size == GIMP_THUMBNAIL_SIZE_NONE)
return;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (box));
if (GIMP_IS_FILE_DIALOG (toplevel))
dialog = GIMP_FILE_DIALOG (toplevel);
gimp_set_busy (gimp);
if (dialog)
gimp_file_dialog_set_sensitive (dialog, FALSE);
else
gtk_widget_set_sensitive (toplevel, FALSE);
if (box->uris)
{
gtk_widget_hide (box->info);
gtk_widget_show (box->progress);
}
n_uris = g_slist_length (box->uris);
if (n_uris > 1)
{
gchar *str;
gimp_progress_start (GIMP_PROGRESS (box), "", TRUE);
progress = gimp_sub_progress_new (GIMP_PROGRESS (box));
gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (progress), 0, n_uris);
for (list = box->uris->next, i = 1;
list;
list = g_slist_next (list), i++)
{
str = g_strdup_printf (_("Thumbnail %d of %d"), i, n_uris);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), str);
g_free (str);
gimp_progress_set_value (progress, 0.0);
while (gtk_events_pending ())
gtk_main_iteration ();
gimp_thumb_box_create_thumbnail (box,
list->data,
gimp->config->thumbnail_size,
force,
progress);
if (dialog && dialog->canceled)
goto canceled;
gimp_sub_progress_set_step (GIMP_SUB_PROGRESS (progress), i, n_uris);
}
str = g_strdup_printf (_("Thumbnail %d of %d"), n_uris, n_uris);
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), str);
g_free (str);
gimp_progress_set_value (progress, 0.0);
while (gtk_events_pending ())
gtk_main_iteration ();
}
if (box->uris)
{
gimp_thumb_box_create_thumbnail (box,
box->uris->data,
gimp->config->thumbnail_size,
force,
progress);
gimp_progress_set_value (progress, 1.0);
}
canceled:
if (n_uris > 1)
{
g_object_unref (progress);
gimp_progress_end (GIMP_PROGRESS (box));
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (box->progress), "");
}
if (box->uris)
{
gtk_widget_hide (box->progress);
gtk_widget_show (box->info);
}
if (dialog)
gimp_file_dialog_set_sensitive (dialog, TRUE);
else
gtk_widget_set_sensitive (toplevel, TRUE);
gimp_unset_busy (gimp);
}
void
splash_update(register_action_e action, const char *message, gpointer client_data)
{
GtkWidget *win;
GtkWidget *main_lb;
GtkWidget *prog_bar;
GtkWidget *percentage_lb;
gfloat percentage;
gulong ul_percentage;
gchar tmp[100];
const char *action_msg;
static gulong ul_sofar = 0;
static gulong ul_count = 0;
static register_action_e last_action = RA_NONE;
static GTimeVal cur_tv;
static GTimeVal next_tv = {0, 0};
win = (GtkWidget *)client_data;
if (win == NULL) return;
g_get_current_time(&cur_tv);
if (last_action == action && cur_tv.tv_sec <= next_tv.tv_sec && cur_tv.tv_usec <= next_tv.tv_usec && ul_sofar < ul_count - 1) {
/* Only update every splash_register_freq milliseconds */
ul_sofar++;
return;
}
memcpy(&next_tv, &cur_tv, sizeof(next_tv));
next_tv.tv_usec += info_update_freq * 1000;
if (next_tv.tv_usec >= 1000000) {
next_tv.tv_sec++;
next_tv.tv_usec -= 1000000;
}
if(last_action != action) {
/* the action has changed */
switch(action) {
case RA_DISSECTORS:
action_msg = "Initializing dissectors ...";
break;
case RA_LISTENERS:
action_msg = "Initializing tap listeners ...";
break;
case RA_REGISTER:
action_msg = "Registering dissector ...";
break;
case RA_PLUGIN_REGISTER:
action_msg = "Registering plugins ...";
break;
case RA_PYTHON_REGISTER:
action_msg = "Registering Python dissectors ...";
break;
case RA_HANDOFF:
action_msg = "Handing off dissector ...";
break;
case RA_PLUGIN_HANDOFF:
action_msg = "Handing off plugins ...";
break;
case RA_PYTHON_HANDOFF:
action_msg = "Handing off Python dissectors ...";
break;
case RA_LUA_PLUGINS:
action_msg = "Loading Lua plugins ...";
break;
case RA_PREFERENCES:
action_msg = "Loading module preferences ...";
break;
case RA_CONFIGURATION:
action_msg = "Loading configuration files ...";
break;
default:
action_msg = "(Unknown action)";;
break;
}
splash_update_label(win, action_msg);
last_action = action;
}
if(ul_count == 0) { /* get the count of dissectors */
ul_count = register_count() + 6; /* additional 6 for:
dissectors, listeners,
registering plugins, handingoff plugins,
preferences and configuration */
#ifdef HAVE_LUA_5_1
ul_count++; /* additional one for lua plugins */
#endif
#ifdef HAVE_PYTHON
ul_count += 2; /* additional 2 for python register and handoff */
#endif
}
main_lb = g_object_get_data(G_OBJECT(win), "protocol_label");
/* make_dissector_reg.py changed -
so we need to strip off the leading elements to get back to the protocol */
if(message) {
if(!strncmp(message, "proto_register_", 15))
message += 15;
else if(!strncmp(message, "proto_reg_handoff_", 18))
message += 18;
}
gtk_label_set_text(GTK_LABEL(main_lb), message ? message : "");
ul_sofar++;
g_assert (ul_sofar <= ul_count);
percentage = (gfloat)ul_sofar/(gfloat)ul_count;
ul_percentage = (gulong)(percentage * 100);
/* update progress bar */
prog_bar = g_object_get_data(G_OBJECT(win), "progress_bar");
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(prog_bar), percentage);
percentage_lb = g_object_get_data(G_OBJECT(win), "percentage_label");
g_snprintf(tmp, sizeof(tmp), "%lu%%", ul_percentage);
gtk_label_set_text((GtkLabel*)percentage_lb, tmp);
/* Process all pending GUI events before continuing, so that
the splash screen window gets updated. */
while (gtk_events_pending()) gtk_main_iteration();
}
void _gtk_loop()
{
while (gtk_events_pending()) {
gtk_main_iteration();
}
}
/**
* @brief Process all pending events.
*/
void gtkEvents(void)
{
while (gtk_events_pending())
gtk_main_iteration();
}
int main(int argc, char *argv[])
{
GtkWidget *window, *ok_but, *fix_but, *diag, *list, *scroll;
GtkAdjustment *adj;
product_component_t *component;
product_option_t *option;
product_file_t *file;
int removed = 0, modified = 0;
goto_installpath(argv[0]);
/* Set the locale */
init_locale();
if ( argc < 2 ) {
fprintf(stderr, _("Usage: %s product\n"), argv[0]);
return 1;
}
gtk_init(&argc,&argv);
argv0 = argv[0];
/* Initialize Glade */
glade_init();
check_glade = glade_xml_new("check.glade", "check_dialog");
/* Add all signal handlers defined in glade file */
glade_xml_signal_autoconnect(check_glade);
window = glade_xml_get_widget(check_glade, "check_dialog");
gtk_widget_realize(window);
while( gtk_events_pending() ) {
gtk_main_iteration();
}
diag = glade_xml_get_widget(check_glade, "diagnostic_label");
ok_but = glade_xml_get_widget(check_glade, "dismiss_button");
fix_but = glade_xml_get_widget(check_glade, "rescue_button");
list = glade_xml_get_widget(check_glade, "main_list");
scroll = glade_xml_get_widget(check_glade, "scrolledwindow");
product = loki_openproduct(argv[1]);
if ( ! product ) {
message_dialog(_("Impossible to locate the product information.\nMaybe another user installed it?"),
_("Error"));
return 1;
}
info = loki_getinfo_product(product);
gtk_label_set_text(GTK_LABEL(diag), "");
gtk_widget_set_sensitive(fix_but, FALSE);
adj = GTK_ADJUSTMENT(gtk_adjustment_new(100.0, 1.0, 100.0, 1.0, 10.0, 10.0));
gtk_scrolled_window_set_vadjustment(GTK_SCROLLED_WINDOW(scroll), adj);
/* Iterate through the components */
for ( component = loki_getfirst_component(product);
component;
component = loki_getnext_component(component) ) {
add_message(list, _("---> Checking component '%s'..."), loki_getname_component(component));
for ( option = loki_getfirst_option(component);
option;
option = loki_getnext_option(option) ) {
add_message(list, _("-> Checking option '%s'..."), loki_getname_option(option));
for ( file = loki_getfirst_file(option);
file;
file = loki_getnext_file(file) ) {
gtk_main_iteration();
switch ( loki_check_file(file) ) {
case LOKI_REMOVED:
add_message(list, _("%s was REMOVED"), loki_getpath_file(file));
removed ++;
add_corrupt_file(product, loki_getpath_file(file), loki_getname_option(option));
break;
case LOKI_CHANGED:
add_message(list, _("%s was MODIFIED"), loki_getpath_file(file));
modified ++;
add_corrupt_file(product, loki_getpath_file(file), loki_getname_option(option));
break;
case LOKI_OK:
add_message(list, _("%s is OK"), loki_getpath_file(file));
break;
}
}
}
}
if ( removed || modified ) {
char status[200];
snprintf(status, sizeof(status), _("Changes detected: %d files removed, %d files modified."),
removed, modified);
gtk_label_set_text(GTK_LABEL(diag), status);
gtk_widget_set_sensitive(fix_but, TRUE);
} else {
gtk_label_set_text(GTK_LABEL(diag), _("No problems were found."));
}
/* Run the UI.. */
gtk_main();
return 0;
}
static const gchar*
tny_gnome_keyring_password_getter_get_password (TnyPasswordGetter *self, const gchar *aid, const gchar *prompt, gboolean *cancel)
{
gchar *retval = NULL;
GList *list;
GnomeKeyringResult keyringret;
gchar *keyring;
gnome_keyring_get_default_keyring_sync (&keyring);
keyringret = gnome_keyring_find_network_password_sync (aid, "Mail",
aid /* hostname */,
"password", aid /* proto */,
"PLAIN", 0, &list);
if ((keyringret != GNOME_KEYRING_RESULT_OK) || (list == NULL))
{
gboolean canc = FALSE;
GnomePasswordDialog *dialog = GNOME_PASSWORD_DIALOG
(gnome_password_dialog_new
(_("Enter password"), prompt,
NULL,
NULL, TRUE));
gnome_password_dialog_set_domain (dialog, "Mail");
gnome_password_dialog_set_remember (dialog,
GNOME_PASSWORD_DIALOG_REMEMBER_FOREVER);
gnome_password_dialog_set_readonly_username (dialog, TRUE);
/* gnome_password_dialog_set_username (dialog,
tny_account_get_user (account)); */
gnome_password_dialog_set_show_username (dialog, FALSE);
gnome_password_dialog_set_show_remember (dialog,
gnome_keyring_is_available ());
gnome_password_dialog_set_show_domain (dialog, FALSE);
gnome_password_dialog_set_show_userpass_buttons (dialog, FALSE);
canc = gnome_password_dialog_run_and_block (dialog);
if (canc)
{
guint32 item_id;
GnomePasswordDialogRemember r;
retval = gnome_password_dialog_get_password (dialog);
mlock (retval, strlen (retval));
r = gnome_password_dialog_get_remember (dialog);
if (r == GNOME_PASSWORD_DIALOG_REMEMBER_FOREVER)
{
gnome_keyring_set_network_password_sync (keyring,
aid /* user */,
"Mail", aid /* hostname */,
"password", aid /* proto */,
"PLAIN", 0, retval, &item_id);
}
} else retval = NULL;
*cancel = (!canc);
/* this causes warnings, but should be done afaik */
gtk_object_destroy (GTK_OBJECT (dialog));
while (gtk_events_pending ())
gtk_main_iteration ();
} else {
GnomeKeyringNetworkPasswordData *pwd_data;
pwd_data = list->data;
retval = g_strdup (pwd_data->password);
*cancel = FALSE;
gnome_keyring_network_password_list_free (list);
}
return retval;
}
gint DeviceBoxOKEvent(GtkWidget *widget, GdkEvent event, gpointer data)
{
char templine[256];
u8 tempbuffer[2352];
struct IsoFile *tofile;
const char *tempdevice;
s32 retval;
cdvdTD cdvdtd;
int stop;
int compressmethod;
int multi;
int imagetype;
int i;
DeviceBoxUnfocus();
tempdevice = gtk_entry_get_text(GTK_ENTRY(devicebox.device));
strcpy(conf.devicename, tempdevice); // Temporarily put in new device name
tempdevice = NULL;
retval = DeviceOpen();
if (retval != 0)
{
DeviceClose();
MessageBoxShow("Could not open the device", 2);
return(TRUE);
} // ENDIF- Trouble opening device? Abort here.
DeviceTrayStatus();
retval = DiscInserted();
if (retval != 0)
{
DeviceClose();
MessageBoxShow("No disc in the device\r\nPlease put a disc in and try again.", 2);
return(TRUE);
} // ENDIF- Trouble opening device? Abort here.
retval = DeviceGetTD(0, &cdvdtd); // Fish for Ending Sector
if (retval < 0)
{
DeviceClose();
MessageBoxShow("Could not retrieve disc sector size", 2);
return(TRUE);
} // ENDIF- Trouble getting disc sector count?
compressmethod = gtk_combo_box_get_active(GTK_COMBO_BOX(devicebox.compress));
if (compressmethod > 0) compressmethod += 2;
multi = 0;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(devicebox.multi)) == TRUE)
multi = 1;
imagetype = 0;
if ((disctype != CDVD_TYPE_PS2DVD) &&
(disctype != CDVD_TYPE_DVDV)) imagetype = 8;
tofile = IsoFileOpenForWrite(gtk_entry_get_text(GTK_ENTRY(devicebox.file)),
imagetype,
multi,
compressmethod);
if (tofile == NULL)
{
DeviceClose();
MessageBoxShow("Could not create the new ISO file", 2);
return(TRUE);
} // ENDIF- Trouble opening the ISO file?
// Open Progress Bar
sprintf(templine, "%s -> %s",
gtk_entry_get_text(GTK_ENTRY(devicebox.device)), tofile->name);
ProgressBoxStart(templine, (off64_t) cdvdtd.lsn);
tofile->cdvdtype = disctype;
for (i = 0; i < 2048; i++) tofile->toc[i] = tocbuffer[i];
stop = 0;
mainbox.stop = 0;
progressbox.stop = 0;
while ((stop == 0) && (tofile->sectorpos < cdvdtd.lsn))
{
if (imagetype == 0)
{
retval = DeviceReadTrack((u32) tofile->sectorpos,
CDVD_MODE_2048,
tempbuffer);
}
else
{
retval = DeviceReadTrack((u32) tofile->sectorpos,
CDVD_MODE_2352,
tempbuffer);
} // ENDIF- Are we reading a DVD sector? (Or a CD sector?)
if (retval < 0)
{
for (i = 0; i < 2352; i++)
{
tempbuffer[i] = 0;
} // NEXT i- Zeroing the buffer
} // ENDIF- Trouble reading next block?
retval = IsoFileWrite(tofile, tempbuffer);
if (retval < 0)
{
MessageBoxShow("Trouble writing new file", 3);
stop = 1;
} // ENDIF- Trouble writing out the next block?
ProgressBoxTick(tofile->sectorpos);
while (gtk_events_pending()) gtk_main_iteration();
if (mainbox.stop != 0) stop = 2;
if (progressbox.stop != 0) stop = 2;
} // ENDWHILE- No reason found to stop...
ProgressBoxStop();
if (stop == 0)
{
if (tofile->multi == 1) tofile->name[tofile->multipos] = '0'; // First file
strcpy(templine, tofile->name);
} // ENDIF- Did we succeed with the transfer?
DeviceClose();
if (stop == 0)
{
IsoSaveTOC(tofile);
tofile = IsoFileClose(tofile);
gtk_entry_set_text(GTK_ENTRY(mainbox.file), templine);
}
else
{
tofile = IsoFileCloseAndDelete(tofile);
} // ENDIF- (Failed to complete writing file? Get rid of the garbage files.)
if (stop != 1) DeviceBoxRefocus();
if (stop == 0) DeviceBoxCancelEvent(widget, event, data);
return(TRUE);
} // END DeviceBoxOKEvent()
void VectorTableToDialog (vector_table_options_D *dialog, BUS_LAYOUT *bus_layout, int *sim_type, VectorTable *pvt)
{
GList *llCols = NULL, *llItr = NULL ;
int Nix ;
GtkTreeModel *model = NULL ;
GtkWidget *tbtn = NULL ;
GtkTreeViewColumn *col = NULL ;
if (NULL == dialog || NULL == sim_type || NULL == pvt) return ;
g_object_set_data (G_OBJECT (dialog->dialog), "user_sim_type", sim_type) ;
g_object_set_data (G_OBJECT (dialog->dialog), "user_pvt", pvt) ;
g_object_set_data (G_OBJECT (dialog->dialog), "user_bus_layout", bus_layout) ;
g_object_set_data (G_OBJECT (dialog->dialog), "idxVector", (gpointer)-1) ;
if (0 == bus_layout->inputs->icUsed)
(*sim_type) = EXHAUSTIVE_VERIFICATION ;
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (tbtn = (VECTOR_TABLE == (*sim_type) ? dialog->tbtnVT : dialog->tbtnExhaustive)), TRUE) ;
g_object_set_data (G_OBJECT (dialog->crActive), "pvt", pvt) ;
if (NULL != (model = GTK_TREE_MODEL (design_bus_layout_tree_store_new (bus_layout, ROW_TYPE_INPUT, 1, G_TYPE_BOOLEAN))))
{
gboolean bActive = FALSE ;
GtkTreeIter itr, itrChild ;
int row_type = -1, idx = -1 ;
QCADCell *cell = NULL ;
gboolean bBusActive = FALSE ;
// First reflect the active_flag of current cell inputs
if (gtk_tree_model_get_iter_first (model, &itr))
while (TRUE)
{
gtk_tree_model_get (model, &itr,
BUS_LAYOUT_MODEL_COLUMN_TYPE, &row_type,
BUS_LAYOUT_MODEL_COLUMN_CELL, &cell, -1) ;
if (ROW_TYPE_CELL_INPUT == row_type && NULL != cell)
if (-1 != (idx = VectorTable_find_input_idx (pvt, cell)))
gtk_tree_store_set (GTK_TREE_STORE (model), &itr,
VECTOR_TABLE_MODEL_COLUMN_ACTIVE, exp_array_index_1d (pvt->inputs, VT_INPUT, idx).active_flag, -1) ;
if (!gtk_tree_model_iter_next_dfs (model, &itr)) break ;
}
// For any given bus, if any of its cells are active, then the bus is active. Reflect this.
if (gtk_tree_model_get_iter_first (model, &itr))
while (TRUE)
{
bBusActive = FALSE ;
if (gtk_tree_model_iter_children (model, &itrChild, &itr))
{
while (TRUE)
{
gtk_tree_model_get (model, &itrChild, VECTOR_TABLE_MODEL_COLUMN_ACTIVE, &bActive, -1) ;
if ((bBusActive = bActive)) break ;
if (!gtk_tree_model_iter_next (model, &itrChild)) break ;
}
gtk_tree_store_set (GTK_TREE_STORE (model), &itr, VECTOR_TABLE_MODEL_COLUMN_ACTIVE, bBusActive, -1) ;
}
if (!gtk_tree_model_iter_next (model, &itr)) break ;
}
llCols = gtk_tree_view_get_columns (GTK_TREE_VIEW (dialog->tv)) ;
for (Nix = 0, llItr = llCols ; Nix < 2 && NULL != llItr ; Nix++, llItr = llItr->next) ;
for (; llItr != NULL ; llItr = llItr->next)
gtk_tree_view_remove_column (GTK_TREE_VIEW (dialog->tv), GTK_TREE_VIEW_COLUMN (llItr->data)) ;
g_list_free (llCols) ;
gtk_tree_view_set_model (GTK_TREE_VIEW (dialog->tv), model) ;
}
gtk_tree_view_expand_all (GTK_TREE_VIEW (dialog->tv)) ;
for (Nix = 0 ; Nix < pvt->vectors->icUsed ; Nix++)
{
if (NULL == col)
col = add_vector_to_dialog (dialog, pvt, Nix) ;
else
add_vector_to_dialog (dialog, pvt, Nix) ;
// Give the dialog a chance to update itself
if (0 == Nix % 10)
while (gtk_events_pending ())
gtk_main_iteration () ;
}
if (NULL != col)
gtk_tree_view_column_clicked (col) ;
if (!gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (tbtn)))
vector_table_options_dialog_btnSimType_clicked (tbtn, dialog) ;
vector_table_options_dialog_reflect_state (dialog) ;
}
static void do_test_webkit_web_view_adjustments(gboolean with_page_cache)
{
char* effective_uri = g_strconcat(base_uri, "bigdiv.html", NULL);
char* second_uri = g_strconcat(base_uri, "iframe.html", NULL);
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget* scrolled_window = gtk_scrolled_window_new(NULL, NULL);
WebKitWebView* view = WEBKIT_WEB_VIEW(webkit_web_view_new());
GtkAdjustment* adjustment;
double lower;
double upper;
if (with_page_cache) {
WebKitWebSettings* settings = webkit_web_view_get_settings(view);
g_object_set(settings, "enable-page-cache", TRUE, NULL);
}
gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
gtk_container_add(GTK_CONTAINER(window), scrolled_window);
gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(view));
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
loop = g_main_loop_new(NULL, TRUE);
g_object_connect(G_OBJECT(view),
"signal::notify::load-status", idle_quit_loop_cb, NULL,
NULL);
/* Wait for window to show up */
gtk_widget_show_all(window);
g_signal_connect(window, "map-event",
G_CALLBACK(map_event_cb), loop);
g_main_loop_run(loop);
/* Load a page with a big div that will cause scrollbars to appear */
webkit_web_view_load_uri(view, effective_uri);
g_main_loop_run(loop);
/* Adjustments update asynchronously, so we must wait a bit. */
g_timeout_add(100, quit_after_short_delay_cb, loop);
g_main_loop_run(loop);
adjustment = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scrolled_window));
g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 0.0);
lower = gtk_adjustment_get_lower(adjustment);
upper = gtk_adjustment_get_upper(adjustment);
/* Scroll the view using JavaScript */
webkit_web_view_execute_script(view, "window.scrollBy(0, 100)");
/* Adjustments update asynchronously, so we must wait a bit. */
g_timeout_add(100, quit_after_short_delay_cb, loop);
g_main_loop_run(loop);
/* Make sure the ScrolledWindow noticed the scroll */
g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 100.0);
/* Load a second URI */
webkit_web_view_load_uri(view, second_uri);
g_main_loop_run(loop);
/* The page loaded but the adjustments may not be updated yet. Wait a bit. */
g_timeout_add(100, quit_after_short_delay_cb, loop);
g_main_loop_run(loop);
/* Make sure the scrollbar has been reset */
g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 0.0);
/* Go back */
webkit_web_view_go_back(view);
/* When using page cache, go_back will return syncronously */
if (!with_page_cache)
g_main_loop_run(loop);
/* Make sure GTK+ has time to process the changes in size, for the adjusments */
while (gtk_events_pending())
gtk_main_iteration();
/* Make sure upper and lower bounds have been restored correctly */
g_assert_cmpfloat(lower, ==, gtk_adjustment_get_lower(adjustment));
g_assert_cmpfloat(upper, ==, gtk_adjustment_get_upper(adjustment));
g_assert_cmpfloat(gtk_adjustment_get_value(adjustment), ==, 100.0);
g_free(effective_uri);
g_free(second_uri);
gtk_widget_destroy(window);
}
/* Refreshes the diagram. Called each refresh_period ms
* 1. Checks for new protocols and displays them
* 2. Updates nodes looks
* 3. Updates links looks
*/
guint update_diagram(GtkWidget * canvas)
{
static struct timeval last_refresh_time = { 0, 0 };
double diffms;
enum status_t status;
/* if requested and enabled, dump to xml */
if (appdata.request_dump && appdata.export_file_signal)
{
g_warning (_("SIGUSR1 received: exporting to %s"), appdata.export_file_signal);
dump_xml(appdata.export_file_signal);
appdata.request_dump = FALSE;
}
status = get_capture_status();
if (status == PAUSE)
return FALSE;
if (status == CAP_EOF)
{
gui_eof_capture ();
return FALSE;
}
/*
* It could happen that during an intensive calculation, in order
* to update the GUI and make the application responsive gtk_main_iteration
* is called. But that could also trigger this very function's timeout.
* If we let it run twice many problems could come up. Thus,
* we are preventing it with the already_updating variable
*/
if (already_updating)
{
g_my_debug ("update_diagram called while already updating");
return FALSE;
}
already_updating = TRUE;
gettimeofday (&appdata.now, NULL);
/* update nodes */
diagram_update_nodes(canvas);
/* update links */
diagram_update_links(canvas);
/* Update protocol information */
protocol_summary_update_all();
/* update proto legend */
update_legend();
/* Now update info windows */
update_info_windows ();
/* With this we make sure that we don't overload the
* CPU with redraws */
if ((last_refresh_time.tv_sec == 0) && (last_refresh_time.tv_usec == 0))
last_refresh_time = appdata.now;
/* Force redraw */
while (gtk_events_pending ())
gtk_main_iteration ();
gettimeofday (&appdata.now, NULL);
diffms = substract_times_ms(&appdata.now, &last_refresh_time);
last_refresh_time = appdata.now;
already_updating = FALSE;
if (!is_idle)
{
if (diffms > pref.refresh_period * 1.2)
return FALSE; /* Removes the timeout */
}
else
{
if (diffms < pref.refresh_period)
return FALSE; /* removes the idle */
}
if (stop_requested)
gui_stop_capture();
return TRUE; /* Keep on calling this function */
} /* update_diagram */
void ZLGtkApplicationWindow::processAllEvents() {
while (gtk_events_pending()) {
gtk_main_iteration();
}
}
int main(int argc, char *argv[])
{
setlocale (LC_ALL, "");
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
textdomain (GETTEXT_PACKAGE);
gboolean explicit_username = FALSE;
gboolean explicit_message = FALSE;
int error = 0;
int m = 0, i = 1;
guint counter = 0;
gchar *command = NULL;
gchar *command_run = NULL;
gchar *username = NULL;
gchar *password = NULL;
uid_t whoami;
struct passwd *pw;
char err_msg[256];
gchar *message = NULL;
char **cmd_argv = NULL;
GError *cmd_error = NULL;
GtkWidget *dialog;
GtkSizeGroup *sizegroup;
GtkWidget *hbox;
GtkWidget *image;
GtkWidget *align;
GtkWidget *label;
GtkWidget *user;
GtkWidget *pass;
gtk_init(&argc, &argv);
/* Parse arguments */
while (i < argc) {
if (argv[i][0] != '-')
break;
if (!strcmp(argv[i], "--help") || !strcmp(argv[i], "-h"))
say_help(argv[0]);
if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v"))
say_about();
if (!strcmp(argv[i], "--user") || !strcmp(argv[i], "-u")) {
if ((username = argv[i + 1]) == NULL)
Werror(ERR_MISSING_USER_AND_COMMAND, NULL, 1, 1);
explicit_username = TRUE;
i += 1;
}
if (!strcmp(argv[i], "--message") || !strcmp(argv[i], "-m")) {
if ((message = argv[i + 1]) == NULL)
Werror(ERR_MISSING_MESSAGE_AND_COMMAND, NULL, 1, 1);
explicit_message = TRUE;
i += 1;
}
i += 1;
}
if (argv[i] == NULL)
Werror(ERR_MISSING_COMMAND, NULL, 1, 1);
/* handle arguments and spaces in the subcommand correctly */
if (! g_shell_parse_argv(argv[i], NULL, &cmd_argv, &cmd_error))
/* Something bad has happened */
Werror(ERR_INVALID_COMMAND, cmd_error->message, 1, 1);
/* Get the full path command */
command = get_real_name(cmd_argv[0]);
if (command == NULL)
Werror(ERR_INVALID_COMMAND, cmd_argv[0], 1, 1);
/* Sanity check */
whoami = getuid();
if ((pw = getpwuid(whoami)) == NULL)
exit(2 + 0 * fprintf(stderr, "Who you think you are? Houdini?\n"));
if (!explicit_username)
username = g_strdup("root");
if (username && !strcmp(pw->pw_name, username)) {
/* username was me so let's just run it and get the hell out */
if (execvp(command, &(cmd_argv[0])) == -1) {
Werror(ERR_PERMISSION_DENIED, NULL, 1, 1);
exit(1);
}
/* We should never get here, but just in case */
exit(0);
}
if (explicit_username && !explicit_message)
message = g_strdup_printf(gettext("Please enter the\npassword for %s:"), username);
else if (!explicit_message)
message = g_strdup(gettext("Please enter the desired\nusername and password:"******"ktsuss");
gtk_container_set_border_width(GTK_CONTAINER(dialog), 5);
gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), 5);
gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), 5);
hbox = gtk_hbox_new(FALSE, 6);
#if GTK_CHECK_VERSION(2, 10, 0)
image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
#else
image = gtk_image_new_from_icon_name("ktsuss", GTK_ICON_SIZE_DIALOG);
#endif
gtk_box_pack_start(GTK_BOX(hbox), image, FALSE, FALSE, 0);
label = gtk_label_new(message);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
if (!explicit_username) {
hbox = gtk_hbox_new(FALSE, 6);
label = gtk_label_new(gettext("Username"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_size_group_add_widget(sizegroup, align);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, FALSE, 0);
user = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(user), username ? username : "******");
gtk_box_pack_start(GTK_BOX(hbox), user, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
}
hbox = gtk_hbox_new(FALSE, 6);
label = gtk_label_new(gettext("Password"));
align = gtk_alignment_new(0, 0.5, 0, 0);
gtk_container_add(GTK_CONTAINER(align), label);
gtk_size_group_add_widget(sizegroup, align);
gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, FALSE, 0);
pass = gtk_entry_new_with_max_length(32);
gtk_entry_set_visibility(GTK_ENTRY(pass), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), pass, FALSE, FALSE, 0);
gtk_entry_set_activates_default(GTK_ENTRY(pass), TRUE);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), hbox);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_widget_grab_focus(pass);
gtk_widget_show_all(GTK_DIALOG(dialog)->vbox);
/* Show the dialog up to 3 times */
while (counter < 3) {
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) {
if (!explicit_username)
username = strdup(gtk_entry_get_text(GTK_ENTRY(user)));
password = strdup(gtk_entry_get_text(GTK_ENTRY(pass)));
#ifdef SUDOPATH
if ((error = check_password_sudo(username, password)) == ERR_SUCCESS) {
#else
if ((error = check_password_su(username, password)) == ERR_SUCCESS) {
#endif
gtk_widget_destroy(dialog);
while (gtk_events_pending())
gtk_main_iteration();
dialog = NULL;
/* using argv instead of cmd_argv is fine, because 'su' is going
* to implement its only parsing nevertheless */
command_run = g_strjoinv(" ", &argv[i]);
#ifdef SUDOPATH
run_sudo(username, password, command_run);
#else
run_su(username, password, command_run);
#endif
g_free(command_run);
counter = 3;
}
if (!explicit_username) {
free(username);
username = NULL;
}
memset(password, '\0', strlen(password));
free(password);
if (error != ERR_SUCCESS) {
snprintf(err_msg, sizeof(err_msg), gettext("Could not run '%s'"), command);
Werror(error, err_msg, 0, 0);
counter++;
}
}
else
break;
if (counter < 3)
gtk_widget_grab_focus(pass);
}
/* Clean up process */
if (dialog)
gtk_widget_destroy(dialog);
if ((explicit_username && !explicit_message) || !explicit_message)
free(message);
if (!explicit_username && username)
g_free(username);
g_strfreev(cmd_argv);
if (cmd_error)
g_error_free(cmd_error);
return 0;
}
