// XXXdholbert -- this function is duplicated in nsPrintDialogGTK.cpp
// and needs to be unified in some generic utility class.
static GtkWindow *
get_gtk_window_for_nsiwidget(nsIWidget *widget)
{
// Get native GdkWindow
GdkWindow *gdk_win = GDK_WINDOW(widget->GetNativeData(NS_NATIVE_WIDGET));
if (!gdk_win)
return NULL;
// Get the container
gpointer user_data = NULL;
gdk_window_get_user_data(gdk_win, &user_data);
if (!user_data)
return NULL;
// Make sure its really a container
MozContainer *parent_container = MOZ_CONTAINER(user_data);
if (!parent_container)
return NULL;
// Get its toplevel
return GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(parent_container)));
}
static void
gam_app_save_prefs (GamApp *gam_app)
{
GamAppPrivate *priv;
gint height, width;
g_return_if_fail (GAM_IS_APP (gam_app));
priv = GAM_APP_GET_PRIVATE (gam_app);
gdk_window_get_geometry (GDK_WINDOW (GTK_WIDGET (gam_app)->window), NULL, NULL, &width, &height, NULL);
gconf_client_set_int (priv->gconf_client,
"/apps/gnome-alsamixer/geometry/main_window_height",
height,
NULL);
gconf_client_set_int (priv->gconf_client,
"/apps/gnome-alsamixer/geometry/main_window_width",
width,
NULL);
gconf_client_suggest_sync (priv->gconf_client, NULL);
}
static void
set_size(DiaRenderer *object, gpointer window,
int width, int height)
{
DiaGdkRenderer *renderer = DIA_GDK_RENDERER (object);
if (renderer->pixmap != NULL)
g_object_unref(renderer->pixmap);
if (window)
renderer->pixmap = gdk_pixmap_new(GDK_WINDOW(window), width, height, -1);
else /* the integrated UI insist to call us too early */
renderer->pixmap = gdk_pixmap_new(NULL, width, height, 24);
if (renderer->gc == NULL) {
renderer->gc = gdk_gc_new(renderer->pixmap);
gdk_gc_set_line_attributes(renderer->gc,
renderer->line_width,
renderer->line_style,
renderer->cap_style,
renderer->join_style);
}
}
static void
gdk_device_win32_set_window_cursor (GdkDevice *device,
GdkWindow *window,
GdkCursor *cursor)
{
GdkWin32Cursor *cursor_private;
GdkWindow *parent_window;
GdkWindowImplWin32 *impl;
HCURSOR hcursor;
HCURSOR hprevcursor;
impl = GDK_WINDOW_IMPL_WIN32 (window->impl);
cursor_private = (GdkWin32Cursor*) cursor;
hprevcursor = impl->hcursor;
if (!cursor)
hcursor = NULL;
else
hcursor = cursor_private->hcursor;
if (hcursor != NULL)
{
/* If the pointer is over our window, set new cursor */
GdkWindow *curr_window = gdk_window_get_pointer (window, NULL, NULL, NULL);
if (curr_window == window ||
(curr_window && window == gdk_window_get_toplevel (curr_window)))
SetCursor (hcursor);
else
{
/* Climb up the tree and find whether our window is the
* first ancestor that has cursor defined, and if so, set
* new cursor.
*/
while (curr_window && curr_window->impl &&
!GDK_WINDOW_IMPL_WIN32 (curr_window->impl)->hcursor)
{
curr_window = curr_window->parent;
if (curr_window == GDK_WINDOW (window))
{
SetCursor (hcursor);
break;
}
}
}
}
/* Unset the previous cursor: Need to make sure it's no longer in
* use before we destroy it, in case we're not over our window but
* the cursor is still set to our old one.
*/
if (hprevcursor != NULL &&
GetCursor () == hprevcursor)
{
/* Look for a suitable cursor to use instead */
hcursor = NULL;
parent_window = GDK_WINDOW (window)->parent;
while (hcursor == NULL)
{
if (parent_window)
{
impl = GDK_WINDOW_IMPL_WIN32 (parent_window->impl);
hcursor = impl->hcursor;
parent_window = parent_window->parent;
}
else
hcursor = LoadCursor (NULL, IDC_ARROW);
}
SetCursor (hcursor);
}
}
static void
on_calendar_realized(GtkWidget *widget, gpointer data)
{
gint parent_x, parent_y, parent_w, parent_h;
gint root_w, root_h;
gint width, height, x, y;
gint orientation;
GdkScreen *screen;
GtkWidget *parent;
GtkRequisition requisition;
orientation = GPOINTER_TO_INT(data);
parent = g_object_get_data(G_OBJECT(widget), "calendar-parent");
gdk_window_get_origin(GDK_WINDOW(parent->window), &parent_x, &parent_y);
gdk_drawable_get_size(GDK_DRAWABLE(parent->window), &parent_w, &parent_h);
screen = gdk_drawable_get_screen(GDK_DRAWABLE(widget->window));
root_w = gdk_screen_get_width(GDK_SCREEN(screen));
root_h = gdk_screen_get_height(GDK_SCREEN(screen));
gtk_widget_size_request(GTK_WIDGET(widget), &requisition);
width = requisition.width;
height = requisition.height;
/*
g_print("parent: %dx%d +%d+%d\n", parent_w, parent_h, parent_x, parent_y);
g_print("root: %dx%d\n", root_w, root_h);
g_print("calendar: %dx%d\n", width, height);
*/
if (orientation == GTK_ORIENTATION_VERTICAL) {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x + parent_w;
y = parent_y;
} else {
/* lower left */
x = parent_x + parent_w;
y = parent_y + parent_h - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x - width;
y = parent_y;
} else {
/* lower right */
x = parent_x - width;
y = parent_y + parent_h - height;
}
}
} else {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x;
y = parent_y + parent_h;
} else {
/* lower left */
x = parent_x;
y = parent_y - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x + parent_w - width;
y = parent_y + parent_h;
} else {
/* lower right */
x = parent_x + parent_w - width;
y = parent_y - height;
}
}
}
gtk_window_move(GTK_WINDOW(widget), x, y);
}
/**
* @brief minor convenience function to force repaint of widget..
* @param widget widget to refresh
* @return void
*/
void gtk_custom_table_refresh(GtkWidget *widget) {
gdk_window_invalidate_rect(GDK_WINDOW(gtk_widget_get_window(widget)), NULL, TRUE);
}
gint
main (gint argc, gchar *argv[])
{
Window root;
//gettext
bindtextdomain( "gamine", LOCALDIR );
textdomain( "gamine" );
gamine_t cb;
GtkWidget *window;
GdkWindow *gdkwindow;
GtkWindow *gtkwindow;
GdkScreen *screen;
GdkPixbuf *cursor_pixbuf;
GdkPixbuf *icon_pixbuf;
GdkCursor *cursor;
GdkColor bg_color;
gchar *cursorfile;
gchar *iconfile;
cb.is_cairo = FALSE;
gtk_init (&argc, &argv);
gst_init (&argc, &argv);
gconf_init(argc, argv, NULL);
gst_play_background (cb.bus,
"BachJSBrandenburgConcertNo2inFMajorBWV1047mvmt1.ogg", TRUE);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
/* Create the drawing area and configuration */
cb.da = gtk_drawing_area_new ();
bg_color.red = 65535;
bg_color.green = 65535;
bg_color.blue = 65535;
gtk_widget_modify_bg (cb.da, GTK_STATE_NORMAL, &bg_color);
gtk_container_add (GTK_CONTAINER (window), cb.da);
cb.gc = gconf_client_get_default();
gtkwindow = GTK_WINDOW(window);
gtk_window_set_title (gtkwindow, "Gamine");
gtk_window_set_wmclass(gtkwindow, "gamine", "Gamine");
gtk_container_set_border_width (GTK_CONTAINER (gtkwindow), 0);
/* Event signals */
g_signal_connect (gtkwindow, "destroy",
G_CALLBACK (gtk_main_quit), >kwindow);
g_signal_connect (G_OBJECT (cb.da), "expose-event",
G_CALLBACK (display_help), &cb);
g_signal_connect (cb.da, "motion_notify_event",
G_CALLBACK (draw_line), &cb);
g_signal_connect (cb.da, "button_press_event",
G_CALLBACK (draw_star), &cb);
g_signal_connect (gtkwindow, "key-press-event",
G_CALLBACK (gamine_on_key), &cb);
gtk_widget_set_events (cb.da, gtk_widget_get_events (cb.da)
| GDK_LEAVE_NOTIFY_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
/* Set fullscreen, grab mouse/keyboard, ...*/
gtk_widget_show_all (GTK_WIDGET(gtkwindow));
gdkwindow = GDK_WINDOW(GTK_WIDGET(gtkwindow)->window);
screen = gtk_widget_get_screen (cb.da);
gtk_window_present (gtkwindow);
gtk_window_stick(gtkwindow);
//gtk_window_set_keep_above (gtkwindow), True);
//gtk_window_set_transient_for (gtkwindow, NULL);
//set fullscreen
gdk_window_fullscreen (gdkwindow);
gtk_window_fullscreen (gtkwindow);
gdk_window_raise (gdkwindow);
//set full screen without window manager
XMoveResizeWindow(GDK_WINDOW_XDISPLAY(gdkwindow), GDK_WINDOW_XID(gdkwindow),
0, 0, gdk_screen_get_width (screen), gdk_screen_get_height (screen));
root = DefaultRootWindow(GDK_WINDOW_XDISPLAY (gdkwindow));
XGrabPointer(GDK_WINDOW_XDISPLAY (gdkwindow), root, True, PointerMotionMask,
GrabModeAsync, GrabModeAsync, root, None, CurrentTime);
XGrabKeyboard(GDK_WINDOW_XDISPLAY (gdkwindow), root, True,
GrabModeAsync, GrabModeAsync, CurrentTime);
//remove keyboard repeat
XAutoRepeatOff(GDK_WINDOW_XDISPLAY (gdkwindow));
gtk_window_has_toplevel_focus (gtkwindow);
/*cursor*/
cursorfile = g_build_filename(DATADIR, "pencil.png", NULL);
if (!g_file_test (cursorfile, G_FILE_TEST_EXISTS)) {
printf(gettext("*** error: %s does not exists***\n"), cursorfile);
} else {
cursor_pixbuf = gdk_pixbuf_new_from_file(cursorfile, NULL);
cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(),
cursor_pixbuf, 0, 38);
gdk_window_set_cursor(gdkwindow, cursor);
gdk_cursor_unref(cursor);
gdk_pixbuf_unref(cursor_pixbuf);
}
g_free(cursorfile);
/*Set icon*/
iconfile = g_build_filename(DATADIR, "gamine.png", NULL);
if (!g_file_test (iconfile, G_FILE_TEST_EXISTS))
printf(gettext("*** error: %s does not exists***\n"), iconfile);
else {
icon_pixbuf = gdk_pixbuf_new_from_file(iconfile, NULL);
gtk_window_set_icon (gtkwindow, icon_pixbuf);
gdk_pixbuf_unref (icon_pixbuf);
}
g_free(iconfile);
load_conf(&cb);
gtk_main ();
//set keyboard repeat
XAutoRepeatOn(GDK_WINDOW_XDISPLAY (gdkwindow));
XCloseDisplay(GDK_WINDOW_XDISPLAY (gdkwindow));
return 0;
}
gboolean
_gdk_input_other_event (GdkEvent *event,
MSG *msg,
GdkWindow *window)
{
GdkDisplay *display;
GdkDeviceWintab *device = NULL;
GdkDeviceGrabInfo *last_grab;
GdkEventMask masktest;
guint key_state;
POINT pt;
PACKET packet;
gdouble root_x, root_y;
gint num_axes;
gint x, y;
guint translated_buttons, button_diff, button_mask;
/* Translation from tablet button state to GDK button state for
* buttons 1-3 - swap button 2 and 3.
*/
static guint button_map[8] = {0, 1, 4, 5, 2, 3, 6, 7};
if (event->any.window != wintab_window)
{
g_warning ("_gdk_input_other_event: not wintab_window?");
return FALSE;
}
window = gdk_window_at_pointer (&x, &y);
if (window == NULL)
window = _gdk_root;
g_object_ref (window);
display = gdk_window_get_display (window);
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("_gdk_input_other_event: window=%p %+d%+d\n",
GDK_WINDOW_HWND (window), x, y));
if (msg->message == WT_PACKET)
{
if (!(*p_WTPacket) ((HCTX) msg->lParam, msg->wParam, &packet))
return FALSE;
}
switch (msg->message)
{
case WT_PACKET:
/* Don't produce any button or motion events while a window is being
* moved or resized, see bug #151090.
*/
if (_modal_operation_in_progress)
{
GDK_NOTE (EVENTS_OR_INPUT, g_print ("... ignored when moving/sizing\n"));
return FALSE;
}
if ((device = _gdk_device_manager_find_wintab_device ((HCTX) msg->lParam,
packet.pkCursor)) == NULL)
return FALSE;
if (gdk_device_get_mode (GDK_DEVICE (device)) == GDK_MODE_DISABLED)
return FALSE;
last_grab = _gdk_display_get_last_device_grab (_gdk_display, GDK_DEVICE (device));
if (last_grab && last_grab->window)
{
g_object_unref (window);
window = g_object_ref (last_grab->window);
}
if (window == _gdk_root)
{
GDK_NOTE (EVENTS_OR_INPUT, g_print ("... is root\n"));
return FALSE;
}
num_axes = 0;
if (device->pktdata & PK_X)
device->last_axis_data[num_axes++] = packet.pkX;
if (device->pktdata & PK_Y)
device->last_axis_data[num_axes++] = packet.pkY;
if (device->pktdata & PK_NORMAL_PRESSURE)
device->last_axis_data[num_axes++] = packet.pkNormalPressure;
if (device->pktdata & PK_ORIENTATION)
{
decode_tilt (device->last_axis_data + num_axes,
device->orientation_axes, &packet);
num_axes += 2;
}
translated_buttons = button_map[packet.pkButtons & 0x07] | (packet.pkButtons & ~0x07);
if (translated_buttons != device->button_state)
{
/* At least one button has changed state so produce a button event
* If more than one button has changed state (unlikely),
* just care about the first and act on the next the next time
* we get a packet
*/
button_diff = translated_buttons ^ device->button_state;
/* Gdk buttons are numbered 1.. */
event->button.button = 1;
for (button_mask = 1; button_mask != 0x80000000;
button_mask <<= 1, event->button.button++)
{
if (button_diff & button_mask)
{
/* Found a button that has changed state */
break;
}
}
if (!(translated_buttons & button_mask))
{
event->any.type = GDK_BUTTON_RELEASE;
masktest = GDK_BUTTON_RELEASE_MASK;
}
else
{
event->any.type = GDK_BUTTON_PRESS;
masktest = GDK_BUTTON_PRESS_MASK;
}
device->button_state ^= button_mask;
}
else
{
event->any.type = GDK_MOTION_NOTIFY;
masktest = GDK_POINTER_MOTION_MASK;
if (device->button_state & (1 << 0))
masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK;
if (device->button_state & (1 << 1))
masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON2_MOTION_MASK;
if (device->button_state & (1 << 2))
masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON3_MOTION_MASK;
}
/* Now we can check if the window wants the event, and
* propagate if necessary.
*/
while (gdk_window_get_device_events (window, GDK_DEVICE (device)) == 0)
{
GDK_NOTE (EVENTS_OR_INPUT, g_print ("... not selected\n"));
if (window->parent == GDK_WINDOW (_gdk_root))
return FALSE;
/* It is not good to propagate the extended events up to the parent
* if this window wants normal (not extended) motion/button events */
if (window->event_mask & masktest)
{
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("... wants ordinary event, ignoring this\n"));
return FALSE;
}
pt.x = x;
pt.y = y;
ClientToScreen (GDK_WINDOW_HWND (window), &pt);
g_object_unref (window);
window = window->parent;
g_object_ref (window);
ScreenToClient (GDK_WINDOW_HWND (window), &pt);
x = pt.x;
y = pt.y;
GDK_NOTE (EVENTS_OR_INPUT, g_print ("... propagating to %p %+d%+d\n",
GDK_WINDOW_HWND (window), x, y));
}
if (gdk_window_get_device_events (window, GDK_DEVICE (device)) == 0)
return FALSE;
event->any.window = window;
key_state = get_modifier_key_state ();
if (event->any.type == GDK_BUTTON_PRESS ||
event->any.type == GDK_BUTTON_RELEASE)
{
event->button.time = _gdk_win32_get_next_tick (msg->time);
gdk_event_set_device (event, GDK_DEVICE (device));
event->button.axes = g_new (gdouble, num_axes);
_gdk_device_wintab_get_window_coords (window, &root_x, &root_y);
_gdk_device_wintab_translate_axes (device,
window,
event->button.axes,
&event->button.x,
&event->button.y);
event->button.x_root = event->button.x + root_x;
event->button.y_root = event->button.y + root_y;
event->button.state =
key_state | ((device->button_state << 8)
& (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK
| GDK_BUTTON3_MASK | GDK_BUTTON4_MASK
| GDK_BUTTON5_MASK));
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("WINTAB button %s:%d %g,%g\n",
(event->button.type == GDK_BUTTON_PRESS ?
"press" : "release"),
event->button.button,
event->button.x, event->button.y));
}
else
{
event->motion.time = _gdk_win32_get_next_tick (msg->time);
event->motion.is_hint = FALSE;
gdk_event_set_device (event, GDK_DEVICE (device));
event->motion.axes = g_new (gdouble, num_axes);
_gdk_device_wintab_get_window_coords (window, &root_x, &root_y);
_gdk_device_wintab_translate_axes (device,
window,
event->motion.axes,
&event->motion.x,
&event->motion.y);
event->motion.x_root = event->motion.x + root_x;
event->motion.y_root = event->motion.y + root_y;
event->motion.state =
key_state | ((device->button_state << 8)
& (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK
| GDK_BUTTON3_MASK | GDK_BUTTON4_MASK
| GDK_BUTTON5_MASK));
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("WINTAB motion: %g,%g\n",
event->motion.x, event->motion.y));
}
return TRUE;
case WT_PROXIMITY:
if (LOWORD (msg->lParam) == 0)
{
event->proximity.type = GDK_PROXIMITY_OUT;
set_ignore_core (FALSE);
}
else
{
event->proximity.type = GDK_PROXIMITY_IN;
set_ignore_core (TRUE);
}
event->proximity.time = _gdk_win32_get_next_tick (msg->time);
gdk_event_set_device (event, GDK_DEVICE (device));
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("WINTAB proximity %s\n",
(event->proximity.type == GDK_PROXIMITY_IN ?
"in" : "out")));
return TRUE;
}
return FALSE;
}
static GtkWidget *
pop_calendar_window(GtkWidget *parent, int orientation)
{
GtkWidget *window;
GtkWidget *cal;
gint parent_x, parent_y, parent_w, parent_h;
gint root_w, root_h;
gint width, height, x, y;
GtkRequisition requisition;
GtkAllocation allocation;
window = gtk_window_new(GTK_WINDOW_POPUP);
cal = gtk_calendar_new();
gtk_container_add(GTK_CONTAINER(window), cal);
gdk_window_get_origin(GDK_WINDOW(parent->window), &parent_x, &parent_y);
gdk_drawable_get_size(GDK_DRAWABLE(parent->window), &parent_w, &parent_h);
root_w = gdk_screen_width();
root_h = gdk_screen_height();
gtk_widget_realize(GTK_WIDGET(window));
gtk_widget_size_request(GTK_WIDGET(cal), &requisition);
allocation.x = requisition.width;
allocation.y = requisition.height;
gtk_widget_size_allocate(GTK_WIDGET(cal), &allocation);
gtk_widget_size_request(GTK_WIDGET(cal), &requisition);
width = requisition.width;
height = requisition.height;
g_print("parent: %dx%d +%d+%d\n", parent_w, parent_h, parent_x, parent_y);
g_print("root: %dx%d\n", root_w, root_h);
g_print("calendar: %dx%d\n", width, height);
if (orientation == GTK_ORIENTATION_VERTICAL) {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x + parent_w;
y = parent_y;
} else {
/* lower left */
x = parent_x + parent_w;
y = parent_y + parent_h - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x - width;
y = parent_y;
} else {
/* lower right */
x = parent_x - width;
y = parent_y + parent_h - height;
}
}
} else {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x;
y = parent_y + parent_h;
} else {
/* lower left */
x = parent_x;
y = parent_y - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x + parent_w - width;
y = parent_y + parent_h;
} else {
/* lower right */
x = parent_x + parent_w - width;
y = parent_y - height;
}
}
}
gtk_window_move(GTK_WINDOW(window), x, y);
gtk_widget_show(cal);
gtk_widget_show(window);
return window;
}
static VALUE
style_attach(VALUE self, VALUE win)
{
return GOBJ2RVAL(gtk_style_attach(_SELF(self),
GDK_WINDOW(RVAL2GOBJ(win))));
}
static VALUE
gdkevent_s_get_graphics_expose(G_GNUC_UNUSED VALUE self, VALUE window)
{
return make_gdkevent(gdk_event_get_graphics_expose(GDK_WINDOW(RVAL2GOBJ(window))));
}
static gboolean
panel_background_prepare (PanelBackground *background)
{
PanelBackgroundType effective_type;
GtkWidget *widget = NULL;
if (!background->transformed)
return FALSE;
effective_type = panel_background_effective_type (background);
switch (effective_type) {
case PANEL_BACK_NONE:
if (background->default_pattern) {
/* the theme background-image pattern must be scaled by
* the width & height of the panel so that when the
* backing region is cleared
* (gdk_window_clear_backing_region), the correctly
* scaled pattern is used */
cairo_matrix_t m;
cairo_surface_t *surface;
double width, height;
surface = NULL;
width = 1.0;
height = 1.0;
cairo_pattern_get_surface(background->default_pattern, &surface);
/* catch invalid images (e.g. -gtk-gradient) before scaling and rendering */
if (surface != NULL ){
cairo_surface_reference(surface);
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
cairo_matrix_init_translate (&m, 0, 0);
cairo_matrix_scale (&m,
width / background->region.width,
height / background->region.height);
cairo_pattern_set_matrix (background->default_pattern, &m);
gdk_window_set_background_pattern (background->window,
background->default_pattern);
}
else {
g_warning ("%s", "unsupported value of 'background-image' in GTK+ theme (such as '-gtk-gradient')");
/* use any background color that has been set if image is invalid */
gdk_window_set_background_rgba (
background->window, &background->default_color);
}
cairo_surface_destroy(surface);
} else
gdk_window_set_background_rgba (
background->window, &background->default_color);
break;
case PANEL_BACK_COLOR:
if (background->has_alpha &&
!gdk_window_check_composited_wm(background->window))
set_pixbuf_background (background);
else {
gdk_window_set_background_rgba (background->window,
&background->color);
}
break;
case PANEL_BACK_IMAGE:
set_pixbuf_background (background);
break;
default:
g_assert_not_reached ();
break;
}
/* Panel applets may use the panel's background pixmap to
* decide how to draw themselves. Therefore, we need to
* make sure that all drawing has been completed before
* the applet looks at the pixmap. */
gdk_display_sync (gdk_window_get_display (background->window));
gdk_window_get_user_data (GDK_WINDOW (background->window),
(gpointer) &widget);
if (GTK_IS_WIDGET (widget)) {
panel_background_apply_css (background, gtk_widget_get_toplevel(widget));
gtk_widget_set_app_paintable(widget,TRUE);
gtk_widget_queue_draw (widget);
}
background->notify_changed (background, background->user_data);
return TRUE;
}
static void
test_type (gconstpointer data)
{
GObjectClass *klass;
GObject *instance;
GParamSpec **pspecs;
guint n_pspecs, i;
GType type;
type = * (GType *) data;
if (!G_TYPE_IS_CLASSED (type))
return;
if (G_TYPE_IS_ABSTRACT (type))
return;
if (!g_type_is_a (type, G_TYPE_OBJECT))
return;
/* These can't be freely constructed/destroyed */
if (g_type_is_a (type, GTK_TYPE_PRINT_JOB) ||
g_type_is_a (type, GTK_TYPE_APPLICATION) ||
g_type_is_a (type, GDK_TYPE_PIXBUF_LOADER) ||
g_type_is_a (type, gdk_pixbuf_simple_anim_iter_get_type ()))
return;
klass = g_type_class_ref (type);
if (g_type_is_a (type, GTK_TYPE_SETTINGS))
instance = g_object_ref (gtk_settings_get_default ());
else if (g_type_is_a (type, GDK_TYPE_WINDOW))
{
GdkWindowAttr attributes;
attributes.window_type = GDK_WINDOW_TEMP;
attributes.event_mask = 0;
attributes.width = 100;
attributes.height = 100;
instance = g_object_ref (gdk_window_new (NULL, &attributes, 0));
}
else
instance = g_object_new (type, NULL);
if (g_type_is_a (type, G_TYPE_INITIALLY_UNOWNED))
g_object_ref_sink (instance);
pspecs = g_object_class_list_properties (klass, &n_pspecs);
for (i = 0; i < n_pspecs; ++i)
{
GParamSpec *pspec = pspecs[i];
GValue value = G_VALUE_INIT;
if (pspec->owner_type != type)
continue;
if ((pspec->flags & G_PARAM_READABLE) == 0)
continue;
if (g_type_is_a (type, GDK_TYPE_DISPLAY_MANAGER) &&
(strcmp (pspec->name, "default-display") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_ABOUT_DIALOG) &&
(strcmp (pspec->name, "program-name") == 0))
continue;
/* These are set to the current date */
if (g_type_is_a (type, GTK_TYPE_CALENDAR) &&
(strcmp (pspec->name, "year") == 0 ||
strcmp (pspec->name, "month") == 0 ||
strcmp (pspec->name, "day") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_CELL_RENDERER_TEXT) &&
(strcmp (pspec->name, "background-gdk") == 0 ||
strcmp (pspec->name, "foreground-gdk") == 0 ||
strcmp (pspec->name, "font") == 0 ||
strcmp (pspec->name, "font-desc") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_CELL_VIEW) &&
(strcmp (pspec->name, "background-gdk") == 0 ||
strcmp (pspec->name, "foreground-gdk") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_COLOR_BUTTON) &&
strcmp (pspec->name, "color") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_COLOR_SELECTION) &&
strcmp (pspec->name, "current-color") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_COLOR_SELECTION_DIALOG) &&
(strcmp (pspec->name, "color-selection") == 0 ||
strcmp (pspec->name, "ok-button") == 0 ||
strcmp (pspec->name, "help-button") == 0 ||
strcmp (pspec->name, "cancel-button") == 0))
continue;
/* Default invisible char is determined at runtime */
if (g_type_is_a (type, GTK_TYPE_ENTRY) &&
(strcmp (pspec->name, "invisible-char") == 0 ||
strcmp (pspec->name, "buffer") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_FONT_SELECTION) &&
strcmp (pspec->name, "font") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_LAYOUT) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_MESSAGE_DIALOG) &&
(strcmp (pspec->name, "image") == 0 ||
strcmp (pspec->name, "message-area") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_PANED) &&
strcmp (pspec->name, "max-position") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_PRINT_OPERATION) &&
strcmp (pspec->name, "job-name") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_PRINT_UNIX_DIALOG) &&
(strcmp (pspec->name, "page-setup") == 0 ||
strcmp (pspec->name, "print-settings") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_PROGRESS_BAR) &&
strcmp (pspec->name, "adjustment") == 0)
continue;
/* filename value depends on $HOME */
if (g_type_is_a (type, GTK_TYPE_RECENT_MANAGER) &&
(strcmp (pspec->name, "filename") == 0 ||
strcmp (pspec->name, "size") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_SCALE_BUTTON) &&
strcmp (pspec->name, "adjustment") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_SCROLLED_WINDOW) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
/* these defaults come from XResources */
if (g_type_is_a (type, GTK_TYPE_SETTINGS) &&
strncmp (pspec->name, "gtk-xft-", 8) == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_SETTINGS) &&
(strcmp (pspec->name, "color-hash") == 0 ||
strcmp (pspec->name, "gtk-cursor-theme-name") == 0 ||
strcmp (pspec->name, "gtk-cursor-theme-size") == 0 ||
strcmp (pspec->name, "gtk-dnd-drag-threshold") == 0 ||
strcmp (pspec->name, "gtk-double-click-time") == 0 ||
strcmp (pspec->name, "gtk-fallback-icon-theme") == 0 ||
strcmp (pspec->name, "gtk-file-chooser-backend") == 0 ||
strcmp (pspec->name, "gtk-icon-theme-name") == 0 ||
strcmp (pspec->name, "gtk-im-module") == 0 ||
strcmp (pspec->name, "gtk-key-theme-name") == 0 ||
strcmp (pspec->name, "gtk-theme-name") == 0 ||
strcmp (pspec->name, "gtk-sound-theme-name") == 0 ||
strcmp (pspec->name, "gtk-enable-input-feedback-sounds") == 0 ||
strcmp (pspec->name, "gtk-enable-event-sounds") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_SPIN_BUTTON) &&
(strcmp (pspec->name, "adjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_STATUS_ICON) &&
(strcmp (pspec->name, "size") == 0 ||
strcmp (pspec->name, "screen") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_TEXT_BUFFER) &&
(strcmp (pspec->name, "tag-table") == 0 ||
strcmp (pspec->name, "copy-target-list") == 0 ||
strcmp (pspec->name, "paste-target-list") == 0))
continue;
/* language depends on the current locale */
if (g_type_is_a (type, GTK_TYPE_TEXT_TAG) &&
(strcmp (pspec->name, "background-gdk") == 0 ||
strcmp (pspec->name, "foreground-gdk") == 0 ||
strcmp (pspec->name, "language") == 0 ||
strcmp (pspec->name, "font") == 0 ||
strcmp (pspec->name, "font-desc") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_TEXT_VIEW) &&
strcmp (pspec->name, "buffer") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_TOOL_ITEM_GROUP) &&
strcmp (pspec->name, "label-widget") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_TREE_VIEW) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_VIEWPORT) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_WIDGET) &&
(strcmp (pspec->name, "name") == 0 ||
strcmp (pspec->name, "screen") == 0 ||
strcmp (pspec->name, "style") == 0))
continue;
/* resize-grip-visible is determined at runtime */
if (g_type_is_a (type, GTK_TYPE_WINDOW) &&
(strcmp (pspec->name, "resize-grip-visible") == 0))
continue;
if (g_test_verbose ())
g_print ("Property %s.%s\n",
g_type_name (pspec->owner_type),
pspec->name);
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (instance, pspec->name, &value);
check_property ("Property", pspec, &value);
g_value_unset (&value);
}
g_free (pspecs);
if (g_type_is_a (type, GTK_TYPE_WIDGET))
{
pspecs = gtk_widget_class_list_style_properties (GTK_WIDGET_CLASS (klass), &n_pspecs);
for (i = 0; i < n_pspecs; ++i)
{
GParamSpec *pspec = pspecs[i];
GValue value = G_VALUE_INIT;
if (pspec->owner_type != type)
continue;
if ((pspec->flags & G_PARAM_READABLE) == 0)
continue;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
gtk_widget_style_get_property (GTK_WIDGET (instance), pspec->name, &value);
check_property ("Style property", pspec, &value);
g_value_unset (&value);
}
g_free (pspecs);
}
if (g_type_is_a (type, GDK_TYPE_WINDOW))
gdk_window_destroy (GDK_WINDOW (instance));
else
g_object_unref (instance);
g_type_class_unref (klass);
}
void help(char *file) {
char fullspec[1024], *temp, *pt;
if ( browser[0]=='\0' )
findbrowser();
#ifndef __CygWin
if ( browser[0]=='\0' ) {
gwwv_post_error(_("No Browser"),_("Could not find a browser. Set the BROWSER environment variable to point to one"));
return;
}
#endif
if ( strstr(file,"http://")==NULL ) {
fullspec[0] = 0;
if ( *file!='/' ) {
if ( helpdir==NULL || *helpdir=='\0' ) {
#ifdef DOCDIR
strcpy(fullspec,DOCDIR "/");
#elif defined(SHAREDIR)
strcpy(fullspec,SHAREDIR "/doc/fontforge/");
#else
strcpy(fullspec,"/usr/local/share/doc/fontforge/");
#endif
} else
strcpy(fullspec,helpdir);
}
strcat(fullspec,file);
if (( pt = strrchr(fullspec,'#') )!=NULL ) *pt ='\0';
if ( !GFileReadable( fullspec )) {
if ( *file!='/' ) {
strcpy(fullspec,"/usr/share/doc/fontforge/");
strcat(fullspec,file);
if (( pt = strrchr(fullspec,'#') )!=NULL ) *pt ='\0';
}
}
if ( !GFileReadable( fullspec )) {
strcpy(fullspec,"http://fontforge.sf.net/");
AppendSupportedLocale(fullspec);
strcat(fullspec,file);
} else if ( pt!=NULL )
*pt = '#';
} else
strcpy(fullspec,file);
#if __CygWin
if ( (strstrmatch(browser,"/cygdrive")!=NULL || browser[0]=='\0') &&
strstr(fullspec,":/")==NULL ) {
/* It looks as though the browser is a windows application, so we */
/* should give it a windows file name */
char *pt, *tpt;
temp = galloc(1024);
cygwin_conv_to_full_win32_path(fullspec,temp);
for ( pt = fullspec, tpt = temp; *tpt && pt<fullspec+sizeof(fullspec)-3; *pt++ = *tpt++ )
if ( *tpt=='\\' )
*pt++ = '\\';
*pt = '\0';
free(temp);
}
#endif
#if __Mac
if ( strcmp(browser,"open")==0 )
/* open doesn't want "file:" prepended */;
else
#endif
if ( strstr(fullspec,":/")==NULL ) {
char *t1 = galloc(strlen(fullspec)+strlen("file:")+20);
#if __CygWin
sprintf( t1, "file:\\\\\\%s", fullspec );
#else
sprintf( t1, "file:%s", fullspec);
#endif
strcpy(fullspec,t1);
free(t1);
}
#if 0 && __Mac
/* Starting a Mac application is weird... system() can't do it */
/* Thanks to Edward H. Trager giving me an example... */
if ( strstr(browser,".app")!=NULL ) {
*strstr(browser,".app") = '\0';
pt = strrchr(browser,'/');
if ( pt==NULL ) pt = browser-1;
++pt;
temp = galloc(strlen(pt)+strlen(fullspec) +
strlen( "osascript -l AppleScript -e \"Tell application \"\" to getURL \"\"\"" )+
20);
/* this doesn't work on Max OS X.0 (osascript does not support -e) */
sprintf( temp, "osascript -l AppleScript -e \"Tell application \"%s\" to getURL \"%s\"\"",
pt, fullspec);
system(temp);
ff_post_notice(_("Leave X"),_("A browser is probably running in the native Mac windowing system. You must leave the X environment to view it. Try Cmd-Opt-A"));
} else {
#elif __Mac
/* This seems a bit easier... Thanks to riggle */
if ( strcmp(browser,"open")==0 ) {
temp = galloc(strlen(browser) + strlen(fullspec) + 20);
sprintf( temp, "open \"%s\" &", fullspec );
system(temp);
ff_post_notice(_("Leave X"),_("A browser is probably running in the native Mac windowing system. You must leave the X environment to view it. Try Cmd-Opt-A"));
} else {
#elif __CygWin
if ( browser[0]=='\0' ) {
do_windows_browser(fullspec);
temp = NULL;
} else {
#else
{
#endif
temp = galloc(strlen(browser) + strlen(fullspec) + 20);
sprintf( temp, strcmp(browser,"kfmclient openURL")==0 ? "%s \"%s\" &" : "\"%s\" \"%s\" &", browser, fullspec );
system(temp);
}
free(temp);
}
#define MAX_ERR_LINES 200
static struct errordata {
char *errlines[MAX_ERR_LINES];
int fh, as;
GtkWidget *vsb;
GtkWidget *gw, *v;
PangoLayout *layout;
int cnt, linecnt;
int offtop;
int showing;
} errdata;
static void Warning_Hide(void) {
gdk_window_hide(errdata.gw->window);
errdata.showing = false;
}
static void Warning_VScroll(GtkRange *vsb, gpointer user_data) {
GtkAdjustment *sb;
sb = gtk_range_get_adjustment(GTK_RANGE(vsb));
if ( sb->value!=errdata.offtop) {
int diff = sb->value-errdata.offtop;
errdata.offtop = sb->value;
gdk_window_scroll(GDK_WINDOW(errdata.v->window),0,diff*errdata.fh);
}
}
static gboolean Warning_Resize(GtkWidget *widget, GdkEventConfigure *event, gpointer user_data) {
GtkAdjustment *sb;
errdata.linecnt = widget->allocation.width/errdata.fh;
sb = gtk_range_get_adjustment(GTK_RANGE(errdata.vsb));
sb->lower = 0; sb->upper = errdata.cnt; sb->page_size = errdata.linecnt;
sb->step_increment = 1; sb->page_increment = errdata.linecnt;
if ( errdata.offtop>=errdata.cnt-errdata.linecnt )
errdata.offtop = errdata.cnt-errdata.linecnt;
if ( errdata.offtop<0 ) errdata.offtop =0;
sb->value = errdata.offtop;
gtk_range_set_adjustment(GTK_RANGE(errdata.vsb),sb);
return 0;
}
static gint
find_tab_num_at_pos (CeditNotebook *notebook,
gint abs_x,
gint abs_y)
{
GtkPositionType tab_pos;
int page_num = 0;
GtkNotebook *nb = GTK_NOTEBOOK (notebook);
GtkWidget *page;
tab_pos = gtk_notebook_get_tab_pos (GTK_NOTEBOOK (notebook));
/* For some reason unfullscreen + quick click can
cause a wrong click event to be reported to the tab */
if (!is_in_notebook_window (notebook, abs_x, abs_y))
{
return NOT_IN_APP_WINDOWS;
}
while ((page = gtk_notebook_get_nth_page (nb, page_num)) != NULL)
{
GtkAllocation allocation;
GtkWidget *tab;
gint max_x, max_y;
gint x_root, y_root;
tab = gtk_notebook_get_tab_label (nb, page);
g_return_val_if_fail (tab != NULL, AFTER_ALL_TABS);
if (!gtk_widget_get_mapped (tab))
{
++page_num;
continue;
}
gdk_window_get_origin (GDK_WINDOW (gtk_widget_get_window (tab)),
&x_root, &y_root);
gtk_widget_get_allocation(tab, &allocation);
max_x = x_root + allocation.x + allocation.width;
max_y = y_root + allocation.y + allocation.height;
if (((tab_pos == GTK_POS_TOP) ||
(tab_pos == GTK_POS_BOTTOM)) &&
(abs_x <= max_x))
{
return page_num;
}
else if (((tab_pos == GTK_POS_LEFT) ||
(tab_pos == GTK_POS_RIGHT)) &&
(abs_y <= max_y))
{
return page_num;
}
++page_num;
}
return AFTER_ALL_TABS;
}
static VALUE
rg_set_client_window(VALUE self, VALUE gdkwindow)
{
gtk_im_context_set_client_window(_SELF(self), GDK_WINDOW(RVAL2GOBJ(gdkwindow)));
return self;
}
static gboolean step (gpointer data)
{
gdk_window_invalidate_rect(GDK_WINDOW(data), NULL, TRUE);
return TRUE;
}
static void
test_type (gconstpointer data)
{
GObjectClass *klass;
GObject *instance;
GParamSpec **pspecs;
guint n_pspecs, i;
GType type;
GdkDisplay *display;
type = * (GType *) data;
display = gdk_display_get_default ();
if (!G_TYPE_IS_CLASSED (type))
return;
if (G_TYPE_IS_ABSTRACT (type))
return;
if (!g_type_is_a (type, G_TYPE_OBJECT))
return;
/* These can't be freely constructed/destroyed */
if (g_type_is_a (type, GTK_TYPE_APPLICATION) ||
g_type_is_a (type, GDK_TYPE_PIXBUF_LOADER) ||
g_type_is_a (type, GDK_TYPE_DRAWING_CONTEXT) ||
#ifdef G_OS_UNIX
g_type_is_a (type, GTK_TYPE_PRINT_JOB) ||
#endif
g_type_is_a (type, gdk_pixbuf_simple_anim_iter_get_type ()) ||
g_str_equal (g_type_name (type), "GdkX11DeviceManagerXI2") ||
g_str_equal (g_type_name (type), "GdkX11DeviceManagerCore") ||
g_str_equal (g_type_name (type), "GdkX11Display") ||
g_str_equal (g_type_name (type), "GdkX11DisplayManager") ||
g_str_equal (g_type_name (type), "GdkX11Screen") ||
g_str_equal (g_type_name (type), "GdkX11GLContext"))
return;
/* This throws a critical when the connection is dropped */
if (g_type_is_a (type, GTK_TYPE_APP_CHOOSER_DIALOG))
return;
/* These leak their GDBusConnections */
if (g_type_is_a (type, GTK_TYPE_FILE_CHOOSER_BUTTON) ||
g_type_is_a (type, GTK_TYPE_FILE_CHOOSER_DIALOG) ||
g_type_is_a (type, GTK_TYPE_FILE_CHOOSER_WIDGET) ||
g_type_is_a (type, GTK_TYPE_PLACES_SIDEBAR))
return;
klass = g_type_class_ref (type);
if (g_type_is_a (type, GTK_TYPE_SETTINGS))
instance = g_object_ref (gtk_settings_get_default ());
else if (g_type_is_a (type, GDK_TYPE_WINDOW))
{
GdkWindowAttr attributes;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.window_type = GDK_WINDOW_TEMP;
attributes.event_mask = 0;
attributes.width = 100;
attributes.height = 100;
instance = g_object_ref (gdk_window_new (NULL, &attributes, 0));
}
else if (g_str_equal (g_type_name (type), "GdkX11Cursor"))
instance = g_object_new (type, "display", display, NULL);
else
instance = g_object_new (type, NULL);
if (g_type_is_a (type, G_TYPE_INITIALLY_UNOWNED))
g_object_ref_sink (instance);
pspecs = g_object_class_list_properties (klass, &n_pspecs);
for (i = 0; i < n_pspecs; ++i)
{
GParamSpec *pspec = pspecs[i];
GValue value = G_VALUE_INIT;
if (pspec->owner_type != type)
continue;
if ((pspec->flags & G_PARAM_READABLE) == 0)
continue;
/* This one has a special-purpose default value */
if (g_type_is_a (type, GTK_TYPE_DIALOG) &&
(strcmp (pspec->name, "use-header-bar") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_ASSISTANT) &&
(strcmp (pspec->name, "use-header-bar") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_POPOVER) &&
(strcmp (pspec->name, "pointing-to") == 0))
continue;
if (g_type_is_a (type, GDK_TYPE_DISPLAY_MANAGER) &&
(strcmp (pspec->name, "default-display") == 0))
continue;
if (g_type_is_a (type, GDK_TYPE_MONITOR) &&
(strcmp (pspec->name, "geometry") == 0 ||
strcmp (pspec->name, "workarea") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_ABOUT_DIALOG) &&
(strcmp (pspec->name, "program-name") == 0))
continue;
/* These are set to the current date */
if (g_type_is_a (type, GTK_TYPE_CALENDAR) &&
(strcmp (pspec->name, "year") == 0 ||
strcmp (pspec->name, "month") == 0 ||
strcmp (pspec->name, "day") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_CELL_AREA_CONTEXT) &&
(strcmp (pspec->name, "minimum-width") == 0 ||
strcmp (pspec->name, "minimum-height") == 0 ||
strcmp (pspec->name, "natural-width") == 0 ||
strcmp (pspec->name, "natural-height") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_CELL_RENDERER_TEXT) &&
(strcmp (pspec->name, "background-gdk") == 0 ||
strcmp (pspec->name, "foreground-gdk") == 0 ||
strcmp (pspec->name, "background-rgba") == 0 ||
strcmp (pspec->name, "foreground-rgba") == 0 ||
strcmp (pspec->name, "font") == 0 ||
strcmp (pspec->name, "font-desc") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_CELL_VIEW) &&
(strcmp (pspec->name, "background-gdk") == 0 ||
strcmp (pspec->name, "foreground-gdk") == 0 ||
strcmp (pspec->name, "foreground-rgba") == 0 ||
strcmp (pspec->name, "background-rgba") == 0 ||
strcmp (pspec->name, "cell-area") == 0 ||
strcmp (pspec->name, "cell-area-context") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_COLOR_BUTTON) &&
(strcmp (pspec->name, "color") == 0 ||
strcmp (pspec->name, "rgba") == 0))
continue;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (g_type_is_a (type, GTK_TYPE_COLOR_SELECTION) &&
(strcmp (pspec->name, "current-color") == 0 ||
strcmp (pspec->name, "current-rgba") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_COLOR_SELECTION_DIALOG) &&
(strcmp (pspec->name, "color-selection") == 0 ||
strcmp (pspec->name, "ok-button") == 0 ||
strcmp (pspec->name, "help-button") == 0 ||
strcmp (pspec->name, "cancel-button") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_COMBO_BOX) &&
(strcmp (pspec->name, "cell-area") == 0 ||
strcmp (pspec->name, "cell-area-context") == 0))
continue;
G_GNUC_END_IGNORE_DEPRECATIONS
/* Default invisible char is determined at runtime */
if (g_type_is_a (type, GTK_TYPE_ENTRY) &&
(strcmp (pspec->name, "invisible-char") == 0 ||
strcmp (pspec->name, "buffer") == 0))
continue;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
if (g_type_is_a (type, GTK_TYPE_ENTRY_COMPLETION) &&
(strcmp (pspec->name, "cell-area") == 0 ||
strcmp (pspec->name, "cell-area-context") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_FONT_SELECTION) &&
strcmp (pspec->name, "font") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_ICON_VIEW) &&
(strcmp (pspec->name, "cell-area") == 0 ||
strcmp (pspec->name, "cell-area-context") == 0))
continue;
G_GNUC_END_IGNORE_DEPRECATIONS
if (g_type_is_a (type, GTK_TYPE_LAYOUT) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_MESSAGE_DIALOG) &&
(strcmp (pspec->name, "image") == 0 ||
strcmp (pspec->name, "message-area") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_PANED) &&
strcmp (pspec->name, "max-position") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_PRINT_OPERATION) &&
strcmp (pspec->name, "job-name") == 0)
continue;
#ifdef G_OS_UNIX
if (g_type_is_a (type, GTK_TYPE_PRINT_UNIX_DIALOG) &&
(strcmp (pspec->name, "page-setup") == 0 ||
strcmp (pspec->name, "print-settings") == 0))
continue;
#endif
if (g_type_is_a (type, GTK_TYPE_PROGRESS_BAR) &&
strcmp (pspec->name, "adjustment") == 0)
continue;
/* filename value depends on $HOME */
if (g_type_is_a (type, GTK_TYPE_RECENT_MANAGER) &&
(strcmp (pspec->name, "filename") == 0 ||
strcmp (pspec->name, "size") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_SCALE_BUTTON) &&
strcmp (pspec->name, "adjustment") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_SCROLLED_WINDOW) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_SETTINGS))
continue;
if (g_type_is_a (type, GTK_TYPE_SPIN_BUTTON) &&
(strcmp (pspec->name, "adjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_STATUS_ICON) &&
(strcmp (pspec->name, "size") == 0 ||
strcmp (pspec->name, "screen") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_STYLE_CONTEXT) &&
strcmp (pspec->name, "screen") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_TEXT_BUFFER) &&
(strcmp (pspec->name, "tag-table") == 0 ||
strcmp (pspec->name, "copy-target-list") == 0 ||
strcmp (pspec->name, "paste-target-list") == 0))
continue;
/* language depends on the current locale */
if (g_type_is_a (type, GTK_TYPE_TEXT_TAG) &&
(strcmp (pspec->name, "background-gdk") == 0 ||
strcmp (pspec->name, "foreground-gdk") == 0 ||
strcmp (pspec->name, "language") == 0 ||
strcmp (pspec->name, "font") == 0 ||
strcmp (pspec->name, "font-desc") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_TEXT_VIEW) &&
strcmp (pspec->name, "buffer") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_TOOL_ITEM_GROUP) &&
strcmp (pspec->name, "label-widget") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_TREE_VIEW) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_TREE_VIEW_COLUMN) &&
(strcmp (pspec->name, "cell-area") == 0 ||
strcmp (pspec->name, "cell-area-context") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_VIEWPORT) &&
(strcmp (pspec->name, "hadjustment") == 0 ||
strcmp (pspec->name, "vadjustment") == 0))
continue;
if (g_type_is_a (type, GTK_TYPE_WIDGET) &&
(strcmp (pspec->name, "name") == 0 ||
strcmp (pspec->name, "screen") == 0 ||
strcmp (pspec->name, "style") == 0))
continue;
/* resize-grip-visible is determined at runtime */
if (g_type_is_a (type, GTK_TYPE_WINDOW) &&
strcmp (pspec->name, "resize-grip-visible") == 0)
continue;
/* show-desktop depends on desktop environment */
if (g_type_is_a (type, GTK_TYPE_PLACES_SIDEBAR) &&
strcmp (pspec->name, "show-desktop") == 0)
continue;
if (g_test_verbose ())
g_print ("Property %s.%s\n",
g_type_name (pspec->owner_type),
pspec->name);
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (instance, pspec->name, &value);
check_property ("Property", pspec, &value);
g_value_unset (&value);
}
g_free (pspecs);
if (g_type_is_a (type, GTK_TYPE_WIDGET))
{
g_object_set (gtk_settings_get_default (), "gtk-theme-name", "Raleigh", NULL);
pspecs = gtk_widget_class_list_style_properties (GTK_WIDGET_CLASS (klass), &n_pspecs);
for (i = 0; i < n_pspecs; ++i)
{
GParamSpec *pspec = pspecs[i];
GValue value = G_VALUE_INIT;
if (pspec->owner_type != type)
continue;
if ((pspec->flags & G_PARAM_READABLE) == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_BUTTON) &&
strcmp (pspec->name, "default-border") == 0)
continue;
if (g_type_is_a (type, GTK_TYPE_WINDOW) &&
(strcmp (pspec->name, "resize-grip-width") == 0 ||
strcmp (pspec->name, "resize-grip-height") == 0 ||
strcmp (pspec->name, "decoration-button-layout") == 0))
continue;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
gtk_widget_style_get_property (GTK_WIDGET (instance), pspec->name, &value);
check_property ("Style property", pspec, &value);
g_value_unset (&value);
}
g_free (pspecs);
}
if (g_type_is_a (type, GDK_TYPE_WINDOW))
gdk_window_destroy (GDK_WINDOW (instance));
else
g_object_unref (instance);
g_type_class_unref (klass);
}
gboolean
gnomemeeting_window_is_visible (GtkWidget *w)
{
return (GTK_WIDGET_VISIBLE (w) && !(gdk_window_get_state (GDK_WINDOW (w->window)) & GDK_WINDOW_STATE_ICONIFIED));
}
int
main (int argc, char **argv)
{
GtkWidget *panel,
*panel2,
*button,
*button2,
*button3,
*button4,
*window,
*window2,
*window_t,
*socket,
*sbold;
Display *display;
Window win;
Atom atoms[3];
gtk_init (&argc,&argv);
socket = g_object_new (STATUSBAR_TYPE_ITEM_SOCKET,NULL);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
window2 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
window_t = gtk_window_new (GTK_WINDOW_TOPLEVEL);
panel = g_object_new (DESKTOP_TYPE_PANEL,NULL);
panel2 = g_object_new (DESKTOP_TYPE_PANEL,"orientation",GTK_ORIENTATION_VERTICAL,NULL);
gtk_window_set_type_hint( GTK_WINDOW(window),GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_set_type_hint( GTK_WINDOW(window2),GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_set_type_hint( GTK_WINDOW(window_t),GDK_WINDOW_TYPE_HINT_DESKTOP);
gtk_widget_realize (GTK_WIDGET (window_t));
gtk_widget_set_size_request (GTK_WIDGET (window_t), gdk_screen_width (), gdk_screen_height ());
gtk_window_set_decorated (GTK_WINDOW (window),FALSE);
gtk_widget_realize (window);
gtk_widget_realize (window2);
gtk_widget_set_size_request (GTK_WIDGET (panel),300,40);
gtk_widget_set_size_request (GTK_WIDGET (panel2),80,gdk_screen_height ());
button = gtk_button_new_with_label("Testing");
button2 = GTK_WIDGET (statusbar_item_wrapper_new ("load","/usr/lib/hildon-status-bar/libload.so",FALSE));
button4 = GTK_WIDGET (hn_app_switcher_new ());
button3 = GTK_WIDGET (tasknavigator_item_wrapper_new ("contacts","/usr/lib/hildon-navigator/libosso-contact-plugin.so"));
sbold = gtk_button_new_with_label("Testing 4");
gtk_box_pack_start (GTK_BOX (panel),button, FALSE,FALSE,0);
gtk_box_pack_start (GTK_BOX (panel),socket, FALSE,FALSE,0);
gtk_box_pack_start (GTK_BOX (panel),button2, FALSE,FALSE,0);
gtk_box_pack_start (GTK_BOX (panel),sbold, FALSE,FALSE,0);
gtk_box_pack_start (GTK_BOX (panel2),button3, FALSE,FALSE,0);
gtk_box_pack_start (GTK_BOX (panel2),button4, FALSE,FALSE,0);
gtk_container_add (GTK_CONTAINER (window),panel);
gtk_container_add (GTK_CONTAINER (window2),panel2);
gtk_widget_realize (socket);
printf ("%d\n",hildon_desktop_item_socket_get_id (HILDON_DESKTOP_ITEM_SOCKET(socket)));
gtk_widget_show_all (window_t);
gtk_widget_show_all (window);
gtk_widget_show_all (window2);
gdk_window_move (GDK_WINDOW (window->window), 400, 0);
gtk_main();
return 0;
}
static void create_border_with_arrow(GtkWidget* nw, WindowData* windata)
{
int width;
int height;
int y;
int norm_point_x;
int norm_point_y;
GtkArrowType arrow_type;
GdkScreen* screen;
int arrow_side1_width = DEFAULT_ARROW_WIDTH / 2;
int arrow_side2_width = DEFAULT_ARROW_WIDTH / 2;
int arrow_offset = DEFAULT_ARROW_OFFSET;
GdkPoint* shape_points = NULL;
int i = 0;
int monitor;
GdkRectangle monitor_geometry;
width = windata->width;
height = windata->height;
screen = gdk_window_get_screen(GDK_WINDOW(gtk_widget_get_window(nw)));
monitor = gdk_screen_get_monitor_at_point(screen, windata->point_x, windata->point_y);
gdk_screen_get_monitor_geometry(screen, monitor, &monitor_geometry);
windata->num_border_points = 5;
arrow_type = get_notification_arrow_type(windata->win);
norm_point_x = windata->point_x - monitor_geometry.x;
norm_point_y = windata->point_y - monitor_geometry.y;
/* Handle the offset and such */
switch (arrow_type)
{
case GTK_ARROW_UP:
case GTK_ARROW_DOWN:
if (norm_point_x < arrow_side1_width)
{
arrow_side1_width = 0;
arrow_offset = 0;
}
else if (norm_point_x > monitor_geometry.width - arrow_side2_width)
{
arrow_side2_width = 0;
arrow_offset = width - arrow_side1_width;
}
else
{
if (norm_point_x - arrow_side2_width + width >= monitor_geometry.width)
{
arrow_offset = width - monitor_geometry.width + norm_point_x;
}
else
{
arrow_offset = MIN(norm_point_x - arrow_side1_width, DEFAULT_ARROW_OFFSET);
}
if (arrow_offset == 0 || arrow_offset == width - arrow_side1_width)
{
windata->num_border_points++;
}
else
{
windata->num_border_points += 2;
}
}
/*
* Why risk this for official builds? If it's somehow off the
* screen, it won't horribly impact the user. Definitely less
* than an assertion would...
*/
#if 0
g_assert(arrow_offset + arrow_side1_width >= 0);
g_assert(arrow_offset + arrow_side1_width + arrow_side2_width <= width);
#endif
windata->border_points = g_new0(GdkPoint, windata->num_border_points);
shape_points = g_new0(GdkPoint, windata->num_border_points);
windata->drawn_arrow_begin_x = arrow_offset;
windata->drawn_arrow_middle_x = arrow_offset + arrow_side1_width;
windata->drawn_arrow_end_x = arrow_offset + arrow_side1_width + arrow_side2_width;
if (arrow_type == GTK_ARROW_UP)
{
windata->drawn_arrow_begin_y = DEFAULT_ARROW_HEIGHT;
windata->drawn_arrow_middle_y = 0;
windata->drawn_arrow_end_y = DEFAULT_ARROW_HEIGHT;
if (arrow_side1_width == 0)
{
ADD_POINT(0, 0, 0, 0);
}
else
{
ADD_POINT(0, DEFAULT_ARROW_HEIGHT, 0, 0);
if (arrow_offset > 0)
{
ADD_POINT(arrow_offset - (arrow_side2_width > 0 ? 0 : 1), DEFAULT_ARROW_HEIGHT, 0, 0);
}
ADD_POINT(arrow_offset + arrow_side1_width - (arrow_side2_width > 0 ? 0 : 1), 0, 0, 0);
}
if (arrow_side2_width > 0)
{
ADD_POINT(windata->drawn_arrow_end_x, windata->drawn_arrow_end_y, 1, 0);
ADD_POINT(width - 1, DEFAULT_ARROW_HEIGHT, 1, 0);
}
ADD_POINT(width - 1, height - 1, 1, 1);
ADD_POINT(0, height - 1, 0, 1);
y = windata->point_y;
}
else
{
windata->drawn_arrow_begin_y = height - DEFAULT_ARROW_HEIGHT;
windata->drawn_arrow_middle_y = height;
windata->drawn_arrow_end_y = height - DEFAULT_ARROW_HEIGHT;
ADD_POINT(0, 0, 0, 0);
ADD_POINT(width - 1, 0, 1, 0);
if (arrow_side2_width == 0)
{
ADD_POINT(width - 1, height, (arrow_side1_width > 0 ? 0 : 1), 0);
}
else
{
ADD_POINT(width - 1, height - DEFAULT_ARROW_HEIGHT, 1, 1);
if (arrow_offset < width - arrow_side1_width)
{
ADD_POINT(arrow_offset + arrow_side1_width + arrow_side2_width, height - DEFAULT_ARROW_HEIGHT, 0, 1);
}
ADD_POINT(arrow_offset + arrow_side1_width, height, 0, 1);
}
if (arrow_side1_width > 0)
{
ADD_POINT(windata->drawn_arrow_begin_x - (arrow_side2_width > 0 ? 0 : 1), windata->drawn_arrow_begin_y, 0, 0);
ADD_POINT(0, height - DEFAULT_ARROW_HEIGHT, 0, 1);
}
y = windata->point_y - height;
}
#if 0
g_assert(i == windata->num_border_points);
g_assert(windata->point_x - arrow_offset - arrow_side1_width >= 0);
#endif
gtk_window_move(GTK_WINDOW(windata->win), windata->point_x - arrow_offset - arrow_side1_width, y);
break;
case GTK_ARROW_LEFT:
case GTK_ARROW_RIGHT:
if (norm_point_y < arrow_side1_width)
{
arrow_side1_width = 0;
arrow_offset = norm_point_y;
}
else if (norm_point_y > monitor_geometry.height - arrow_side2_width)
{
arrow_side2_width = 0;
arrow_offset = norm_point_y - arrow_side1_width;
}
break;
default:
g_assert_not_reached();
}
g_assert(shape_points != NULL);
#if GTK_CHECK_VERSION(3, 0, 0)
/* FIXME!!! */
#else
windata->window_region = gdk_region_polygon(shape_points, windata->num_border_points, GDK_EVEN_ODD_RULE);
#endif
g_free(shape_points);
}
static GSList*
test_find_widget_input_windows (GtkWidget *widget,
gboolean input_only)
{
GdkWindow *window;
GList *node, *children;
GSList *matches = NULL;
gpointer udata;
window = gtk_widget_get_window (widget);
gdk_window_get_user_data (window, &udata);
if (udata == widget && (!input_only || (GDK_IS_WINDOW (window) && gdk_window_is_input_only (GDK_WINDOW (window)))))
matches = g_slist_prepend (matches, window);
children = gdk_window_get_children (gtk_widget_get_parent_window (widget));
for (node = children; node; node = node->next)
{
gdk_window_get_user_data (node->data, &udata);
if (udata == widget && (!input_only || (GDK_IS_WINDOW (node->data) && gdk_window_is_input_only (GDK_WINDOW (node->data)))))
matches = g_slist_prepend (matches, node->data);
}
return g_slist_reverse (matches);
}
static void
locate_pointer_paint (MsdLocatePointerData *data,
cairo_t *cr,
gboolean composite)
{
GdkColor color;
gdouble progress, circle_progress;
gint width, height, i;
GtkStyle *style;
progress = data->progress;
#if GTK_CHECK_VERSION(3, 0, 0)
width = gdk_window_get_width(GDK_WINDOW(data->window));
height = gdk_window_get_height(GDK_WINDOW(data->window));
#else
gdk_drawable_get_size(data->window, &width, &height);
#endif
style = gtk_widget_get_style (data->widget);
color = style->bg[GTK_STATE_SELECTED];
cairo_set_source_rgba (cr, 1., 1., 1., 0.);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
for (i = 0; i <= N_CIRCLES; i++)
{
if (progress < 0.)
break;
circle_progress = MIN (1., (progress * 2));
progress -= CIRCLES_PROGRESS_INTERVAL;
if (circle_progress >= 1.)
continue;
if (composite)
{
cairo_set_source_rgba (cr,
color.red / 65535.,
color.green / 65535.,
color.blue / 65535.,
1 - circle_progress);
cairo_arc (cr,
width / 2,
height / 2,
circle_progress * width / 2,
0, 2 * G_PI);
cairo_fill (cr);
cairo_stroke (cr);
}
else
{
cairo_set_source_rgb (cr, 0., 0., 0.);
cairo_set_line_width (cr, 3.);
cairo_arc (cr,
width / 2,
height / 2,
circle_progress * width / 2,
0, 2 * G_PI);
cairo_stroke (cr);
cairo_set_source_rgb (cr, 1., 1., 1.);
cairo_set_line_width (cr, 1.);
cairo_arc (cr,
width / 2,
height / 2,
circle_progress * width / 2,
0, 2 * G_PI);
cairo_stroke (cr);
}
}
}
static gboolean on_countdown_expose(GtkWidget* pie, GdkEventExpose* event, WindowData* windata)
{
GtkStyle* style;
cairo_t* context;
cairo_surface_t* surface;
cairo_t* cr;
GdkColor color;
double r, g, b;
style = gtk_widget_get_style(windata->win);
#if GTK_CHECK_VERSION(3, 0, 0)
context = gdk_cairo_create(GDK_WINDOW(windata->pie_countdown->window));
#else
context = gdk_cairo_create(GDK_DRAWABLE(windata->pie_countdown->window));
#endif
cairo_set_operator(context, CAIRO_OPERATOR_SOURCE);
#if GTK_CHECK_VERSION(3, 0, 0)
GtkAllocation allocation;
gtk_widget_get_allocation(pie, &allocation);
surface = cairo_surface_create_similar(cairo_get_target(context), CAIRO_CONTENT_COLOR_ALPHA, allocation.width, allocation.height);
#else
surface = cairo_surface_create_similar(cairo_get_target(context), CAIRO_CONTENT_COLOR_ALPHA, pie->allocation.width, pie->allocation.height);
#endif
cr = cairo_create(surface);
cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
color = windata->win->style->bg[GTK_STATE_NORMAL];
r = (float) color.red / 65535.0;
g = (float) color.green / 65535.0;
b = (float) color.blue / 65535.0;
cairo_set_source_rgba(cr, r, g, b, BACKGROUND_ALPHA);
cairo_paint(cr);
if (windata->timeout > 0)
{
gdouble pct = (gdouble) windata->remaining / (gdouble) windata->timeout;
gdk_cairo_set_source_color(cr, &style->fg[GTK_STATE_NORMAL]);
cairo_move_to(cr, PIE_RADIUS, PIE_RADIUS);
cairo_arc_negative(cr, PIE_RADIUS, PIE_RADIUS, PIE_RADIUS, -G_PI_2, -(pct * G_PI * 2) - G_PI_2);
cairo_line_to(cr, PIE_RADIUS, PIE_RADIUS);
cairo_fill(cr);
}
cairo_destroy(cr);
cairo_set_source_surface(context, surface, 0, 0);
cairo_paint(context);
cairo_surface_destroy(surface);
cairo_destroy(context);
return TRUE;
}
/**
* matecomponent_control_set_transient_for:
* @control: a control with associated control frame
* @window: a window upon which to set the transient window.
*
* Attempts to make the @window transient for the toplevel
* of any associated controlframe the MateComponentControl may have.
**/
void
matecomponent_control_set_transient_for (MateComponentControl *control,
GtkWindow *window,
CORBA_Environment *opt_ev)
{
CORBA_char *id;
GdkDisplay *display;
GdkWindow *win;
GdkNativeWindow window_id;
CORBA_Environment *ev = NULL, tmp_ev;
MateComponent_ControlFrame frame;
gpointer local_win;
g_return_if_fail (GTK_IS_WINDOW (window));
g_return_if_fail (MATECOMPONENT_IS_CONTROL (control));
/* FIXME: special case the local case !
* we can only do this if set_transient is virtualized
* and thus we can catch it in MateComponentSocket and chain up
* again if we are embedded inside an embedded thing. */
frame = control->priv->frame;
if (frame == CORBA_OBJECT_NIL)
return;
if (opt_ev)
ev = opt_ev;
else {
CORBA_exception_init (&tmp_ev);
ev = &tmp_ev;
}
id = MateComponent_ControlFrame_getToplevelId (frame, ev);
g_return_if_fail (!MATECOMPONENT_EX (ev) && id != NULL);
window_id = matecomponent_control_x11_from_window_id (id);
#ifdef TRANSIENT_DEBUG
g_warning ("Got id '%s' -> %d", id, window_id);
#endif
CORBA_free (id);
display = gtk_widget_get_display (GTK_WIDGET (window));
#if defined (GDK_WINDOWING_X11)
local_win = gdk_xid_table_lookup_for_display (display, window_id);
#elif defined (GDK_WINDOWING_WIN32)
local_win = gdk_win32_handle_table_lookup (window_id);
#endif
if (local_win == NULL)
win = gdk_window_foreign_new_for_display (display, window_id);
else {
win = GDK_WINDOW (local_win);
g_object_ref (win);
}
g_return_if_fail (win != NULL);
window_set_transient_for_gdk (window, win);
if (!opt_ev)
CORBA_exception_free (&tmp_ev);
}
