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; }