nsDragService::nsDragService()
{
// We have to destroy the hidden widget before the event loop stops
// running.
nsCOMPtr<nsIObserverService> obsServ =
do_GetService("@mozilla.org/observer-service;1");
obsServ->AddObserver(this, "quit-application", PR_FALSE);
// our hidden source widget
mHiddenWidget = gtk_invisible_new();
// make sure that the widget is realized so that
// we can use it as a drag source.
gtk_widget_realize(mHiddenWidget);
// hook up our internal signals so that we can get some feedback
// from our drag source
gtk_signal_connect(GTK_OBJECT(mHiddenWidget), "drag_data_get",
GTK_SIGNAL_FUNC(invisibleSourceDragDataGet), this);
gtk_signal_connect(GTK_OBJECT(mHiddenWidget), "drag_end",
GTK_SIGNAL_FUNC(invisibleSourceDragEnd), this);
// set up our logging module
if (!sDragLm)
sDragLm = PR_NewLogModule("nsDragService");
PR_LOG(sDragLm, PR_LOG_DEBUG, ("nsDragService::nsDragService"));
mTargetWidget = 0;
mTargetDragContext = 0;
mTargetTime = 0;
mCanDrop = PR_FALSE;
mTargetDragDataReceived = PR_FALSE;
mTargetDragData = 0;
mTargetDragDataLen = 0;
}
static CsdLocatePointerData *
csd_locate_pointer_data_new (GdkScreen *screen)
{
CsdLocatePointerData *data;
data = g_new0 (CsdLocatePointerData, 1);
/* this widget will never be shown, it's
* mainly used to get signals/events from
*/
data->widget = gtk_invisible_new ();
gtk_widget_realize (data->widget);
g_signal_connect (G_OBJECT (data->widget), "draw",
G_CALLBACK (locate_pointer_draw),
data);
data->timeline = csd_timeline_new (ANIMATION_LENGTH);
g_signal_connect (data->timeline, "frame",
G_CALLBACK (timeline_frame_cb), data);
g_signal_connect (data->timeline, "finished",
G_CALLBACK (timeline_finished_cb), data);
create_window (data, screen);
return data;
}
void Selection::create_selection_widget()
{
if (selection_widget)
gtk_widget_destroy(selection_widget);
selection_widget = gtk_invisible_new ();
g_signal_connect (G_OBJECT (selection_widget), "selection_received", G_CALLBACK (SelectionReceivedCallback), this);
}
//
// Create the navigator widget
//
NavGtk::NavGtk(
void *nav_parent_ctx,
GtkWidget *nav_parent_wid,
const char *nav_name,
ldh_tSesContext nav_ldhses,
const char *nav_root_name,
GtkWidget **w,
pwr_tStatus *status
) :
Nav(nav_parent_ctx,nav_name,nav_ldhses,nav_root_name,status),
parent_wid(nav_parent_wid)
{
GtkWidget *scrolledbrow = scrolledbrowwidgetgtk_new(
Nav::init_brow_cb, this, &brow_widget);
form_widget = gtk_frame_new( NULL);
gtk_container_add( GTK_CONTAINER(form_widget), scrolledbrow);
gtk_container_set_border_width( GTK_CONTAINER(scrolledbrow), 3);
selection_widget = gtk_invisible_new();
gtk_selection_add_target( selection_widget, GDK_SELECTION_PRIMARY,
GDK_SELECTION_TYPE_STRING, 1);
g_signal_connect( selection_widget, "selection-get",
G_CALLBACK( nav_sel_convert_cb), this);
sel_lose_id = g_signal_connect( selection_widget, "selection-clear-event",
G_CALLBACK( nav_sel_lose_cb), this);
gtk_widget_show_all( brow_widget);
set_inputfocus(0);
*w = form_widget;
*status = 1;
}
gboolean
CopyPasteDnDX11::Init(ToolsAppCtx *ctx)
{
TRACE_CALL();
CopyPasteDnDWrapper *wrapper = CopyPasteDnDWrapper::GetInstance();
ASSERT(ctx);
int argc = 1;
const char *argv[] = {"", NULL};
m_main = new Gtk::Main(&argc, (char ***) &argv, false);
if (wrapper) {
BlockService::GetInstance()->Init(ctx);
}
gUserMainWidget = gtk_invisible_new();
#ifndef GTK3
gXDisplay = GDK_WINDOW_XDISPLAY(gUserMainWidget->window);
#else
gXDisplay = GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gUserMainWidget));
#endif
gXRoot = RootWindow(gXDisplay, DefaultScreen(gXDisplay));
/*
* Register legacy (backdoor) version of copy paste.
*/
CopyPaste_SetVersion(1);
CopyPaste_Register(gUserMainWidget, ctx);
return TRUE;
}
static void
gs_grab_init (GSGrab *grab)
{
grab->priv = GS_GRAB_GET_PRIVATE (grab);
grab->priv->mouse_hide_cursor = FALSE;
grab->priv->invisible = gtk_invisible_new ();
gtk_widget_show (grab->priv->invisible);
}
static void
gimp_pick_button_clicked (GtkButton *gtk_button)
{
GimpPickButton *button = GIMP_PICK_BUTTON (gtk_button);
GtkWidget *widget;
guint32 timestamp;
if (! button->cursor)
button->cursor = make_cursor (gtk_widget_get_display (GTK_WIDGET (gtk_button)));
if (! button->grab_widget)
{
button->grab_widget = gtk_invisible_new ();
gtk_widget_add_events (button->grab_widget,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_POINTER_MOTION_MASK);
gtk_widget_show (button->grab_widget);
}
widget = button->grab_widget;
timestamp = gtk_get_current_event_time ();
if (gdk_keyboard_grab (gtk_widget_get_window (widget), FALSE,
timestamp) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab keyboard to do eyedropper");
return;
}
if (gdk_pointer_grab (gtk_widget_get_window (widget), FALSE,
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_POINTER_MOTION_MASK,
NULL,
button->cursor,
timestamp) != GDK_GRAB_SUCCESS)
{
gdk_display_keyboard_ungrab (gtk_widget_get_display (widget), timestamp);
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
gtk_grab_add (widget);
g_signal_connect (widget, "button-press-event",
G_CALLBACK (gimp_pick_button_mouse_press),
button);
g_signal_connect (widget, "key-press-event",
G_CALLBACK (gimp_pick_button_key_press),
button);
}
static void
gs_grab_init (GSGrab *grab)
{
grab->priv = GS_GRAB_GET_PRIVATE (grab);
grab->priv->session_bus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
grab->priv->mouse_hide_cursor = FALSE;
grab->priv->invisible = gtk_invisible_new ();
gtk_widget_show (grab->priv->invisible);
}
InitHandle
ResolutionToolkitInit(void)
{
int argc = 1;
char *argv[] = {"", NULL};
GtkWidget *wnd;
Display *display;
gtk_init(&argc, (char ***) &argv);
wnd = gtk_invisible_new();
display = GDK_WINDOW_XDISPLAY(wnd->window);
return (InitHandle) display;
}
static void
begin_area_grab (void)
{
GdkWindow *window;
GdkDeviceManager *manager;
GdkDevice *device;
if (grab_widget == NULL)
{
grab_widget = gtk_invisible_new ();
gtk_widget_add_events (grab_widget,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
gtk_widget_show (grab_widget);
}
window = gtk_widget_get_window (grab_widget);
manager = gdk_display_get_device_manager (gdk_display_get_default ());
device = gdk_device_manager_get_client_pointer (manager);
if (gdk_device_grab (device,
window,
GDK_OWNERSHIP_NONE,
FALSE,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
if (gdk_device_grab (gdk_device_get_associated_device (device),
window,
GDK_OWNERSHIP_NONE,
FALSE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
gdk_device_ungrab (device, gtk_get_current_event_time ());
g_warning ("Failed to grab keyboard to do eyedropper");
return;
}
gtk_grab_add (grab_widget);
g_signal_connect (grab_widget, "button_press_event",
G_CALLBACK (mouse_press), NULL);
g_signal_connect (grab_widget, "key_press_event",
G_CALLBACK (key_press), NULL);
}
char* iupdrvGetSystemFont(void)
{
static char systemfont[200] = "";
GtkStyle* style;
GtkWidget* widget = gtk_invisible_new();
gtk_widget_realize(widget);
style = gtk_widget_get_style(widget);
if (!style || !style->font_desc)
strcpy(systemfont, "Sans, 10");
else
strcpy(systemfont, pango_font_description_to_string(style->font_desc));
gtk_widget_unrealize(widget);
gtk_widget_destroy(widget);
return systemfont;
}
/* entry point to this file, called from gimppickbutton.c */
void
_gimp_pick_button_default_pick (GimpPickButton *button)
{
GdkDisplay *display;
GtkWidget *widget;
if (! button->priv->cursor)
button->priv->cursor =
make_cursor (gtk_widget_get_display (GTK_WIDGET (button)));
if (! button->priv->grab_widget)
{
button->priv->grab_widget = gtk_invisible_new ();
gtk_widget_add_events (button->priv->grab_widget,
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_BUTTON1_MOTION_MASK);
gtk_widget_show (button->priv->grab_widget);
}
widget = button->priv->grab_widget;
display = gtk_widget_get_display (widget);
if (gdk_seat_grab (gdk_display_get_default_seat (display),
gtk_widget_get_window (widget),
GDK_SEAT_CAPABILITY_ALL,
FALSE,
button->priv->cursor,
NULL,
NULL, NULL) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab seat to do eyedropper");
return;
}
gtk_grab_add (widget);
g_signal_connect (widget, "button-press-event",
G_CALLBACK (gimp_pick_button_mouse_press),
button);
g_signal_connect (widget, "key-press-event",
G_CALLBACK (gimp_pick_button_key_press),
button);
}
static GimpProgress *
gimp_tool_progress_start (GimpProgress *progress,
const gchar *message,
gboolean cancelable)
{
GimpTool *tool = GIMP_TOOL (progress);
GimpDisplayShell *shell;
gint x, y;
g_return_val_if_fail (GIMP_IS_DISPLAY (tool->display), NULL);
g_return_val_if_fail (tool->progress == NULL, NULL);
shell = gimp_display_get_shell (tool->display);
x = shell->disp_width / 2;
y = shell->disp_height / 2;
gimp_display_shell_unzoom_xy (shell, x, y, &x, &y, FALSE);
tool->progress = gimp_canvas_progress_new (shell,
GIMP_HANDLE_ANCHOR_CENTER,
x, y);
gimp_display_shell_add_unrotated_item (shell, tool->progress);
g_object_unref (tool->progress);
gimp_progress_start (GIMP_PROGRESS (tool->progress),
message, FALSE);
gimp_widget_flush_expose (shell->canvas);
tool->progress_display = tool->display;
if (cancelable)
{
tool->progress_grab_widget = gtk_invisible_new ();
gtk_widget_show (tool->progress_grab_widget);
gtk_grab_add (tool->progress_grab_widget);
g_signal_connect (tool->progress_grab_widget, "button-press-event",
G_CALLBACK (gimp_tool_progress_button_press),
tool);
g_signal_connect (tool->progress_grab_widget, "key-press-event",
G_CALLBACK (gimp_tool_progress_key_press),
tool);
}
return progress;
}
nsresult
nsClipboard::Init(void)
{
mWidget = gtk_invisible_new();
if (!mWidget)
return NS_ERROR_FAILURE;
g_signal_connect(G_OBJECT(mWidget), "selection_get",
G_CALLBACK(invisible_selection_get_cb), this);
g_signal_connect(G_OBJECT(mWidget), "selection_clear_event",
G_CALLBACK(selection_clear_event_cb), this);
// XXX make sure to set up the selection_clear event
return NS_OK;
}
static gboolean
drw_selection_claim (DrwSelection *drw_selection)
{
drw_selection->invisible = gtk_invisible_new ();
g_signal_connect (drw_selection->invisible, "selection-clear-event",
G_CALLBACK (drw_selection_clear), drw_selection);
if (gtk_selection_owner_set (drw_selection->invisible,
gdk_atom_intern (SELECTION_NAME, FALSE),
GDK_CURRENT_TIME)) {
return TRUE;
} else {
drw_selection_reset (drw_selection);
return FALSE;
}
}
NS_IMETHODIMP
nsGTKRemoteService::Startup(const char* aAppName, const char* aProfileName)
{
NS_ASSERTION(aAppName, "Don't pass a null appname!");
sRemoteImplementation = this;
if (mServerWindow) return NS_ERROR_ALREADY_INITIALIZED;
XRemoteBaseStartup(aAppName, aProfileName);
mServerWindow = gtk_invisible_new();
gtk_widget_realize(mServerWindow);
HandleCommandsFor(mServerWindow, nullptr);
mWindows.EnumerateRead(StartupHandler, this);
return NS_OK;
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
static int have_selection = FALSE;
gtk_init (&argc, &argv);
/* Create the toplevel window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Event Box");
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
g_signal_connect (window, "destroy",
G_CALLBACK (exit), NULL);
/* Create a toggle button to act as the selection */
selection_widget = gtk_invisible_new ();
selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
gtk_container_add (GTK_CONTAINER (window), selection_button);
gtk_widget_show (selection_button);
g_signal_connect (selection_button, "toggled",
G_CALLBACK (selection_toggled), (gpointer) &have_selection);
g_signal_connect (selection_widget, "selection_clear_event",
G_CALLBACK (selection_clear), (gpointer) &have_selection);
gtk_selection_add_target (selection_widget,
GDK_SELECTION_PRIMARY,
GDK_SELECTION_TYPE_STRING,
1);
g_signal_connect (selection_widget, "selection_get",
G_CALLBACK (selection_handle), (gpointer) &have_selection);
gtk_widget_show (selection_button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
gboolean
CopyPasteDnDX11::Init(ToolsAppCtx *ctx)
{
TRACE_CALL();
#if GTK_MAJOR_VERSION > 3 || (GTK_MAJOR_VERSION == 3 && GTK_MINOR_VERSION >= 10)
/*
* On recent distros, Wayland is the default display server. If the obtained
* display or window is a wayland one, applying X11 specific functions on them
* will result in crashes. Before migrating the X11 specific code to Wayland,
* force using X11 as the backend of Gtk+3. gdk_set_allowed_backends() is
* introduced since Gtk+3.10 and Wayland is supported from Gtk+3.10.
*/
gdk_set_allowed_backends("x11");
#endif
CopyPasteDnDWrapper *wrapper = CopyPasteDnDWrapper::GetInstance();
ASSERT(ctx);
int argc = 1;
const char *argv[] = {"", NULL};
m_main = new Gtk::Main(&argc, (char ***) &argv, false);
if (wrapper) {
BlockService::GetInstance()->Init(ctx);
}
gUserMainWidget = gtk_invisible_new();
#ifndef GTK3
gXDisplay = GDK_WINDOW_XDISPLAY(gUserMainWidget->window);
#else
gXDisplay = GDK_WINDOW_XDISPLAY(gtk_widget_get_window(gUserMainWidget));
#endif
gXRoot = RootWindow(gXDisplay, DefaultScreen(gXDisplay));
/*
* Register legacy (backdoor) version of copy paste.
*/
CopyPaste_SetVersion(1);
CopyPaste_Register(gUserMainWidget, ctx);
return TRUE;
}
static VALUE
rg_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE screen;
rb_scan_args(argc, argv, "01", &screen);
if (argc == 0){
RBGTK_INITIALIZE(self, gtk_invisible_new());
} else {
#if GTK_CHECK_VERSION(2,2,0)
RBGTK_INITIALIZE(self, gtk_invisible_new_for_screen(
GDK_SCREEN(RVAL2GOBJ(screen))));
#else
rb_raise(rb_eArgError, "GTK+-2.2 feature. GTK+-2.0.x doesn't support this.");
#endif
}
return Qnil;
}
NS_IMETHODIMP
nsGTKRemoteService::Startup(const char* aAppName, const char* aProfileName)
{
NS_ASSERTION(aAppName, "Don't pass a null appname!");
sRemoteImplementation = this;
if (mServerWindow) return NS_ERROR_ALREADY_INITIALIZED;
XRemoteBaseStartup(aAppName, aProfileName);
mServerWindow = gtk_invisible_new();
gtk_widget_realize(mServerWindow);
HandleCommandsFor(mServerWindow, nullptr);
for (auto iter = mWindows.Iter(); !iter.Done(); iter.Next()) {
HandleCommandsFor(iter.Key(), iter.UserData());
}
return NS_OK;
}
static void
begin_area_grab (void)
{
if (grab_widget == NULL)
{
grab_widget = gtk_invisible_new ();
gtk_widget_add_events (grab_widget,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
gtk_widget_show (grab_widget);
}
if (gdk_keyboard_grab (gtk_widget_get_window (grab_widget),
FALSE,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
g_warning ("Failed to grab keyboard to do eyedropper");
return;
}
if (gdk_pointer_grab (gtk_widget_get_window (grab_widget),
FALSE,
GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK,
NULL,
NULL,
gtk_get_current_event_time ()) != GDK_GRAB_SUCCESS)
{
gdk_keyboard_ungrab (GDK_CURRENT_TIME);
g_warning ("Failed to grab pointer to do eyedropper");
return;
}
gtk_grab_add (grab_widget);
g_signal_connect (grab_widget, "button_press_event",
G_CALLBACK (mouse_press), NULL);
g_signal_connect (grab_widget, "key_press_event",
G_CALLBACK (key_press), NULL);
}
int
clip_GTK_INVISIBLENEW(ClipMachine * ClipMachineMemory)
{
ClipVar *cv = _clip_spar(ClipMachineMemory, 1);
C_widget *cwid = NULL;
GtkWidget *wid;
CHECKOPT(1, MAP_type_of_ClipVarType);
wid = gtk_invisible_new();
if (!wid)
goto err;
cwid = _register_widget(ClipMachineMemory, wid, cv);
_clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
return 0;
err:
return 1;
}
static void
mailwatch_set_size(Control *c, gint size)
{
XfceMailwatchPlugin *mwp = c->data;
gint wsize = icon_size[size] + border_width, i;
GtkWidget *dummy;
gchar *icon;
if(mwp->pix_normal)
g_object_unref(G_OBJECT(mwp->pix_normal));
if(mwp->pix_newmail)
g_object_unref(G_OBJECT(mwp->pix_newmail));
for(i = 0; i < XFCE_MAILWATCH_N_LOG_LEVELS; i++) {
if(mwp->pix_log[i])
g_object_unref(G_OBJECT(mwp->pix_log[i]));
}
icon = mwp->normal_icon ? mwp->normal_icon : DEFAULT_NORMAL_ICON;
mwp->pix_normal = xfce_themed_icon_load(icon, icon_size[size]);
icon = mwp->new_mail_icon ? mwp->new_mail_icon : DEFAULT_NEW_MAIL_ICON;
mwp->pix_newmail = xfce_themed_icon_load(icon, icon_size[size]);
dummy = gtk_invisible_new();
gtk_widget_realize(dummy);
mwp->pix_log[XFCE_MAILWATCH_LOG_INFO] =
mailwatch_get_mini_icon(dummy, GTK_STOCK_DIALOG_INFO, size);
mwp->pix_log[XFCE_MAILWATCH_LOG_WARNING] =
mailwatch_get_mini_icon(dummy, GTK_STOCK_DIALOG_WARNING, size);
mwp->pix_log[XFCE_MAILWATCH_LOG_ERROR] =
mailwatch_get_mini_icon(dummy, GTK_STOCK_DIALOG_ERROR, size);
gtk_widget_destroy(dummy);
mailwatch_set_icon(mwp, mwp->newmail_icon_visible);
gtk_widget_set_size_request(c->base, wsize, wsize);
}
int
main (int argc, char *argv[])
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *table;
GtkWidget *label;
GtkWidget *entry;
GtkWidget *hscrollbar;
GtkWidget *vscrollbar;
GtkWidget *hbox;
static GtkTargetEntry targetlist[] = {
{ "STRING", 0, STRING },
{ "TEXT", 0, TEXT },
{ "COMPOUND_TEXT", 0, COMPOUND_TEXT }
};
static gint ntargets = sizeof(targetlist) / sizeof(targetlist[0]);
gtk_init (&argc, &argv);
init_atoms();
selection_widget = gtk_invisible_new ();
dialog = gtk_dialog_new ();
gtk_widget_set_name (dialog, "Test Input");
gtk_container_set_border_width (GTK_CONTAINER(dialog), 0);
g_signal_connect (dialog, "destroy",
G_CALLBACK (quit), NULL);
table = gtk_table_new (4, 2, FALSE);
gtk_container_set_border_width (GTK_CONTAINER(table), 10);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 5);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 2, 2);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 2);
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->vbox),
table, TRUE, TRUE, 0);
gtk_widget_show (table);
selection_button = gtk_toggle_button_new_with_label ("Claim Selection");
gtk_table_attach (GTK_TABLE (table), selection_button, 0, 2, 0, 1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (selection_button);
g_signal_connect (selection_button, "toggled",
G_CALLBACK (selection_toggled), NULL);
g_signal_connect (selection_widget, "selection_clear_event",
G_CALLBACK (selection_clear), NULL);
g_signal_connect (selection_widget, "selection_received",
G_CALLBACK (selection_received), NULL);
gtk_selection_add_targets (selection_widget, GDK_SELECTION_PRIMARY,
targetlist, ntargets);
g_signal_connect (selection_widget, "selection_get",
G_CALLBACK (selection_get), NULL);
selection_text = gtk_text_new (NULL, NULL);
gtk_table_attach_defaults (GTK_TABLE (table), selection_text, 0, 1, 1, 2);
gtk_widget_show (selection_text);
hscrollbar = gtk_hscrollbar_new (GTK_TEXT (selection_text)->hadj);
gtk_table_attach (GTK_TABLE (table), hscrollbar, 0, 1, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (hscrollbar);
vscrollbar = gtk_vscrollbar_new (GTK_TEXT (selection_text)->vadj);
gtk_table_attach (GTK_TABLE (table), vscrollbar, 1, 2, 1, 2,
GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (vscrollbar);
hbox = gtk_hbox_new (FALSE, 2);
gtk_table_attach (GTK_TABLE (table), hbox, 0, 2, 3, 4,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_widget_show (hbox);
label = gtk_label_new ("Target:");
gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
gtk_widget_show (label);
entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX(hbox), entry, TRUE, TRUE, 0);
gtk_widget_show (entry);
/* .. And create some buttons */
button = gtk_button_new_with_label ("Paste");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect (button, "clicked",
G_CALLBACK (paste), entry);
gtk_widget_show (button);
button = gtk_button_new_with_label ("Quit");
gtk_box_pack_start (GTK_BOX (GTK_DIALOG(dialog)->action_area),
button, TRUE, TRUE, 0);
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy), dialog);
gtk_widget_show (button);
gtk_widget_show (dialog);
gtk_main ();
return 0;
}
int
fe_args (int argc, char *argv[])
{
#ifdef USE_GNOME
struct poptOption options[] = {
{"cfgdir", 'd', POPT_ARG_STRING, 0, 0, _("Config dir"), 0},
{"noauto", 'a', POPT_ARG_NONE, 0, 0, _("Don't Auto connect"), 0},
#ifdef USE_PANEL
{"no-panel", 'n', POPT_ARG_NONE, 0, 0, _("Don't use GNOME Panel"), 0},
#endif
POPT_AUTOHELP {0, '\0', 0, 0}
};
#endif
if (argc > 1)
{
if (!strcasecmp (argv[1], "-a") || !strcasecmp (argv[1], "--noauto"))
{
auto_connect = 0;
}
#ifdef USE_PANEL
if (!strcasecmp (argv[1], "-n") || !strcasecmp (argv[1], "--no-panel"))
{
nopanel = TRUE;
}
#endif
if (!strcasecmp (argv[1], "-v") || !strcasecmp (argv[1], "--version"))
{
printf (PACKAGE" "VERSION"\n");
return 0;
}
#ifndef USE_GNOME
#ifdef ENABLE_NLS
bindtextdomain (PACKAGE, PREFIX"/share/locale");
textdomain (PACKAGE);
#endif
if (!strcasecmp (argv[1], "-h") || !strcasecmp (argv[1], "--help"))
{
printf(_("%s %s Options:\n\n"
" --cfgdir <dir> -d\t : use a different config dir\n"
" --noauto -a\t : don't auto connect\n"
" --version -v\t : show version information\n"
), PACKAGE, VERSION);
return 0;
}
#endif
}
#ifdef ENABLE_NLS
#ifdef USE_GNOME
bindtextdomain (PACKAGE, PREFIX"/share/locale");
textdomain (PACKAGE);
#endif
#endif
if (argc > 2)
{
if (!strcasecmp (argv[1], "-d") || !strcasecmp (argv[1], "--cfgdir"))
{
xdir = strdup (argv[2]);
if (xdir[strlen (xdir) - 1] == '/')
xdir[strlen (xdir) - 1] = 0;
}
}
#ifndef USE_GNOME
gtk_set_locale ();
#endif
#ifdef USE_PANEL
if (nopanel)
gnome_init_with_popt_table (argv[0], VERSION, argc, argv, options, 0, 0);
else {
CORBA_Environment ev;
CORBA_exception_init (&ev);
gnome_CORBA_init_with_popt_table (argv[0], VERSION,
&argc, argv, options, 0, 0,
GNORBA_INIT_SERVER_FUNC, &ev);
CORBA_exception_free (&ev);
}
#else
#ifdef USE_GNOME
gnome_init_with_popt_table (argv[0], VERSION, argc, argv, options, 0, 0);
#else
gtk_init (&argc, &argv);
#endif
#endif
#ifndef USE_GNOME
#ifdef USE_GDK_PIXBUF
gdk_rgb_init();
#endif
#endif
#ifdef USE_XLIB
proxy_invisible = gtk_invisible_new ();
gtk_widget_show (proxy_invisible);
/* Make the root window send events to the invisible proxy widget */
gdk_window_set_user_data (GDK_ROOT_PARENT (), proxy_invisible);
/* Select for PropertyNotify events from the root window */
XSelectInput (GDK_DISPLAY (), GDK_ROOT_WINDOW (), PropertyChangeMask);
gtk_signal_connect (GTK_OBJECT (proxy_invisible), "property-notify-event",
GTK_SIGNAL_FUNC (handle_property_notify), NULL);
#endif
return 1;
}
