static int _calendar_embedded(void)
{
GtkWidget * window;
GtkWidget * widget;
Calendar * calendar;
unsigned long id;
window = gtk_plug_new(0);
gtk_widget_realize(window);
g_signal_connect_swapped(window, "embedded", G_CALLBACK(
_embedded_on_embedded), window);
if((calendar = calendar_new()) == NULL)
{
gtk_widget_destroy(window);
return -1;
}
widget = calendar_get_widget(calendar);
gtk_container_add(GTK_CONTAINER(window), widget);
id = gtk_plug_get_id(GTK_PLUG(window));
printf("%lu\n", id);
fclose(stdout);
gtk_main();
calendar_delete(calendar);
gtk_widget_destroy(window);
return 0;
}
guint32
create_child_plug (guint32 xid,
gboolean local)
{
GtkWidget *window;
GtkWidget *content;
window = gtk_plug_new (xid);
g_signal_connect (window, "destroy",
local ? G_CALLBACK (local_destroy)
: G_CALLBACK (remote_destroy),
NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
content = create_content (GTK_WINDOW (window), local);
gtk_container_add (GTK_CONTAINER (window), content);
gtk_widget_show_all (window);
if (GTK_WIDGET_REALIZED (window))
#if defined (GDK_WINDOWING_X11)
return GDK_WINDOW_XID (window->window);
#elif defined (GDK_WINDOWING_WIN32)
return (guint32) GDK_WINDOW_HWND (window->window);
#endif
else
return 0;
NetscapePluginX11::NetscapePluginX11(NetscapePlugin& plugin, Display* display, uint64_t windowID)
: m_plugin(plugin)
, m_pluginDisplay(display)
, m_windowID(windowID)
{
// It seems flash needs the socket to be in the same process,
// I guess it uses gdk_window_lookup(), so we create a new socket here
// containing a plug with the UI process socket embedded.
m_platformPluginWidget = gtk_plug_new(static_cast<Window>(windowID));
// Hide the GtkPlug on delete-event since we assume the widget is valid while the plugin is active.
// platformDestroy() will be called anyway right after the delete-event.
g_signal_connect(m_platformPluginWidget, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), nullptr);
GtkWidget* socket = gtk_socket_new();
// Do not show the plug widget until the socket is connected.
g_signal_connect_swapped(socket, "plug-added", G_CALLBACK(gtk_widget_show), m_platformPluginWidget);
g_signal_connect(socket, "plug-removed", G_CALLBACK(socketPlugRemovedCallback), nullptr);
gtk_container_add(GTK_CONTAINER(m_platformPluginWidget), socket);
gtk_widget_show(socket);
Display* hostDisplay = x11HostDisplay();
m_npWindowID = gtk_socket_get_id(GTK_SOCKET(socket));
GdkWindow* window = gtk_widget_get_window(socket);
m_setWindowCallbackStruct.display = GDK_WINDOW_XDISPLAY(window);
m_setWindowCallbackStruct.visual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));
m_setWindowCallbackStruct.depth = gdk_visual_get_depth(gdk_window_get_visual(window));
m_setWindowCallbackStruct.colormap = XCreateColormap(hostDisplay, GDK_ROOT_WINDOW(), m_setWindowCallbackStruct.visual, AllocNone);
XFlush(hostDisplay);
}
static int
wrapper_wrap(SuilWrapper* wrapper,
SuilInstance* instance)
{
SuilGtk2InQt4Wrapper* const impl = (SuilGtk2InQt4Wrapper*)wrapper->impl;
QWidget* root = static_cast<QWidget*>(impl->parent);
QX11EmbedContainer* const wrap = new QX11EmbedContainer(root);
GtkWidget* const plug = gtk_plug_new(wrap->winId());
GtkWidget* const widget = (GtkWidget*)instance->ui_widget;
gtk_container_add(GTK_CONTAINER(plug), widget);
gtk_widget_show_all(plug);
#ifdef SUIL_OLD_GTK
wrap->resize(widget->allocation.width, widget->allocation.height);
#else
GtkAllocation alloc;
gtk_widget_get_allocation(widget, &alloc);
wrap->resize(alloc.width, alloc.height);
#endif
g_signal_connect(
G_OBJECT(plug), "size-request", G_CALLBACK(on_size_request), wrap);
g_signal_connect(
G_OBJECT(plug), "size-allocate", G_CALLBACK(on_size_allocate), wrap);
impl->host_widget = wrap;
impl->plug = plug;
instance->host_widget = wrap;
return 0;
}
JNIEXPORT jint JNICALL GTK_NATIVE(_1gtk_1plug_1new)
(JNIEnv *env, jclass that, jint arg0)
{
jint rc = 0;
GTK_NATIVE_ENTER(env, that, _1gtk_1plug_1new_FUNC);
rc = (jint)gtk_plug_new(arg0);
GTK_NATIVE_EXIT(env, that, _1gtk_1plug_1new_FUNC);
return rc;
}
NPError
VirtViewerXSetWindow (NPP instance, NPWindow *window)
{
PluginInstance *This;
NPSetWindowCallbackStruct *ws_info;
int r;
if (instance == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
This = (PluginInstance*) instance->pdata;
debug ("ViewViewerXSetWindow, This=%p", This);
if (This == NULL)
return NPERR_INVALID_INSTANCE_ERROR;
ws_info = (NPSetWindowCallbackStruct *)window->ws_info;
/* Mozilla likes to re-run its greatest hits */
if (window == This->window &&
window->x == This->x &&
window->y == This->y &&
window->width == This->width &&
window->height == This->height) {
debug ("virt-viewer-plugin: window re-run; returning");
return NPERR_NO_ERROR;
}
This->window = window;
This->x = window->x;
This->y = window->y;
This->width = window->width;
This->height = window->height;
/* Create a GtkPlug container and a Gtk-VNC widget inside it. */
This->container = gtk_plug_new ((GdkNativeWindow)(long)window->window);
/* Make the VNC widget. */
if (This->uri && This->name) {
debug ("calling viewer_start uri=%s name=%s direct=%d waitvm=%d reconnect=%d container=%p",
This->uri, This->name, This->direct, This->waitvm, This->reconnect, This->container);
r = viewer_start (This->uri, This->name, This->direct, This->waitvm, This->reconnect, 1, This->debug, This->container);
if (r != 0)
fprintf (stderr, "viewer_start returned %d != 0\n", r);
}
gtk_widget_show_all (This->container);
return NPERR_NO_ERROR;
}
gMainWindow::gMainWindow(int plug) : gContainer(NULL)
{
initialize();
g_typ = Type_gMainWindow;
windows = g_list_append(windows, (gpointer)this);
_xembed = plug != 0;
if (_xembed)
border = gtk_plug_new(plug);
else
border = gtk_window_new(GTK_WINDOW_TOPLEVEL);
widget = gtk_fixed_new(); //gtk_layout_new(0,0);
#if 0 //def GTK3
static bool patch = FALSE;
if (!patch)
{
GtkWidgetClass *klass;
klass = (GtkWidgetClass *)GTK_FIXED_GET_CLASS(widget);
old_fixed_get_preferred_width = klass->get_preferred_width;
klass->get_preferred_width = gtk_fixed_get_preferred_width;
old_fixed_get_preferred_height = klass->get_preferred_height;
klass->get_preferred_height = gtk_fixed_get_preferred_height;
/*klass = (GtkWidgetClass *)GTK_FIXED_GET_CLASS(border);
old_window_get_preferred_width = klass->get_preferred_width;
klass->get_preferred_width = gtk_window_get_preferred_width;
old_window_get_preferred_height = klass->get_preferred_height;
klass->get_preferred_height = gtk_window_get_preferred_height;*/
patch = true;
}
#endif
realize(false);
initWindow();
gtk_widget_realize(border);
gtk_widget_show(widget);
gtk_widget_set_size_request(border, 1, 1);
setCanFocus(false);
}
/* Create "pluggable" dialog for this settings instance */
GtkWidget* xfdashboard_settings_create_plug(XfdashboardSettings *self, Window inSocketID)
{
XfdashboardSettingsPrivate *priv;
GtkWidget *plug;
GObject *dialogChild;
#if GTK_CHECK_VERSION(3, 14 ,0)
GtkWidget *dialogParent;
#endif
g_return_val_if_fail(XFDASHBOARD_IS_SETTINGS(self), NULL);
g_return_val_if_fail(inSocketID, NULL);
priv=self->priv;
/* Get builder if not available */
if(!_xfdashboard_settings_create_builder(self))
{
/* An critical error message should be displayed so just return NULL */
return(NULL);
}
/* Get dialog object */
dialogChild=gtk_builder_get_object(priv->builder, "preferences-plug-child");
if(!dialogChild)
{
g_critical(_("Could not get dialog from UI file."));
return(NULL);
}
/* Create plug widget and reparent dialog object to it */
plug=gtk_plug_new(inSocketID);
#if GTK_CHECK_VERSION(3, 14 ,0)
g_object_ref(G_OBJECT(dialogChild));
dialogParent=gtk_widget_get_parent(GTK_WIDGET(dialogChild));
gtk_container_remove(GTK_CONTAINER(dialogParent), GTK_WIDGET(dialogChild));
gtk_container_add(GTK_CONTAINER(plug), GTK_WIDGET(dialogChild));
g_object_unref(G_OBJECT(dialogChild));
#else
gtk_widget_reparent(GTK_WIDGET(dialogChild), plug);
#endif
gtk_widget_show(GTK_WIDGET(dialogChild));
/* Return widget */
return(GTK_WIDGET(plug));
}
static void
realize_cb (GtkWidget *socket, gpointer user_data)
{
GtkWidget *plug, *w;
g_warning ("Realize");
plug = gtk_plug_new (0);
w = gtk_button_new_with_label ("Baa");
gtk_widget_show_all (w);
gtk_widget_show (plug);
gtk_container_add (GTK_CONTAINER (plug), w);
GTK_PLUG (plug)->socket_window = GTK_WIDGET (socket)->window;
gtk_socket_add_id (GTK_SOCKET (socket),
gtk_plug_get_id (GTK_PLUG (plug)));
gdk_window_show (GTK_WIDGET (plug)->window);
}
static VALUE
plug_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE socket_id;
GdkNativeWindow id;
if (rb_scan_args(argc, argv, "01", &socket_id) == 0)
id = 0;
else {
#ifdef GDK_NATIVE_WINDOW_POINTER
id = GUINT_TO_POINTER(NUM2ULONG(socket_id));
#else
id = NUM2UINT(socket_id);
#endif
}
RBGTK_INITIALIZE(self, gtk_plug_new(id));
return Qnil;
}
bool NetscapePlugin::platformPostInitializeWindowed(bool needsXEmbed, uint64_t windowID)
{
m_npWindow.type = NPWindowTypeWindow;
if (!needsXEmbed) {
notImplemented();
return false;
}
Display* display = x11HostDisplay();
#if PLATFORM(GTK)
// It seems flash needs the socket to be in the same process,
// I guess it uses gdk_window_lookup(), so we create a new socket here
// containing a plug with the UI process socket embedded.
m_platformPluginWidget = gtk_plug_new(static_cast<Window>(windowID));
GtkWidget* socket = gtk_socket_new();
// Do not show the plug widget until the socket is connected.
g_signal_connect_swapped(socket, "plug-added", G_CALLBACK(gtk_widget_show), m_platformPluginWidget);
g_signal_connect(socket, "plug-removed", G_CALLBACK(socketPlugRemovedCallback), nullptr);
gtk_container_add(GTK_CONTAINER(m_platformPluginWidget), socket);
gtk_widget_show(socket);
m_npWindow.window = GINT_TO_POINTER(gtk_socket_get_id(GTK_SOCKET(socket)));
GdkWindow* window = gtk_widget_get_window(socket);
NPSetWindowCallbackStruct* callbackStruct = static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info);
callbackStruct->display = GDK_WINDOW_XDISPLAY(window);
callbackStruct->visual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));
callbackStruct->depth = gdk_visual_get_depth(gdk_window_get_visual(window));
callbackStruct->colormap = XCreateColormap(display, GDK_ROOT_WINDOW(), callbackStruct->visual, AllocNone);
#else
UNUSED_PARAM(windowID);
#endif
XFlush(display);
callSetWindow();
return true;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkEmbeddedWindowPeer_create
(JNIEnv *env, jobject obj, jlong socket_id)
{
GtkWidget *window;
GtkWidget *fixed;
gdk_threads_enter ();
NSA_SET_GLOBAL_REF (env, obj);
window = gtk_plug_new ((GdkNativeWindow) socket_id);
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
NSA_SET_PTR (env, obj, window);
gdk_threads_leave ();
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkEmbeddedWindowPeer_create
(JNIEnv *env, jobject obj, jlong socket_id)
{
GtkWidget *window;
GtkWidget *fixed;
gdk_threads_enter ();
gtkpeer_set_global_ref (env, obj);
window = gtk_plug_new ((GdkNativeWindow) socket_id);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
fixed = gtk_fixed_new ();
gtk_container_add (GTK_CONTAINER (window), fixed);
gtk_widget_show (fixed);
gtkpeer_set_widget (env, obj, window);
gdk_threads_leave ();
}
int main(int argc, char **argv)
{
GError *error = NULL;
unsigned long wid=0;
gtk_init( &argc, &argv );
int i;
for(i=0; i<argc; i++) {
if(strcmp("-h", argv[i])==0 || strcmp("--help", argv[i])==0) {
printHelp();
return 0;
}
else if(strcmp("-V", argv[i])==0 || strcmp("--version", argv[i])==0) {
printf("gtk_preview version 1.0\n");
return 0;
} else if(argc>1)
sscanf(argv[1], "%ld", &wid);
}
const char* ui_file = DATA_DIR "/preview.ui";
GtkBuilder *builder = gtk_builder_new();
if( ! gtk_builder_add_from_file( builder, ui_file, &error ) ) {
g_warning( "%s", error->message );
g_free( error );
return 1;
}
GtkWidget *previewUI = GTK_WIDGET( gtk_builder_get_object( builder, "frame1" ) );
gtk_builder_connect_signals( builder, NULL );
/* a plug when embedded, a window when a window */
GtkWidget* window;
if(wid==0) {
window = gtk_dialog_new();
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (window)->vbox), previewUI);
g_signal_connect(window, "response", G_CALLBACK(on_dlg_response), NULL);
} else {
window = gtk_plug_new(wid);
gtk_container_add (GTK_CONTAINER (window), previewUI);
}
GdkColor black = {0, 0, 0, 0};
gtk_widget_modify_bg(previewUI, GTK_STATE_NORMAL, &black);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_widget_show_all ( window );
g_object_unref( G_OBJECT( builder ) );
if(wid)
fprintf(stderr, "--- is embedded: %d\n", gtk_plug_get_embedded(GTK_PLUG(window)));
gchar** files = gtk_rc_get_default_files();
GFile* file = g_file_new_for_path(files[0]);
GFileMonitor* monitor = g_file_monitor_file(file, G_FILE_MONITOR_NONE, NULL, NULL);
g_signal_connect (monitor, "changed",
G_CALLBACK (reloadstyle), NULL);
gtk_main();
return 0;
}
void
create_plug (void)
{
GtkWidget *win, *vbox, *text;
GtkWidget *main_widget = NULL;
tabs = get_tabs (options.plug, FALSE);
while (!tabs)
{
usleep (1000);
tabs = get_tabs (options.plug, FALSE);
}
win = gtk_plug_new (0);
/* set window borders */
if (options.data.borders == -1)
options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (win));
gtk_container_set_border_width (GTK_CONTAINER (win), (guint) options.data.borders);
#if !GTK_CHECK_VERSION(3,0,0)
vbox = gtk_vbox_new (FALSE, 0);
#else
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_container_add (GTK_CONTAINER (win), vbox);
/* add dialog text */
if (options.data.dialog_text)
{
gchar *buf = g_strcompress (options.data.dialog_text);
text = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (text), buf);
else
gtk_label_set_text (GTK_LABEL (text), buf);
gtk_widget_set_name (text, "yad-dialog-label");
gtk_label_set_line_wrap (GTK_LABEL (text), TRUE);
gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels);
gtk_label_set_justify (GTK_LABEL (text), options.data.text_align);
switch (options.data.text_align)
{
case GTK_JUSTIFY_LEFT:
case GTK_JUSTIFY_FILL:
gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5);
break;
case GTK_JUSTIFY_CENTER:
gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5);
break;
case GTK_JUSTIFY_RIGHT:
gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5);
break;
}
gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2);
#if !GTK_CHECK_VERSION(3,0,0)
g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL);
#endif
g_free (buf);
}
/* add main widget */
switch (options.mode)
{
case YAD_MODE_CALENDAR:
main_widget = calendar_create_widget (win);
break;
case YAD_MODE_COLOR:
main_widget = color_create_widget (win);
break;
case YAD_MODE_ENTRY:
main_widget = entry_create_widget (win);
break;
case YAD_MODE_FILE:
main_widget = file_create_widget (win);
break;
case YAD_MODE_FONT:
main_widget = font_create_widget (win);
break;
case YAD_MODE_FORM:
main_widget = form_create_widget (win);
break;
#ifdef HAVE_HTML
case YAD_MODE_HTML:
main_widget = html_create_widget (win);
break;
#endif
case YAD_MODE_ICONS:
main_widget = icons_create_widget (win);
break;
case YAD_MODE_LIST:
main_widget = list_create_widget (win);
break;
case YAD_MODE_MULTI_PROGRESS:
main_widget = multi_progress_create_widget (win);
break;
case YAD_MODE_PROGRESS:
main_widget = progress_create_widget (win);
break;
case YAD_MODE_SCALE:
main_widget = scale_create_widget (win);
break;
case YAD_MODE_TEXTINFO:
main_widget = text_create_widget (win);
break;
default:
;
}
if (main_widget)
gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2);
gtk_widget_show_all (win);
/* add plug data */
tabs[options.tabnum].pid = getpid ();
tabs[options.tabnum].xid = gtk_plug_get_id (GTK_PLUG (win));
/* FIXME: may be a race here */
tabs[0].xid++;
shmdt (tabs);
}
void window_create(void)
/* Create the main window and child widgets */
{
GtkWidget *widget, *window_vbox, *image;
GdkScreen *screen;
/* Create the window or plug */
window = !window_embedded ? gtk_window_new(GTK_WINDOW_TOPLEVEL) :
gtk_plug_new(0);
g_signal_connect(G_OBJECT(window), "delete-event",
G_CALLBACK(window_close), NULL);
g_signal_connect(G_OBJECT(window), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(G_OBJECT(window), "style-set",
G_CALLBACK(window_style_set), NULL);
g_signal_connect(G_OBJECT(window), "configure-event",
G_CALLBACK(window_configure), NULL);
gtk_window_set_accept_focus(GTK_WINDOW(window), FALSE);
gtk_window_set_resizable(GTK_WINDOW(window), FALSE);
/* Tooltips */
tooltips = gtk_tooltips_new();
gtk_tooltips_enable(tooltips);
/* Root box */
window_vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(window_vbox);
/* Training info label frame */
train_label_frame = gtk_frame_new(NULL);
gtk_widget_set_no_show_all(train_label_frame, TRUE);
gtk_frame_set_shadow_type(GTK_FRAME(train_label_frame), GTK_SHADOW_IN);
gtk_container_set_border_width(GTK_CONTAINER(train_label_frame), 2);
/* Training info label */
train_label = gtk_label_new(NULL);
gtk_label_set_line_wrap(GTK_LABEL(train_label), TRUE);
gtk_label_set_justify(GTK_LABEL(train_label), GTK_JUSTIFY_FILL);
gtk_label_set_markup(GTK_LABEL(train_label),
"<b>Training Mode:</b> Carefully draw each "
"character in its cell. Multiple "
"samples will be stored for each character. "
"If you make a mistake, reset by "
"pressing on the cell with the pen eraser.");
gtk_widget_show(train_label);
/* Training info label colored box */
train_label_box = gtk_event_box_new();
gtk_widget_show(train_label_box);
gtk_container_add(GTK_CONTAINER(train_label_box), train_label);
gtk_container_add(GTK_CONTAINER(train_label_frame), train_label_box);
gtk_widget_show_all(train_label_frame);
gtk_box_pack_start(GTK_BOX(window_vbox), train_label_frame,
FALSE, FALSE, 0);
/* Cell widget */
cell_widget = cell_widget_new();
gtk_box_pack_start(GTK_BOX(window_vbox), cell_widget, TRUE, TRUE, 2);
if (!keyboard_only)
gtk_widget_show_all(cell_widget);
/* Key widget */
key_widget = key_widget_new_full();
gtk_box_pack_start(GTK_BOX(window_vbox), key_widget->drawing_area,
TRUE, TRUE, 2);
if (keyboard_only) {
gtk_widget_show(key_widget->drawing_area);
keys_on = TRUE;
}
/* Bottom box */
bottom_box = gtk_hbox_new(FALSE, 0);
/* Train button */
train_button = gtk_toggle_button_new_with_label("Train");
gtk_button_set_focus_on_click(GTK_BUTTON(train_button), FALSE);
gtk_button_set_image(GTK_BUTTON(train_button),
gtk_image_new_from_stock(GTK_STOCK_MEDIA_RECORD,
GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief(GTK_BUTTON(train_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(bottom_box), train_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(train_button), "toggled",
G_CALLBACK(train_button_toggled), 0);
gtk_tooltips_set_tip(tooltips, train_button, "Toggle training mode",
NULL);
/* Setup button */
setup_button = gtk_button_new_with_label("Setup");
gtk_button_set_focus_on_click(GTK_BUTTON(setup_button), FALSE);
gtk_button_set_image(GTK_BUTTON(setup_button),
gtk_image_new_from_stock(GTK_STOCK_PREFERENCES,
GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief(GTK_BUTTON(setup_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(bottom_box), setup_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(setup_button), "clicked",
G_CALLBACK(options_dialog_open), 0);
gtk_tooltips_set_tip(tooltips, setup_button, "Edit program options",
NULL);
/* Expanding box to keep things tidy */
widget = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(bottom_box), widget, TRUE, FALSE, 0);
/* Training Unicode Block selector */
widget = create_blocks_combo();
gtk_box_pack_start(GTK_BOX(bottom_box), widget, FALSE, FALSE, 0);
gtk_widget_set_no_show_all(blocks_combo, TRUE);
/* Clear button */
clear_button = gtk_button_new_with_label("Clear");
gtk_button_set_focus_on_click(GTK_BUTTON(clear_button), FALSE);
image = gtk_image_new_from_stock(GTK_STOCK_CLEAR, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(clear_button), image);
gtk_button_set_relief(GTK_BUTTON(clear_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(bottom_box), clear_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(clear_button), "clicked",
G_CALLBACK(cell_widget_clear), 0);
gtk_tooltips_set_tip(tooltips, clear_button, "Clear current input",
NULL);
/* Keys button */
keys_button = gtk_toggle_button_new_with_label("Keys");
gtk_button_set_focus_on_click(GTK_BUTTON(keys_button), FALSE);
image = gtk_image_new_from_icon_name("keyboard", GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(keys_button), image);
gtk_button_set_relief(GTK_BUTTON(keys_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(bottom_box), keys_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(keys_button), "toggled",
G_CALLBACK(keys_button_toggled), 0);
gtk_tooltips_set_tip(tooltips, keys_button,
"Switch between on-screen keyboard and "
"handwriting input", NULL);
/* Insert button */
insert_button = gtk_button_new_with_label("Enter");
gtk_button_set_focus_on_click(GTK_BUTTON(insert_button), FALSE);
gtk_button_set_image(GTK_BUTTON(insert_button),
gtk_image_new_from_stock(GTK_STOCK_OK,
GTK_ICON_SIZE_BUTTON));
gtk_button_set_relief(GTK_BUTTON(insert_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(bottom_box), insert_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(insert_button), "clicked",
G_CALLBACK(insert_button_clicked), 0);
gtk_tooltips_set_tip(tooltips, insert_button,
"Insert input or press Enter key", NULL);
/* Back buffer button */
buffer_button = gtk_toggle_button_new();
gtk_button_set_focus_on_click(GTK_BUTTON(buffer_button), FALSE);
button_set_image_xpm(buffer_button, tab_xpm);
gtk_button_set_relief(GTK_BUTTON(buffer_button), GTK_RELIEF_NONE);
gtk_box_pack_start(GTK_BOX(bottom_box), buffer_button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(buffer_button), "pressed",
G_CALLBACK(buffer_button_pressed), NULL);
gtk_tooltips_set_tip(tooltips, buffer_button,
"Recall previously entered input", NULL);
gtk_widget_set_sensitive(buffer_button, FALSE);
/* Pack the regular bottom box */
gtk_box_pack_start(GTK_BOX(window_vbox), bottom_box, FALSE, FALSE, 0);
if (!keyboard_only)
gtk_widget_show_all(bottom_box);
/* Update button labels */
toggle_button_labels(window_button_labels);
/* Set window style */
window_style_set(window);
if (window_embedded) {
/* Embedding in a screensaver won't let us popup new windows */
gtk_widget_hide(buffer_button);
gtk_widget_hide(train_button);
gtk_widget_hide(setup_button);
/* If we are embedded we need to print the plug's window XID */
g_signal_connect_after(G_OBJECT(window), "realize",
G_CALLBACK(print_window_xid), NULL);
gtk_container_add(GTK_CONTAINER(window), window_vbox);
gtk_widget_show(window);
return;
}
/* Non-embedded window configuration */
gtk_container_add(GTK_CONTAINER(window), window_vbox);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(window),
GDK_WINDOW_TYPE_HINT_UTILITY);
gtk_window_set_title(GTK_WINDOW(window), PACKAGE_NAME);
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_decorated(GTK_WINDOW(window), TRUE);
gtk_window_stick(GTK_WINDOW(window));
/* Coordinates passed on the command-line */
if (window_force_x >= 0)
window_frame.x = window_force_x;
if (window_force_y >= 0)
window_frame.y = window_force_y;
/* Center window on initial startup */
screen = gtk_window_get_screen(GTK_WINDOW(window));
if (window_frame.x < 0)
window_frame.x = gdk_screen_get_width(screen) / 2;
if (window_frame.y < 0)
window_frame.y = gdk_screen_get_height(screen) * 3 / 4;
gtk_window_move(GTK_WINDOW(window), window_frame.x,
window_frame.y);
/* Create status icon */
status_icon_create();
/* Set the window size */
if (window_force_docked >= WINDOW_UNDOCKED)
window_docked = window_force_docked;
if (window_docked) {
int mode;
mode = window_docked;
window_docked = WINDOW_UNDOCKED;
window_set_docked(mode);
}
/* Show window */
if (window_force_hide)
window_shown = FALSE;
else if (window_force_show)
window_shown = TRUE;
if (window_shown) {
gtk_widget_show(window);
} else {
/* Check if the status icon is embedded after a timeout so that
it has a chance to embed itself into the tray. */
gtk_timeout_add(10, status_icon_embedded_check, NULL);
}
}
#include <Gtk/Gtk/Plug.h>
TYPE(T, Gtk$Gtk$Window$T, Gtk$Gtk$Bin$T, Gtk$Gtk$Container$T, Gtk$Gtk$Widget$T, Gtk$Gtk$Object$T, Gtk$GObject$Object$T);
GLOBAL_FUNCTION(New, 0) {
GtkWidget *Handle = gtk_plug_new();
Result->Val = Gtk$GObject$Object$new(Handle, T);
return SUCCESS;
};
int main( int argc, char *argv[] )
{
GtkWidget *vbox;
gtk_init( &argc, &argv );
if( client_open( NULL ) )
exit( 1 );
atexit( client_close );
window = argc == 2 ?
gtk_plug_new( strtol( argv[1], NULL, 10 )) :
gtk_window_new( GTK_WINDOW_TOPLEVEL );
vbox = gtk_vbox_new( FALSE, 0 );
gtk_container_add( GTK_CONTAINER( window ), vbox );
drawing_area = gtk_drawing_area_new();
/* Get the dimensions and colors of the pager and viewport and focus */
parse_stdin();
update_rect.x = update_rect.y = 0;
gtk_drawing_area_size( GTK_DRAWING_AREA( drawing_area ), width, height );
gtk_box_pack_start( GTK_BOX( vbox ), drawing_area, FALSE, FALSE, 0 );
/* Signals to quit */
g_signal_connect( GTK_OBJECT( window ), "delete_event",
G_CALLBACK( delete_event ), NULL );
g_signal_connect( GTK_OBJECT( window ), "destroy",
G_CALLBACK( destroy_event ), NULL );
/* Wait for input from standard input */
gdk_input_add( 0, GDK_INPUT_READ,
&wait_stdin,
drawing_area );
/* Change the viewport when a button is pressed */
g_signal_connect( GTK_OBJECT( drawing_area ), "motion_notify_event",
(GCallback) motion_notify_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "button_press_event",
(GCallback) button_press_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "button_release_event",
(GCallback) button_release_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "leave_notify_event",
(GCallback) leave_notify_event, NULL );
g_signal_connect ( GTK_OBJECT( drawing_area), "scroll_event",
(GCallback) scroll_event, NULL );
gtk_widget_set_events( drawing_area, GDK_EXPOSURE_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK
| GDK_SCROLL_MASK );
/* Initialize and draw the pixmap */
g_signal_connect( GTK_OBJECT( drawing_area ), "expose_event",
(GCallback) expose_event, NULL );
g_signal_connect( GTK_OBJECT( drawing_area ), "configure_event",
(GCallback) configure_event, NULL );
gtk_widget_show( drawing_area );
gtk_widget_show( vbox );
wmspec_change_state(TRUE, window->window,
gdk_atom_intern( "_NET_WM_STATE_SKIP_PAGER", FALSE ),
gdk_atom_intern( "_NET_WM_STATE_SKIP_TASKBAR", FALSE ));
gtk_window_set_type_hint( GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_show( window );
gtk_main();
return 0;
}
WebKitWebView *
client_new(const gchar *uri)
{
struct Client *c;
WebKitWebContext *wc;
gchar *f;
if (uri != NULL && cooperative_instances && !cooperative_alone)
{
write(cooperative_pipe_fp, uri, strlen(uri));
write(cooperative_pipe_fp, "\n", 1);
return NULL;
}
c = malloc(sizeof(struct Client));
if (!c)
{
fprintf(stderr, __NAME__": fatal: malloc failed\n");
exit(EXIT_FAILURE);
}
c->hover_uri = NULL;
c->win = NULL;
if (embed != 0)
{
c->win = gtk_plug_new(embed);
if (!gtk_plug_get_embedded(GTK_PLUG(c->win)))
{
fprintf(stderr, __NAME__": Can't plug-in to XID %ld.\n", embed);
gtk_widget_destroy(c->win);
c->win = NULL;
embed = 0;
}
}
if (c->win == NULL)
{
c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(c->win), __NAME__, __NAME_CAPITALIZED__);
}
gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(client_destroy), c);
gtk_window_set_title(GTK_WINDOW(c->win), __NAME__);
c->web_view = webkit_web_view_new();
wc = webkit_web_view_get_context(WEBKIT_WEB_VIEW(c->web_view));
webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(c->web_view), global_zoom);
g_signal_connect(G_OBJECT(c->web_view), "notify::title",
G_CALLBACK(changed_title), c);
g_signal_connect(G_OBJECT(c->web_view), "notify::uri",
G_CALLBACK(changed_uri), c);
g_signal_connect(G_OBJECT(c->web_view), "notify::estimated-load-progress",
G_CALLBACK(changed_load_progress), c);
g_signal_connect(G_OBJECT(c->web_view), "create",
G_CALLBACK(client_new_request), NULL);
g_signal_connect(G_OBJECT(c->web_view), "close",
G_CALLBACK(client_destroy_request), c);
g_signal_connect(G_OBJECT(c->web_view), "decide-policy",
G_CALLBACK(decide_policy), NULL);
g_signal_connect(G_OBJECT(c->web_view), "key-press-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "button-press-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "scroll-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "mouse-target-changed",
G_CALLBACK(hover_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "web-process-crashed",
G_CALLBACK(crashed_web_view), c);
if (!initial_wc_setup_done)
{
if (accepted_language[0] != NULL)
webkit_web_context_set_preferred_languages(wc, accepted_language);
g_signal_connect(G_OBJECT(wc), "download-started",
G_CALLBACK(download_handle_start), NULL);
trust_user_certs(wc);
initial_wc_setup_done = TRUE;
}
if (user_agent != NULL)
g_object_set(G_OBJECT(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(c->web_view))),
"user-agent", user_agent, NULL);
c->location = gtk_entry_new();
g_signal_connect(G_OBJECT(c->location), "key-press-event",
G_CALLBACK(key_location), c);
/* XXX Progress bars don't work/look as intended anymore. Level bars
* are a dirty workaround (kind of). */
c->progress = gtk_level_bar_new();
gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), 0);
gtk_widget_set_size_request(c->progress, 100, -1);
c->top_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(c->top_box), c->location, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(c->top_box), c->progress, FALSE, FALSE, 0);
c->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(c->vbox), c->top_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c->vbox), c->web_view, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
gtk_widget_grab_focus(c->web_view);
gtk_widget_show_all(c->win);
if (uri != NULL)
{
f = ensure_uri_scheme(uri);
webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
g_free(f);
}
clients++;
return WEBKIT_WEB_VIEW(c->web_view);
}
Client *
newclient(void) {
int i;
Client *c;
WebKitWebSettings *settings;
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);
if(!(c->items = calloc(1, sizeof(GtkWidget *) * LENGTH(items))))
die("Cannot malloc!\n");
/* contextmenu */
for(i = 0; i < LENGTH(items); i++) {
c->items[i] = gtk_menu_item_new_with_label(items[i].label);
g_signal_connect(G_OBJECT(c->items[i]), "activate",
G_CALLBACK(itemclick), 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), "title-changed", G_CALLBACK(titlechange), c);
g_signal_connect(G_OBJECT(c->view), "load-progress-changed", G_CALLBACK(progresschange), c);
g_signal_connect(G_OBJECT(c->view), "load-committed", G_CALLBACK(loadcommit), c);
g_signal_connect(G_OBJECT(c->view), "load-started", G_CALLBACK(loadstart), 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), "download-requested", G_CALLBACK(initdownload), c);
g_signal_connect(G_OBJECT(c->view), "window-object-cleared", G_CALLBACK(windowobjectcleared), c);
g_signal_connect(G_OBJECT(c->view), "populate-popup", G_CALLBACK(context), 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);
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_free(uri);
setatom(c, findprop, "");
c->download = NULL;
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;
}
void
HandleSocketMessage(gpointer data, gpointer user_data)
{
int instance, type;
char mMsgBuf[1024];
char *msg = (char *)data;
int i = sscanf(msg, "%d,%d,%s", &instance, &type, mMsgBuf);
NS_ASSERTION(i >= 2, "Wrong message format\n");
// In case that the last message string argument contains spaces, sscanf
// returns before the first space. Below line returns the complete message
// string.
char* mMsgString = (char*)strchr(msg, ',');
mMsgString++;
mMsgString = (char*)strchr(mMsgString, ',');
mMsgString++;
GtkBrowser *pBrowser;
switch (type) {
case JEVENT_INIT:
break;
case JEVENT_CREATEWINDOW:
{
// only create new browser window when the instance does not exist
if (instance < gBrowserArray.GetSize() && gBrowserArray[instance] != NULL)
break;
if (i != 3)
break;
int javaXId = atoi(mMsgString);
NS_ASSERTION(javaXId, "Invalid X window handle\n");
pBrowser = g_new0(GtkBrowser, 1);
pBrowser->topLevelWindow = gtk_plug_new(javaXId);
pBrowser->mozEmbed = gtk_moz_embed_new();
if (pBrowser->mozEmbed) {
gtk_container_add(GTK_CONTAINER(pBrowser->topLevelWindow), pBrowser->mozEmbed);
install_mozembed_cb(pBrowser);
gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(pBrowser->mozEmbed),
GTK_MOZ_EMBED_FLAG_DEFAULTCHROME);
gtk_widget_realize(pBrowser->topLevelWindow);
gtk_widget_show_all(pBrowser->topLevelWindow);
pBrowser->id = instance;
gBrowserArray.SetAtGrow(instance, pBrowser);
SendSocketMessage(instance, CEVENT_INIT_WINDOW_SUCC);
}
gtk_signal_connect(GTK_OBJECT(pBrowser->topLevelWindow),
"set-focus", GTK_SIGNAL_FUNC(set_focus_cb), pBrowser);
}
break;
case JEVENT_DESTROYWINDOW:
pBrowser = (GtkBrowser *)gBrowserArray[instance];
if(pBrowser != NULL){
gtk_widget_destroy(pBrowser->mozEmbed);
gtk_object_destroy((GtkObject *)pBrowser->topLevelWindow);
gBrowserArray.SetAt(instance, NULL);
}
SendSocketMessage(instance, CEVENT_DISTORYWINDOW_SUCC);
break;
case JEVENT_SHUTDOWN:
gtk_main_quit();
break;
case JEVENT_SET_BOUNDS:
{
NS_ASSERTION(i == 3, "Wrong message format\n");
int x, y, w, h;
i = sscanf(mMsgString, "%d,%d,%d,%d", &x, &y, &w, &h);
if (i == 4) {
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
gtk_widget_set_usize(pBrowser->topLevelWindow, w, h);
}
}
break;
case JEVENT_NAVIGATE:
NS_ASSERTION(i == 3, "Wrong message format\n");
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
gtk_moz_embed_load_url(GTK_MOZ_EMBED(pBrowser->mozEmbed), mMsgString);
break;
case JEVENT_NAVIGATE_POST:
NS_ASSERTION(i == 3, "Wrong message format\n");
strncpy(gCachedURL, mMsgString, sizeof(gCachedURL));
break;
case JEVENT_NAVIGATE_POSTDATA:
NS_ASSERTION(i == 3, "Wrong message format\n");
pBrowser = (GtkBrowser *)gBrowserArray[instance];
OpenURL(pBrowser, gCachedURL, mMsgString, POST_HEADER);
break;
case JEVENT_GOBACK:
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
gtk_moz_embed_go_back(GTK_MOZ_EMBED(pBrowser->mozEmbed));
break;
case JEVENT_GOFORWARD:
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
gtk_moz_embed_go_forward(GTK_MOZ_EMBED(pBrowser->mozEmbed));
break;
case JEVENT_REFRESH:
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
gtk_moz_embed_reload(GTK_MOZ_EMBED(pBrowser->mozEmbed), GTK_MOZ_EMBED_FLAG_RELOADNORMAL);
break;
case JEVENT_STOP:
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
gtk_moz_embed_stop_load(GTK_MOZ_EMBED(pBrowser->mozEmbed));
break;
case JEVENT_GETURL:
{
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
nsCOMPtr<nsIWebBrowser> webBrowser;
gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(pBrowser->mozEmbed), getter_AddRefs(webBrowser));
nsCOMPtr<nsIWebNavigation> webNavigation(do_QueryInterface(webBrowser));
nsCOMPtr<nsIURI> currentURI;
webNavigation->GetCurrentURI(getter_AddRefs(currentURI));
if (currentURI == NULL)
SendSocketMessage(instance, CEVENT_RETURN_URL, "");
else {
nsEmbedCString uriString;
currentURI->GetAsciiSpec(uriString);
SendSocketMessage(instance, CEVENT_RETURN_URL, uriString.get());
}
}
break;
case JEVENT_FOCUSGAINED:
case JEVENT_FOCUSLOST:
{
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
if (!pBrowser->topLevelWindow) {
ReportError("Top level Window is Null!\n");
break;
}
GtkWidget *widget = GTK_WIDGET (pBrowser->topLevelWindow);
GdkEvent event;
GtkWindowClass *parent_class = (GtkWindowClass*) gtk_type_class (GTK_TYPE_WINDOW);
if (!widget) {
ReportError("Failed to get browser's toplevel window !\n");
break;
}
if (!parent_class) {
ReportError("Failed to get gtk window class !\n");
break;
}
event.focus_change.type = GDK_FOCUS_CHANGE;
event.focus_change.window = widget->window;
event.focus_change.send_event = TRUE;
if (type == JEVENT_FOCUSGAINED) {
event.focus_change.in = TRUE;
GTK_WIDGET_CLASS (parent_class)->focus_in_event
(widget, (GdkEventFocus *)&event);
}
else {
event.focus_change.in = FALSE;
GTK_WIDGET_CLASS (parent_class)->focus_out_event
(widget, (GdkEventFocus *)&event);
}
}
break;
case JEVENT_GETCONTENT:
{
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
nsCOMPtr<nsIWebBrowser> webBrowser;
gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(pBrowser->mozEmbed),
getter_AddRefs(webBrowser));
nsCOMPtr<nsIWebNavigation>
webNavigation(do_QueryInterface(webBrowser));
char *retStr = GetContent(webNavigation);
if (retStr == NULL)
SendSocketMessage(instance, CEVENT_GETCONTENT, "");
else
SendSocketMessage(instance, CEVENT_GETCONTENT, retStr);
}
break;
case JEVENT_SETCONTENT:
{
NS_ASSERTION(i == 3, "Wrong message format\n");
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
nsCOMPtr<nsIWebBrowser> webBrowser;
gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(pBrowser->mozEmbed),
getter_AddRefs(webBrowser));
nsCOMPtr<nsIWebNavigation>
webNavigation(do_QueryInterface(webBrowser));
SetContent(webNavigation, mMsgString);
}
break;
case JEVENT_EXECUTESCRIPT:
{
NS_ASSERTION(i == 3, "Wrong message format\n");
pBrowser = (GtkBrowser *)gBrowserArray[instance];
NS_ASSERTION(pBrowser, "Can't get native browser instance\n");
nsCOMPtr<nsIWebBrowser> webBrowser;
gtk_moz_embed_get_nsIWebBrowser(GTK_MOZ_EMBED(pBrowser->mozEmbed),
getter_AddRefs(webBrowser));
nsCOMPtr<nsIWebNavigation>
webNavigation(do_QueryInterface(webBrowser));
char *retStr = ExecuteScript(webNavigation, mMsgString);
if (retStr == NULL)
SendSocketMessage(instance, CEVENT_EXECUTESCRIPT, "");
else
SendSocketMessage(instance, CEVENT_EXECUTESCRIPT, retStr);
}
break;
}
}
Download * download_new(DownloadPrefs * prefs, char const * url)
{
Download * download;
char * p;
char buf[256];
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkWidget * widget;
PangoFontDescription * bold;
unsigned long id;
/* verify arguments */
if(prefs == NULL || url == NULL)
{
errno = EINVAL;
_download_error(NULL, NULL, 1);
return NULL;
}
if((download = malloc(sizeof(*download))) == NULL)
{
_download_error(NULL, "malloc", 1);
return NULL;
}
/* initialize structure */
download->prefs.output = (prefs->output != NULL) ? strdup(prefs->output)
: NULL;
download->prefs.user_agent = (prefs->user_agent != NULL)
? strdup(prefs->user_agent) : NULL;
if((p = _ghtml_make_url(NULL, url)) != NULL)
url = p;
download->url = strdup(url);
free(p);
if(download->url != NULL && prefs->output == NULL)
download->prefs.output = strdup(basename(download->url));
download->conn = NULL;
download->data_received = 0;
download->content_length = 0;
download->timeout = 0;
download->pulse = 0;
/* verify initialization */
if((prefs->output != NULL && download->prefs.output == NULL)
|| (prefs->user_agent != NULL
&& download->prefs.user_agent == NULL)
|| download->url == NULL
|| gettimeofday(&download->tv, NULL) != 0)
{
_download_error(NULL, "gettimeofday", 1);
download_delete(download);
return NULL;
}
/* window */
if(prefs->embedded == 0)
{
download->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
snprintf(buf, sizeof(buf), "%s %s", _("Download"),
download->url);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(download->window),
"stock_download");
#endif
gtk_window_set_resizable(GTK_WINDOW(download->window), FALSE);
gtk_window_set_title(GTK_WINDOW(download->window), buf);
g_signal_connect_swapped(download->window, "delete-event",
G_CALLBACK(_download_on_closex), download);
}
else
{
download->window = gtk_plug_new(0);
g_signal_connect_swapped(download->window, "embedded",
G_CALLBACK(_download_on_embedded), download);
}
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
#else
vbox = gtk_vbox_new(FALSE, 2);
#endif
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* address */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
widget = gtk_label_new(_("Address: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
download->address = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(download->address), download->url);
gtk_editable_set_editable(GTK_EDITABLE(download->address), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), download->address, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* labels */
_download_label(vbox, bold, left, _("File: "), &download->filename,
download->prefs.output);
_download_label(vbox, bold, left, _("Status: "), &download->status,
_("Resolving..."));
_download_label(vbox, bold, left, _("Received: "), &download->received,
_("0.0 kB"));
_download_label(vbox, bold, left, _("Remaining: "),
&download->remaining, _("Unknown"));
/* progress bar */
download->progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), download->progress, FALSE, FALSE, 0);
/* checkbox */
download->check = gtk_check_button_new_with_label(
_("Close window when the download is complete"));
gtk_box_pack_start(GTK_BOX(vbox), download->check, FALSE, FALSE, 0);
/* button */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
download->cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped(download->cancel, "clicked", G_CALLBACK(
_download_on_cancel), download);
gtk_box_pack_end(GTK_BOX(hbox), download->cancel, FALSE, TRUE, 0);
download->browse = gtk_button_new_with_mnemonic("_Open folder");
gtk_widget_set_no_show_all(download->browse, TRUE);
widget = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(download->browse), widget);
g_signal_connect_swapped(download->browse, "clicked", G_CALLBACK(
_download_on_browse), download);
gtk_box_pack_end(GTK_BOX(hbox), download->browse, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(download->window), 4);
gtk_container_add(GTK_CONTAINER(download->window), vbox);
download->timeout = g_idle_add(_download_on_idle, download);
_download_refresh(download);
gtk_widget_show_all(vbox);
if(prefs->embedded == 0)
gtk_widget_show(download->window);
else
{
id = gtk_plug_get_id(GTK_PLUG(download->window));
printf("%lu\n", id);
fclose(stdout);
}
_download_cnt++;
return download;
}
static int _progress(Prefs * prefs, char * argv[])
{
Progress p;
struct stat st;
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkSizeGroup * right;
GtkWidget * widget;
PangoFontDescription * bold;
char const * q;
unsigned long id;
memset(&p, 0, sizeof(p));
p.prefs = prefs;
if(prefs->bufsiz == 0)
errno = EINVAL;
if(prefs->bufsiz == 0 || (p.buf = malloc(prefs->bufsiz)) == NULL)
return _progress_error(&p, "malloc", 1);
p.bufsiz = prefs->bufsiz;
if(pipe(p.fds) != 0)
return _progress_error(&p, "pipe", 1);
if((p.pid = fork()) == -1)
{
close(p.fds[0]);
close(p.fds[1]);
return _progress_error(&p, "fork", 1);
}
if(p.pid != 0)
return _progress_exec(&p, argv);
close(p.fds[0]);
if(gettimeofday(&p.tv, NULL) != 0)
return _progress_error(&p, "gettimeofday", 1);
if(prefs->filename == NULL)
prefs->filename = _("Standard input");
else if((p.fd = open(prefs->filename, O_RDONLY)) < 0)
return _progress_error(&p, prefs->filename, 1);
else if(fstat(p.fd, &st) == 0 && S_ISREG(st.st_mode))
prefs->length = st.st_size;
p.in_channel = g_io_channel_unix_new(p.fd);
g_io_channel_set_encoding(p.in_channel, NULL, NULL);
p.in_id = 0;
g_idle_add(_progress_idle_in, &p);
p.out_channel = g_io_channel_unix_new(p.fds[1]);
g_io_channel_set_encoding(p.out_channel, NULL, NULL);
p.out_id = 0;
/* graphical interface */
if((prefs->flags & PREFS_x) == 0)
{
p.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#if GTK_CHECK_VERSION(3, 0, 0) && !GTK_CHECK_VERSION(3, 14, 0)
gtk_window_set_has_resize_grip(GTK_WINDOW(p.window), FALSE);
#endif
gtk_window_set_title(GTK_WINDOW(p.window), prefs->title != NULL
? prefs->title : _("Progress"));
g_signal_connect_swapped(p.window, "delete-event", G_CALLBACK(
_progress_closex), p.window);
}
else
{
p.window = gtk_plug_new(0);
g_signal_connect_swapped(p.window, "embedded", G_CALLBACK(
_progress_embedded), &p);
}
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
#endif
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* file */
widget = gtk_label_new(_("File: "));
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
if((q = g_filename_to_utf8(prefs->filename, -1, NULL, NULL, NULL))
== NULL)
q = prefs->filename;
widget = gtk_label_new(q);
gtk_label_set_ellipsize(GTK_LABEL(widget), PANGO_ELLIPSIZE_MIDDLE);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* done */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
widget = gtk_label_new(_("Done: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
p.done = gtk_label_new(_("0.0 kB"));
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(p.done, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(p.done), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, p.done);
gtk_box_pack_start(GTK_BOX(hbox), p.done, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
/* remaining */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
widget = gtk_label_new(_("Remaining: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
p.remaining = gtk_label_new("");
g_timeout_add(250, _progress_timeout, &p);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(p.remaining, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(p.remaining), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, p.remaining);
gtk_box_pack_start(GTK_BOX(hbox), p.remaining, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
/* progress */
p.progress = gtk_progress_bar_new();
p.pulse = 0;
if(prefs->prefix != NULL)
{
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
widget = gtk_label_new(prefs->prefix);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_size_group_add_widget(right, p.progress);
gtk_box_pack_start(GTK_BOX(hbox), p.progress, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
}
else
gtk_box_pack_start(GTK_BOX(vbox), p.progress, TRUE, TRUE, 4);
/* cancel */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
#if GTK_CHECK_VERSION(3, 10, 0)
widget = gtk_button_new_with_label(_("Cancel"));
gtk_button_set_image(GTK_BUTTON(widget),
gtk_image_new_from_icon_name(GTK_STOCK_CANCEL,
GTK_ICON_SIZE_BUTTON));
#else
widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
#endif
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(
_progress_cancel), NULL);
gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(p.window), vbox);
gtk_container_set_border_width(GTK_CONTAINER(p.window), 4);
gtk_widget_show_all(vbox);
if((prefs->flags & PREFS_x) == 0)
/* show the window */
gtk_widget_show(p.window);
else
{
/* print the window ID and force a flush */
id = gtk_plug_get_id(GTK_PLUG(p.window));
printf("%lu\n", id);
fclose(stdout);
}
gtk_main();
close(p.fd);
close(p.fds[1]);
return p.ret;
}
Client *
newclient(void) {
Client *c;
WebKitWebSettings *settings;
gchar *uri;
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);
gtk_window_set_wmclass(GTK_WINDOW(c->win), "surf", "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);
/* 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), "title-changed", G_CALLBACK(titlechange), c);
g_signal_connect(G_OBJECT(c->view), "load-progress-changed", G_CALLBACK(progresschange), c);
g_signal_connect(G_OBJECT(c->view), "load-finished", G_CALLBACK(loadfinished), c);
g_signal_connect(G_OBJECT(c->view), "load-committed", G_CALLBACK(loadcommit), c);
g_signal_connect(G_OBJECT(c->view), "load-started", G_CALLBACK(loadstart), 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(newwindow), c);
g_signal_connect(G_OBJECT(c->view), "download-requested", G_CALLBACK(initdownload), c);
g_signal_connect(G_OBJECT(c->view), "window-object-cleared", G_CALLBACK(windowobjectcleared), c);
g_signal_connect_after(session, "request-started", G_CALLBACK(request), c);
/* urlbar */
c->urlbar = gtk_entry_new();
gtk_entry_set_has_frame(GTK_ENTRY(c->urlbar), FALSE);
g_signal_connect(G_OBJECT(c->urlbar), "focus-out-event", G_CALLBACK(unfocusbar), c);
/* searchbar */
c->searchbar = gtk_entry_new();
gtk_entry_set_has_frame(GTK_ENTRY(c->searchbar), FALSE);
g_signal_connect(G_OBJECT(c->searchbar), "focus-out-event", G_CALLBACK(unfocusbar), 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->searchbar);
gtk_container_add(GTK_CONTAINER(c->vbox), c->urlbar);
gtk_container_add(GTK_CONTAINER(c->vbox), c->indicator);
/* Setup */
gtk_box_set_child_packing(GTK_BOX(c->vbox), c->urlbar, FALSE, FALSE, 0, GTK_PACK_START);
gtk_box_set_child_packing(GTK_BOX(c->vbox), c->searchbar, FALSE, FALSE, 0, GTK_PACK_START);
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_hide_all(c->searchbar);
gtk_widget_hide_all(c->urlbar);
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);
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);
settings = webkit_web_view_get_settings(c->view);
g_object_set(G_OBJECT(settings), "user-agent", "surf", NULL);
uri = g_strconcat("file://", stylefile, NULL);
g_object_set(G_OBJECT(settings), "user-stylesheet-uri", uri, NULL);
g_free(uri);
c->download = NULL;
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[]) {
Arg arg;
Client *c;
GdkGeometry hints = { 1, 1 };
memset(&arg, 0, sizeof(arg));
/* command line args */
ARGBEGIN {
case 'e':
embed = strtol(EARGF(usage()), NULL, 0);
break;
case 'v':
die("turf-"VERSION", ©2014 turf engineers, "
"see LICENSE for details\n");
case 'x':
showxid = TRUE;
break;
default:
usage();
} ARGEND;
if(argc > 0)
arg.v = argv[0];
sigchld(0);
gtk_init(NULL, NULL);
gtk_gl_init(NULL, NULL);
dpy = GDK_DISPLAY();
/* atoms */
atoms[AtomFind] = XInternAtom(dpy, "_TURF_FIND", False);
atoms[AtomGo] = XInternAtom(dpy, "_TURF_GO", False);
atoms[AtomUri] = XInternAtom(dpy, "_TURF_URI", False);
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);
gtk_window_set_wmclass(GTK_WINDOW(c->win), "turf", "Turf");
gtk_window_set_role(GTK_WINDOW(c->win), "Turf");
}
gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
g_signal_connect(G_OBJECT(c->win),
"destroy",
G_CALLBACK(destroywin), c);
c->vbox = gtk_vbox_new(FALSE, 0);
/* cef init */
cef_settings_t *settings;
if(!(settings = malloc(sizeof(cef_settings_t))))
die("Cannot malloc\n");
cef_initialize(NULL, settings, NULL);
/* cef set as child (vbox) */
gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
gtk_widget_show_all(GTK_WIDGET(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);
/* process X events for window - aka AtomFind/AtomGo
* gdk_window_add_filter(GTK_WIDGET(c->win)->window, processx, c);
* setatom(c, AtomFind, "");
* setatom(c, AtomUri, "about:blank");
*/
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);
if (fclose(stdout) != 0) {
die("Error closing stdout");
}
}
if(arg.v)
loaduri(clients, &arg);
gtk_main();
cleanup();
return EXIT_SUCCESS;
}
int
main(int argc,
char **argv)
{
GtkBuilder *builder;
GtkWidget *notebook, *xfae_page, *lbl;
GError *error = NULL;
XfconfChannel *channel;
xfce_textdomain(GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
if(!gtk_init_with_args (&argc, &argv, "", option_entries,
GETTEXT_PACKAGE, &error))
{
if(G_LIKELY(error)) {
g_print("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_print(_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_print("\n");
g_error_free (error);
} else
g_error("Unable to open display.");
return EXIT_FAILURE;
}
if(G_UNLIKELY(opt_version)) {
g_print("%s %s (Xfce %s)\n\n", G_LOG_DOMAIN, PACKAGE_VERSION, xfce_version_string ());
g_print("%s\n", "Copyright (c) 2004-2014");
g_print("\t%s\n\n", _("The Xfce development team. All rights reserved."));
g_print(_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print("\n");
return EXIT_SUCCESS;
}
if(G_UNLIKELY(!xfconf_init(&error))) {
xfce_dialog_show_error (NULL,
error,
_("Unable to contact settings server"));
g_error_free(error);
return EXIT_FAILURE;
}
gtk_window_set_default_icon_name("xfce4-session");
/* hook to make sure the libxfce4ui library is linked */
if (xfce_titled_dialog_get_type() == 0)
return EXIT_FAILURE;
builder = gtk_builder_new();
gtk_builder_add_from_string(builder,
xfce4_session_settings_ui,
xfce4_session_settings_ui_length,
&error);
if(!builder) {
xfce_dialog_show_error(NULL, error,
_("Unable to create user interface from embedded definition data"));
g_error_free (error);
return EXIT_FAILURE;
}
splash_settings_init(builder);
session_editor_init(builder);
/* FIXME: someday, glade-ify this, maybe. */
xfae_page = xfae_window_new();
gtk_widget_show(xfae_page);
notebook = GTK_WIDGET(gtk_builder_get_object(builder, "plug-child"));
lbl = gtk_label_new_with_mnemonic(_("App_lication Autostart"));
gtk_widget_show(lbl);
gtk_notebook_insert_page(GTK_NOTEBOOK(notebook), xfae_page, lbl, 2);
channel = xfconf_channel_get(SETTINGS_CHANNEL);
/* bind widgets to xfconf */
xfconf_g_property_bind(channel, "/chooser/AlwaysDisplay", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_display_chooser"),
"active");
xfconf_g_property_bind(channel, "/general/AutoSave", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_session_autosave"),
"active");
xfconf_g_property_bind(channel, "/general/PromptOnLogout", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_logout_prompt"),
"active");
xfconf_g_property_bind(channel, "/compat/LaunchGNOME", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_compat_gnome"),
"active");
xfconf_g_property_bind(channel, "/compat/LaunchKDE", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_compat_kde"),
"active");
xfconf_g_property_bind(channel, "/security/EnableTcp", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_enable_tcp"),
"active");
xfconf_g_property_bind(channel, "/shutdown/LockScreen", G_TYPE_BOOLEAN,
gtk_builder_get_object(builder, "chk_lock_screen"),
"active");
if(G_UNLIKELY(opt_socket_id == 0)) {
GtkWidget *dialog = GTK_WIDGET(gtk_builder_get_object(builder, "xfce4_session_settings_dialog"));
g_signal_connect(dialog, "response", G_CALLBACK(xfce4_session_settings_dialog_response), NULL);
g_signal_connect(dialog, "delete-event", G_CALLBACK(gtk_main_quit), NULL);
gtk_widget_show(dialog);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main();
} else {
GtkWidget *plug, *plug_child;
plug = gtk_plug_new(opt_socket_id);
gtk_widget_show(plug);
g_signal_connect(plug, "delete-event",
G_CALLBACK(gtk_main_quit), NULL);
plug_child = GTK_WIDGET(gtk_builder_get_object(builder, "plug-child"));
gtk_widget_reparent(plug_child, plug);
gtk_widget_show(plug_child);
/* Stop startup notification */
gdk_notify_startup_complete();
gtk_main();
}
g_object_unref(builder);
return EXIT_SUCCESS;
}
gint
main(gint argc, gchar **argv)
{
GtkWidget *dialog;
GtkWidget *settings_editor;
GtkWidget *plug;
GError *error = NULL;
/* setup translation domain */
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
/* initialize Gtk+ */
if (!gtk_init_with_args (&argc, &argv, "", option_entries, GETTEXT_PACKAGE, &error))
{
if (G_LIKELY (error))
{
/* print error */
g_print ("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_print (_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_print ("\n");
/* cleanup */
g_error_free (error);
}
else
{
g_error ("Unable to open display.");
}
return EXIT_FAILURE;
}
/* print version information */
if (G_UNLIKELY (opt_version))
{
g_print ("%s %s (Xfce %s)\n\n", G_LOG_DOMAIN, PACKAGE_VERSION, xfce_version_string ());
g_print ("%s\n", "Copyright (c) 2008-2011");
g_print ("\t%s\n\n", _("The Xfce development team. All rights reserved."));
g_print (_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print ("\n");
return EXIT_SUCCESS;
}
/* initialize xfconf */
if (G_UNLIKELY (!xfconf_init (&error)))
{
/* print error and leave */
g_critical ("Failed to connect to Xfconf daemon: %s", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
channel = xfconf_channel_new ("xfce4-settings-editor");
settings_editor = xfce_settings_editor_box_new (
xfconf_channel_get_int (channel, "/last/paned-position", 180));
if (G_UNLIKELY (opt_socket_id == 0))
{
dialog = xfce_titled_dialog_new_with_buttons (_("Settings Editor"), NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
"gtk-help", GTK_RESPONSE_HELP,
"gtk-close", GTK_RESPONSE_OK,
NULL);
xfce_titled_dialog_set_subtitle (XFCE_TITLED_DIALOG (dialog),
_("Customize settings stored by Xfconf"));
gtk_window_set_icon_name (GTK_WINDOW (dialog), "preferences-system");
gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_default_size (GTK_WINDOW (dialog),
xfconf_channel_get_int (channel, "/last/window-width", 640),
xfconf_channel_get_int (channel, "/last/window-height", 500));
gtk_container_add_with_properties(
GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),
settings_editor,
"expand", TRUE,
"fill", TRUE,
NULL);
g_signal_connect (dialog, "response",
G_CALLBACK (settings_dialog_response), settings_editor);
gtk_widget_show_all (dialog);
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (plug_delete_event), settings_editor);
gtk_window_set_default_size (GTK_WINDOW (plug),
xfconf_channel_get_int (channel, "/last/window-width", 640),
xfconf_channel_get_int (channel, "/last/window-height", 500));
gtk_widget_show (plug);
gtk_container_add (GTK_CONTAINER(plug), settings_editor);
/* Stop startup notification */
gdk_notify_startup_complete ();
gtk_widget_show (GTK_WIDGET (settings_editor));
}
gtk_main ();
g_object_unref(channel);
/* shutdown xfconf */
xfconf_shutdown ();
return EXIT_SUCCESS;
}
/* panel_window_new */
PanelWindow * panel_window_new(PanelAppletHelper * helper,
PanelWindowType type, PanelWindowPosition position,
GtkIconSize iconsize, GdkRectangle * root)
{
PanelWindow * panel;
int icon_width;
int icon_height;
GtkOrientation orientation;
if(gtk_icon_size_lookup(iconsize, &icon_width, &icon_height) != TRUE)
{
error_set_code(1, _("Invalid panel size"));
return NULL;
}
if((panel = object_new(sizeof(*panel))) == NULL)
return NULL;
panel->type = type;
panel->position = position;
panel->iconsize = iconsize;
panel->helper = helper;
panel->applets = NULL;
panel->applets_cnt = 0;
if(position != PANEL_WINDOW_POSITION_EMBEDDED)
{
panel->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#if GTK_CHECK_VERSION(3, 0, 0) && !GTK_CHECK_VERSION(3, 14, 0)
gtk_window_set_has_resize_grip(GTK_WINDOW(panel->window),
FALSE);
#endif
}
else
{
panel->window = gtk_plug_new(0);
gtk_widget_show(panel->window);
}
gtk_container_set_border_width(GTK_CONTAINER(panel->window), 2);
panel->height = icon_height + (PANEL_BORDER_WIDTH * 4);
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() %u height=%d\n", __func__, position,
panel->height);
#endif
panel->box = NULL;
orientation = panel_window_get_orientation(panel);
#if GTK_CHECK_VERSION(3, 0, 0)
panel->box = gtk_box_new(orientation, 2);
#else
panel->box = (orientation == GTK_ORIENTATION_HORIZONTAL)
? gtk_hbox_new(FALSE, 2) : gtk_vbox_new(FALSE, 2);
#endif
switch(position)
{
case PANEL_WINDOW_POSITION_TOP:
case PANEL_WINDOW_POSITION_BOTTOM:
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_focus_on_map(GTK_WINDOW(panel->window),
FALSE);
#endif
gtk_window_set_type_hint(GTK_WINDOW(panel->window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_stick(GTK_WINDOW(panel->window));
g_signal_connect(panel->window, "configure-event",
G_CALLBACK(_panel_window_on_configure_event),
panel);
break;
case PANEL_WINDOW_POSITION_LEFT:
case PANEL_WINDOW_POSITION_RIGHT:
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_focus_on_map(GTK_WINDOW(panel->window),
FALSE);
#endif
gtk_window_set_type_hint(GTK_WINDOW(panel->window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_stick(GTK_WINDOW(panel->window));
g_signal_connect(panel->window, "configure-event",
G_CALLBACK(_panel_window_on_configure_event),
panel);
break;
case PANEL_WINDOW_POSITION_CENTER:
gtk_window_set_position(GTK_WINDOW(panel->window),
GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_stick(GTK_WINDOW(panel->window));
/* fallback */
case PANEL_WINDOW_POSITION_FLOATING:
gtk_window_set_accept_focus(GTK_WINDOW(panel->window),
FALSE);
gtk_window_set_decorated(GTK_WINDOW(panel->window),
FALSE);
case PANEL_WINDOW_POSITION_EMBEDDED:
case PANEL_WINDOW_POSITION_MANAGED:
break;
}
g_signal_connect_swapped(panel->window, "delete-event", G_CALLBACK(
_panel_window_on_closex), panel);
gtk_container_add(GTK_CONTAINER(panel->window), panel->box);
gtk_widget_show_all(panel->box);
panel_window_reset(panel, root);
return panel;
}
gint
main (gint argc, gchar **argv)
{
GObject *dialog, *plug_child;
GtkWidget *plug;
GtkBuilder *builder;
GError *error = NULL;
/* setup translation domain */
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
/* initialize Gtk+ */
if(!gtk_init_with_args (&argc, &argv, "", entries, PACKAGE, &error))
{
if (G_LIKELY (error))
{
/* print error */
g_print ("%s: %s.\n", G_LOG_DOMAIN, error->message);
g_print (_("Type '%s --help' for usage."), G_LOG_DOMAIN);
g_print ("\n");
/* cleanup */
g_error_free (error);
}
else
{
g_error ("Unable to open display.");
}
return EXIT_FAILURE;
}
/* check if we should print version information */
if (G_UNLIKELY (opt_version))
{
g_print ("%s %s (Xfce %s)\n\n", G_LOG_DOMAIN, PACKAGE_VERSION, xfce_version_string ());
g_print ("%s\n", "Copyright (c) 2008-2011");
g_print ("\t%s\n\n", _("The Xfce development team. All rights reserved."));
g_print (_("Please report bugs to <%s>."), PACKAGE_BUGREPORT);
g_print ("\n");
return EXIT_SUCCESS;
}
/* initialize xfconf */
if (!xfconf_init (&error))
{
/* print error and exit */
g_error ("Failed to connect to xfconf daemon: %s.", error->message);
g_error_free (error);
return EXIT_FAILURE;
}
/* open the channels */
accessibility_channel = xfconf_channel_new ("accessibility");
session_channel = xfconf_channel_new ("xfce4-session");
/* hook to make sure the libxfce4ui library is linked */
if (xfce_titled_dialog_get_type () == 0)
return EXIT_FAILURE;
/* load the Gtk user-interface file */
builder = gtk_builder_new ();
if (gtk_builder_add_from_string (builder, accessibility_dialog_ui,
accessibility_dialog_ui_length, &error) != 0)
{
/* Configure widgets */
accessibility_settings_dialog_configure_widgets (builder);
if (G_UNLIKELY (opt_socket_id == 0))
{
/* Get the dialog widget */
dialog = gtk_builder_get_object (builder, "dialog");
g_signal_connect (dialog, "response",
G_CALLBACK (accessibility_settings_dialog_response), NULL);
gtk_window_present (GTK_WINDOW (dialog));
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main ();
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (plug);
/* Stop startup notification */
gdk_notify_startup_complete ();
/* Get plug child widget */
plug_child = gtk_builder_get_object (builder, "plug-child");
gtk_widget_reparent (GTK_WIDGET (plug_child), plug);
gtk_widget_show (GTK_WIDGET (plug_child));
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
/* Enter main loop */
gtk_main ();
}
}
else
{
g_error ("Failed to load the UI file: %s.", error->message);
g_error_free (error);
}
/* Release Builder */
g_object_unref (G_OBJECT (builder));
/* release the channels */
g_object_unref (G_OBJECT (accessibility_channel));
g_object_unref (G_OBJECT (session_channel));
/* shutdown xfconf */
xfconf_shutdown();
return EXIT_SUCCESS;
}
int
main (int argc, gchar **argv)
{
GtkWidget *dialog;
GtkWidget *plug;
GtkWidget *plug_child;
GtkBuilder *builder;
GError *cli_error = NULL;
const gchar *wm_name;
#ifdef ENABLE_NLS
xfce_textdomain (GETTEXT_PACKAGE, LOCALEDIR, "UTF-8");
#endif
if (!gtk_init_with_args (&argc, &argv, _ ("."), entries, PACKAGE, &cli_error))
{
if (cli_error != NULL)
{
g_print (_ ("%s: %s\nTry %s --help to see a full list of available command line options.\n"), PACKAGE, cli_error->message, PACKAGE_NAME);
g_error_free (cli_error);
return 1;
}
}
wm_name = gdk_x11_screen_get_window_manager_name (gdk_screen_get_default ());
if (G_UNLIKELY (g_ascii_strcasecmp (wm_name, "Xfwm4")))
{
g_print ("These settings cannot work with your current window manager (%s)\n", wm_name);
return 1;
}
if (opt_version)
{
g_print ("%s\n", PACKAGE_STRING);
return 0;
}
xfconf_init (NULL);
builder = gtk_builder_new ();
if (xfce_titled_dialog_get_type () == 0)
return 1;
gtk_builder_add_from_string (builder, tweaks_dialog_ui, tweaks_dialog_ui_length, NULL);
if (builder)
{
wm_tweaks_dialog_configure_widgets (builder);
if (opt_socket_id == 0)
{
dialog = GTK_WIDGET (gtk_builder_get_object (builder, "main-dialog"));
gtk_widget_show (dialog);
g_signal_connect (dialog, "response", G_CALLBACK (wm_tweaks_dialog_response), NULL);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
gtk_main ();
gtk_widget_destroy (dialog);
}
else
{
/* Create plug widget */
plug = gtk_plug_new (opt_socket_id);
g_signal_connect (plug, "delete-event", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show (plug);
/* Get plug child widget */
plug_child = GTK_WIDGET (gtk_builder_get_object (builder, "plug-child"));
gtk_widget_reparent (plug_child, plug);
gtk_widget_show (plug_child);
/* To prevent the settings dialog to be saved in the session */
gdk_set_sm_client_id ("FAKE ID");
/* Stop startup notification */
gdk_notify_startup_complete ();
/* Enter main loop */
gtk_main ();
}
g_object_unref (builder);
}
xfconf_shutdown ();
return 0;
}
