GtkWidget* webkit_view___::webview_new__(GtkWidget* scrolled) {
GtkWidget* webview = webkit_web_view_new ();
//g_object_ref_sink(webview);
gtk_object_set_data(GTK_OBJECT(webview),object_data_view_,(gpointer)this);
if(scrolled) {
gtk_object_set_data(GTK_OBJECT(webview),object_data_scrolled_,(gpointer)scrolled);
//gtk_container_add (GTK_CONTAINER (scrolled), webview);
GtkWidget* scrolled2 = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled2), webview);
gtk_container_add (GTK_CONTAINER (scrolled), scrolled2);
outer_scrolled_ = scrolled2;
if(is_app_paintable_) {
webkit_web_view_set_transparent(WEBKIT_WEB_VIEW(webview), true);
}
g_signal_connect(webview,"window-object-cleared",G_CALLBACK(window_object_cleared__),NULL);
g_object_connect(G_OBJECT(webview),
"signal::geolocation-policy-decision-requested",
geolocation_policy_decision_requested__, 0, NULL);
signal_connect__(webview);
}
if(!user_agent_.empty()) {
WebKitWebSettings* wws=webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webview));
WebKitWebSettings* wws2=webkit_web_settings_copy(wws);
g_object_set((GObject*)wws2, "user-agent", user_agent_.c_str(), NULL);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webview), wws2);
}
return webview;
}
/**
* This toogles the background of the window
**/
static void
toogleBackground (void)
{
printf("%s > \n", __func__);
static gboolean isTransparent = false;
isTransparent = !isTransparent;
webkit_web_view_set_transparent(g_web_view, isTransparent);
}
void wk_html_open_stream(WkHtml *html, const gchar *mime)
{
wk_html_set_base_uri(html, NULL);
#ifndef USE_WEBKIT2
webkit_web_view_set_transparent(WEBKIT_WEB_VIEW(html), TRUE);
#endif
html->priv->frames_enabled = FALSE;
g_free(html->priv->content);
html->priv->content = NULL;
g_free(html->priv->mime);
html->priv->mime = g_strdup(mime);
}
int main(int argc, char* argv[]) {
gtk_init(&argc, &argv);
if (argc == 1) {
printf("Usage: URI\n");
return 1;
}
const char *uri = argv[1];
if(!g_thread_supported())
g_thread_init(NULL);
// Create a Window, set colormap to RGBA
GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkScreen *screen = gtk_widget_get_screen(window);
#if GTK_CHECK_VERSION(3, 0, 0)
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
if (visual && gdk_screen_is_composited (screen)) {
gtk_widget_set_visual(GTK_WIDGET(window), visual);
}
#else
GdkColormap *rgba = gdk_screen_get_rgba_colormap (screen);s
if (rgba && gdk_screen_is_composited (screen)) {
gtk_widget_set_default_colormap(rgba);
gtk_widget_set_default_colormap(rgba);
}
#endif
gtk_window_set_default_size(GTK_WINDOW(window), 600, 400);
g_signal_connect(window, "destroy", G_CALLBACK(destroy_cb), NULL);
// Optional: for dashboard style borderless windows
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
// Create a WebView, set it transparent, add it to the window
WebKitWebView* web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
webkit_web_view_set_transparent(web_view, TRUE);
gtk_container_add (GTK_CONTAINER(window), GTK_WIDGET(web_view));
// Load a default page
webkit_web_view_load_uri(web_view, uri);
// Show it and continue running until the window closes
gtk_widget_grab_focus(GTK_WIDGET(web_view));
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static GtkScrolledWindow*
create_browser ()
{
scrolled_window = (GtkScrolledWindow*)gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
g_web_view = WEBKIT_WEB_VIEW (webkit_web_view_new ());
webkit_web_view_set_transparent(g_web_view, true);
gtk_container_add (GTK_CONTAINER (scrolled_window), GTK_WIDGET (g_web_view));
webkit_web_view_set_full_content_zoom(g_web_view, true);
g_signal_connect (g_web_view, "notify::load-status", G_CALLBACK (notify_load_status_cb), g_web_view);
g_signal_connect (g_web_view, "hovering-over-link", G_CALLBACK (link_hover_cb), g_web_view);
g_signal_connect (g_web_view, "focus-out-event", G_CALLBACK (focus_out_cb), g_web_view);
g_signal_connect (g_web_view, "document-load-finished", G_CALLBACK (document_load_finished_cb), g_web_view);
g_signal_connect (g_web_view, "window_object_cleared", G_CALLBACK (window_object_cleared_cb), g_web_view);
return scrolled_window;
}
int main(int argc, char* argv[])
{
// Initialize GTK+
gtk_init(&argc, &argv);
gdk_threads_init();
GtkWidget *main_window;
GdkWindow *gdk_window;
createDrawContext(&main_window, &gdk_window);
// Create a browser instance
WebKitWebView *webView = WEBKIT_WEB_VIEW(webkit_web_view_new());
// make sure the background of the main window is black plz
GdkColor blaaack;
gdk_color_parse("#000000", &blaaack);
gtk_widget_modify_bg(main_window, GTK_STATE_NORMAL, &blaaack);
// Put the browser area into the main window
gtk_container_add(GTK_CONTAINER(main_window), GTK_WIDGET(webView));
// necessary for ensuring positioning relative to xscreensaver-demo is right
gtk_widget_show_all(main_window);
// Set up callbacks so that if either the main window or the browser instance is
// closed, the program will exit
g_signal_connect(main_window, "destroy", G_CALLBACK(destroyWindow), NULL);
g_signal_connect(main_window, "delete-event", G_CALLBACK(destroyWindow), NULL);
// transparent background so we dont have any white flashes
webkit_web_view_set_transparent(webView, true);
int height;
int width;
gdk_window_get_geometry(gdk_window, NULL, NULL, &width, &height, NULL);
if (height < 480 && width < 640) {
// make the tiny preview windows look reasonable
webkit_web_view_set_full_content_zoom(webView, true);
webkit_web_view_set_zoom_level(webView, 0.4);
}
// set up some webkit settings
WebKitWebSettings *settings = webkit_web_view_get_settings(webView);
g_object_set (G_OBJECT(settings), "enable-webgl", true, NULL);
// accelerated-compositing chokes on my machine, but maybe its my shitty nvidia drivers
g_object_set (G_OBJECT(settings), "enable-accelerated-compositing", false, NULL);
// select tag and format url
wordexp_t exp_result;
wordexp(CONFIG_PATH, &exp_result, 0);
printf("Loading tags file at %s\n", exp_result.we_wordv[0]);
char* tags_path = exp_result.we_wordv[0];
char url[MAX_URL_LENGTH];
char tags[MAX_NUMBER_TAGS][MAX_TAG_LENGTH];
int tags_length = 0;
FILE* tags_file;
if (tags_path == NULL || (tags_file = fopen(tags_path, "r")) == NULL) {
printf("No tag file found. using defaults\n");
int default_tags_length = sizeof(DEFAULT_TAGS) / sizeof(char*);
for (int i = 0; i < default_tags_length; ++i) {
printf("%d\n", i);
strcpy(tags[i], DEFAULT_TAGS[i]);
}
tags_length = default_tags_length;
} else {
int i = 0;
printf("Iterating through file\n");
while (i < MAX_NUMBER_TAGS && fgets(tags[i], sizeof(tags[0]), tags_file)) {
tags[i][strlen(tags[i]) - 1] = '\0';
printf("Got %s!\n", tags[i]);
++i;
}
tags_length = i;
}
printf("%d tags found. selecting one.\n", tags_length);
srand(time(0));
int index = rand() % tags_length;
printf("%d is our index...\n", index);
printf("%s selected!\n", tags[index]);
sprintf(url, URL_FORMAT, tags[index]);
printf("Loading %s\n", url);
webkit_web_view_load_uri(webView, url);
// Make sure that when the browser area becomes visible, it will get mouse
// and keyboard events
gtk_widget_grab_focus(GTK_WIDGET(webView));
// hit our callback whenever load-status changes
g_signal_connect(G_OBJECT(webView), "notify::load-status", G_CALLBACK(load_status_cb), &url);
g_signal_connect(G_OBJECT(webView), "load-error", G_CALLBACK(load_error_cb), &url);
// Run the main GTK+ event loop
gtk_main();
return 0;
}
Client *
newclient(void) {
Client *c;
WebKitWebSettings *settings;
WebKitWebFrame *frame;
GdkGeometry hints = { 1, 1 };
char *uri, *ua;
if(!(c = calloc(1, sizeof(Client))))
die("Cannot malloc!\n");
/* Window */
if(embed) {
c->win = gtk_plug_new(embed);
}
else {
c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
/* TA: 20091214: Despite what the GNOME docs say, the ICCCM
* is always correct, so we should still call this function.
* But when doing so, we *must* differentiate between a
* WM_CLASS and a resource on the window. By convention, the
* window class (WM_CLASS) is capped, while the resource is in
* lowercase. Both these values come as a pair.
*/
gtk_window_set_wmclass(GTK_WINDOW(c->win), "surf", "surf");
/* TA: 20091214: And set the role here as well -- so that
* sessions can pick this up.
*/
gtk_window_set_role(GTK_WINDOW(c->win), "Surf");
}
gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(destroywin), c);
g_signal_connect(G_OBJECT(c->win), "key-press-event", G_CALLBACK(keypress), c);
g_signal_connect(G_OBJECT(c->win), "size-allocate", G_CALLBACK(resize), c);
/* VBox */
c->vbox = gtk_vbox_new(FALSE, 0);
/* Scrolled Window */
c->scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(c->scroll),
GTK_POLICY_NEVER, GTK_POLICY_NEVER);
/* Webview */
c->view = WEBKIT_WEB_VIEW(webkit_web_view_new());
g_signal_connect(G_OBJECT(c->view), "button-press-event", G_CALLBACK(buttonevent), c);
g_signal_connect(G_OBJECT(c->view), "title-changed", G_CALLBACK(titlechange), c);
g_signal_connect(G_OBJECT(c->view), "hovering-over-link", G_CALLBACK(linkhover), c);
g_signal_connect(G_OBJECT(c->view), "create-web-view", G_CALLBACK(createwindow), c);
g_signal_connect(G_OBJECT(c->view), "new-window-policy-decision-requested", G_CALLBACK(decidewindow), c);
g_signal_connect(G_OBJECT(c->view), "mime-type-policy-decision-requested", G_CALLBACK(decidedownload), c);
g_signal_connect(G_OBJECT(c->view), "window-object-cleared", G_CALLBACK(windowobjectcleared), c);
g_signal_connect(G_OBJECT(c->view), "notify::load-status", G_CALLBACK(loadstatuschange), c);
g_signal_connect(G_OBJECT(c->view), "notify::progress", G_CALLBACK(progresschange), c);
g_signal_connect(G_OBJECT(c->view), "download-requested", G_CALLBACK(initdownload), c);
/* Indicator */
c->indicator = gtk_drawing_area_new();
gtk_widget_set_size_request(c->indicator, 0, 2);
g_signal_connect (G_OBJECT (c->indicator), "expose_event",
G_CALLBACK (exposeindicator), c);
/* Arranging */
gtk_container_add(GTK_CONTAINER(c->scroll), GTK_WIDGET(c->view));
gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
gtk_container_add(GTK_CONTAINER(c->vbox), c->scroll);
gtk_container_add(GTK_CONTAINER(c->vbox), c->indicator);
/* Setup */
gtk_box_set_child_packing(GTK_BOX(c->vbox), c->indicator, FALSE, FALSE, 0, GTK_PACK_START);
gtk_box_set_child_packing(GTK_BOX(c->vbox), c->scroll, TRUE, TRUE, 0, GTK_PACK_START);
gtk_widget_grab_focus(GTK_WIDGET(c->view));
gtk_widget_show(c->vbox);
gtk_widget_show(c->indicator);
gtk_widget_show(c->scroll);
gtk_widget_show(GTK_WIDGET(c->view));
gtk_widget_show(c->win);
gtk_window_set_geometry_hints(GTK_WINDOW(c->win), NULL, &hints, GDK_HINT_MIN_SIZE);
gdk_window_set_events(GTK_WIDGET(c->win)->window, GDK_ALL_EVENTS_MASK);
gdk_window_add_filter(GTK_WIDGET(c->win)->window, processx, c);
webkit_web_view_set_full_content_zoom(c->view, TRUE);
frame = webkit_web_view_get_main_frame(c->view);
runscript(frame, webkit_web_frame_get_global_context(frame));
settings = webkit_web_view_get_settings(c->view);
if(!(ua = getenv("SURF_USERAGENT")))
ua = useragent;
g_object_set(G_OBJECT(settings), "user-agent", ua, NULL);
uri = g_strconcat("file://", stylefile, NULL);
g_object_set(G_OBJECT(settings), "user-stylesheet-uri", uri, NULL);
g_object_set(G_OBJECT(settings), "auto-load-images", loadimage, NULL);
g_object_set(G_OBJECT(settings), "enable-plugins", plugin, NULL);
g_object_set(G_OBJECT(settings), "enable-scripts", script, NULL);
g_object_set(G_OBJECT(settings), "enable-spatial-navigation", true, NULL);
g_free(uri);
setatom(c, AtomFind, "");
setatom(c, AtomUri, "about:blank");
if(NOBACKGROUND)
webkit_web_view_set_transparent(c->view, TRUE);
c->title = NULL;
c->next = clients;
clients = c;
if(showxid) {
gdk_display_sync(gtk_widget_get_display(c->win));
printf("%u\n", (guint)GDK_WINDOW_XID(GTK_WIDGET(c->win)->window));
fflush(NULL);
}
return c;
}
int main( int argc,
char *argv[] )
{
/* GtkWidget is the storage type for widgets */
GtkWidget *window;
GtkWidget *menubar;
time_t now;
struct tm *tm;
GThread *gth = NULL; /* thread id */
gboolean run_flag = TRUE; /* used as exit flag for threads */
int i;
putenv("UBUNTU_MENUPROXY=");
//init_trees();
gdk_color_parse("#FFFF00", &color_yellow);
gdk_color_parse("#FFFFFF", &color_white);
gdk_color_parse("#404040", &color_grey);
gdk_color_parse("#00FF00", &color_green);
gdk_color_parse("#007700", &color_darkgreen);
gdk_color_parse("#0000FF", &color_blue);
gdk_color_parse("#FF0000", &color_red);
gdk_color_parse("#770000", &color_darkred);
gdk_color_parse("#000000", &color_black);
font = pango_font_description_from_string("Sans bold 12");
#ifdef WIN32
installation_dir = g_win32_get_package_installation_directory_of_module(NULL);
#else
gbr_init(NULL);
installation_dir = gbr_find_prefix(NULL);
#endif
program_path = argv[0];
current_directory[0] = 0;
if (current_directory[0] == 0)
strcpy(current_directory, ".");
conffile = g_build_filename(g_get_user_data_dir(), "judoproxy.ini", NULL);
/* create video download dir */
video_dir = g_build_filename(g_get_home_dir(), "rpivideos", NULL);
g_print("Video dir = %s\n", video_dir);
g_mkdir_with_parents(video_dir, 0755);
keyfile = g_key_file_new();
g_key_file_load_from_file(keyfile, conffile, 0, NULL);
now = time(NULL);
tm = localtime(&now);
current_year = tm->tm_year+1900;
srand(now); //srandom(now);
my_address = now + getpid()*10000;
gtk_init (&argc, &argv);
main_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(main_window), "JudoProxy");
gtk_widget_set_size_request(window, FRAME_WIDTH, FRAME_HEIGHT);
gchar *iconfile = g_build_filename(installation_dir, "etc", "judoproxy.png", NULL);
gtk_window_set_default_icon_from_file(iconfile, NULL);
g_free(iconfile);
g_signal_connect (G_OBJECT (window), "delete_event",
G_CALLBACK (delete_event), NULL);
g_signal_connect (G_OBJECT (window), "destroy",
G_CALLBACK (destroy), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
main_vbox = gtk_grid_new();
gtk_container_set_border_width (GTK_CONTAINER (main_vbox), 1);
gtk_container_add (GTK_CONTAINER (window), main_vbox);
gtk_widget_show(main_vbox);
/* menubar */
menubar = get_menubar_menu(window);
gtk_widget_show(menubar);
gtk_grid_attach(GTK_GRID(main_vbox), menubar, 0, 0, 1, 1);
gtk_widget_set_hexpand(menubar, TRUE);
/* judoka info */
//name_box = gtk_label_new("?");
//gtk_box_pack_start(GTK_BOX(main_vbox), name_box, FALSE, TRUE, 0);
//GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
//gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, TRUE, 0);
notebook = gtk_notebook_new();
gtk_notebook_set_scrollable(GTK_NOTEBOOK(notebook), TRUE);
gtk_widget_set_hexpand(notebook, TRUE);
//gtk_widget_set_vexpand(notebook, TRUE);
gtk_notebook_set_tab_pos(GTK_NOTEBOOK(notebook), GTK_POS_TOP);
/*
GtkWidget *camera_table = gtk_grid_new();
gtk_grid_set_column_spacing(GTK_GRID(camera_table), 10);
gtk_grid_set_row_spacing(GTK_GRID(camera_table), 10);
*/
for (i = 0; i < NUM_TATAMIS; i++) {
gchar buf[32];
GtkWidget *data_table = gtk_grid_new();
connections[i].scrolled_window = data_table;
//connections[i].scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(connections[i].scrolled_window), 10);
snprintf(buf, sizeof(buf), "T%d [--]", i+1);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), connections[i].scrolled_window,
gtk_label_new(buf));
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("Camera")), 0, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(_("JudoTimer")), 4, 0, 2, 1);
GtkWidget *reload = gtk_button_new_with_label(_("Reload"));
gtk_grid_attach(GTK_GRID(data_table), reload, 0, 1, 1, 1);
connections[i].in_addr = gtk_entry_new();
connections[i].out_addr = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(connections[i].in_addr), 15);
gtk_entry_set_width_chars(GTK_ENTRY(connections[i].out_addr), 15);
gtk_grid_attach(GTK_GRID(data_table), connections[i].in_addr, 2, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), connections[i].out_addr, 6, 0, 2, 1);
gtk_grid_attach(GTK_GRID(data_table), gtk_label_new(" "), 0, 1, 1, 1);
//gtk_container_add(GTK_CONTAINER(connections[i].scrolled_window), data_table);
g_signal_connect (connections[i].out_addr, "activate",
G_CALLBACK(enter_callback),
gint_to_ptr(i));
g_signal_connect (connections[i].in_addr, "activate",
G_CALLBACK(camera_ip_enter_callback),
gint_to_ptr(i));
#ifdef WEBKIT
g_signal_connect (reload, "clicked",
G_CALLBACK(reload_web),
gint_to_ptr(i));
#else
g_signal_connect (reload, "clicked",
G_CALLBACK(select_camera_video),
gint_to_ptr(i));
#endif
}
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), 0);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), notebook, NULL, GTK_POS_BOTTOM, 1, 1);
progress_bar = gtk_progress_bar_new();
gtk_grid_attach_next_to(GTK_GRID(main_vbox), progress_bar, NULL, GTK_POS_BOTTOM, 1, 1);
GtkWidget *w = GTK_WIDGET(gtk_scrolled_window_new(NULL, NULL));
#ifdef WEBKIT
web_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
webkit_web_view_set_transparent(web_view, TRUE);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(web_view));
gtk_widget_set_vexpand(GTK_WIDGET(web_view), TRUE);
WebKitWebSettings *web_settings = webkit_web_settings_new();
//g_object_set(G_OBJECT(web_settings), "enable-java-applet", FALSE, NULL);
//g_object_set(G_OBJECT(web_settings), "enable-plugins", FALSE, NULL);
webkit_web_view_set_settings(web_view, web_settings);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1);
gtk_widget_grab_focus(GTK_WIDGET(web_view));
//webkit_web_view_load_uri(web_view, "http://www.hs.fi");
webkit_web_view_load_uri(web_view, "http://www.quirksmode.org/html5/tests/video.html");
g_signal_connect(web_view, "download-requested", G_CALLBACK(download_req), NULL);
//g_signal_connect(web_view, "load-changed", G_CALLBACK(load_changed), NULL);
#else
/* HTML page */
html_page = create_html_page();
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(html_page), NULL, GTK_POS_BOTTOM, 1, 1);
/* Video display */
camera_image = gtk_image_new();
gtk_widget_set_size_request(GTK_WIDGET(camera_image), 640, 360);
GtkWidget *event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(event_box), camera_image);
gtk_widget_set_events(event_box, gtk_widget_get_events(event_box) |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
/*GDK_POINTER_MOTION_MASK |*/
GDK_POINTER_MOTION_HINT_MASK |
GDK_BUTTON_MOTION_MASK);
g_signal_connect(G_OBJECT(event_box),
"button_press_event",
G_CALLBACK(button_press_callback),
camera_image);
g_signal_connect(G_OBJECT(event_box),
"button_release_event",
G_CALLBACK(button_release_callback),
camera_image);
g_signal_connect(G_OBJECT(event_box),
"motion-notify-event",
G_CALLBACK(button_notify_callback),
camera_image);
gtk_widget_show(camera_image);
gtk_container_add(GTK_CONTAINER(w), GTK_WIDGET(event_box));
gtk_widget_set_vexpand(GTK_WIDGET(event_box), TRUE);
gtk_widget_set_hexpand(GTK_WIDGET(event_box), TRUE);
gtk_widget_set_vexpand(GTK_WIDGET(camera_image), TRUE);
gtk_widget_set_hexpand(GTK_WIDGET(camera_image), TRUE);
gtk_grid_attach_next_to(GTK_GRID(main_vbox), GTK_WIDGET(w), NULL, GTK_POS_BOTTOM, 1, 1);
#endif
/* timers */
timer = g_timer_new();
gtk_widget_show_all(window);
set_preferences();
change_language(NULL, NULL, gint_to_ptr(language));
open_comm_socket();
scan_interfaces();
/* Create a bg thread using glib */
gpointer proxy_ssdp_thread(gpointer args);
g_snprintf(ssdp_id, sizeof(ssdp_id), "JudoProxy");
static gint run[NUM_CONNECTIONS];
for (i = 0; i < NUM_CONNECTIONS; i++) {
char tname[16];
run[i] = i;
sprintf(tname, "Connection%d", i);
gth = g_thread_new(tname,
(GThreadFunc)connection_thread,
&run[i]);
}
gth = g_thread_new("SSDP",
(GThreadFunc)proxy_ssdp_thread,
(gpointer)&run_flag);
gth = g_thread_new("CameraVideo",
camera_video,
(gpointer)&run_flag);
gth = gth; // make compiler happy
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER_ALWAYS);
cursor = gdk_cursor_new(GDK_HAND2);
//gdk_window_set_cursor(GTK_WIDGET(main_window)->window, cursor);
//g_timeout_add(100, timeout_ask_for_data, NULL);
g_timeout_add(1000, check_table, NULL);
g_timeout_add(100, show_camera_video, NULL);
//g_idle_add(show_camera_video, NULL);
/* All GTK applications must have a gtk_main(). Control ends here
* and waits for an event to occur (like a key press or
* mouse event). */
gtk_main();
for (i = 0; i < NUM_CONNECTIONS; i++)
run[i] = -1;
run_flag = FALSE; /* flag threads to stop and exit */
//g_thread_join(gth); /* wait for thread to exit */
return 0;
}
