static void
set_app_window(HippoWindowGtk *window_gtk,
gboolean app_window)
{
GtkWindow *window = GTK_WINDOW(window_gtk);
GtkWidget *widget = GTK_WIDGET(window_gtk);
app_window = app_window != FALSE;
if (window_gtk->app_window == app_window)
return;
window_gtk->app_window = app_window;
gtk_window_set_skip_taskbar_hint(window, !app_window);
gtk_window_set_skip_pager_hint(window, !app_window);
if (app_window) {
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_accept_focus(window, TRUE);
} else {
/* NOTIFICATION is the right type hint, but that's new in GTK+-2.10 */
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DOCK);
gtk_window_set_accept_focus(window, FALSE);
}
/* See note about "background none" in hippo_window_gtk_realize() */
if (GTK_WIDGET_REALIZED(widget)) {
if (app_window) {
/* This should cause the right pixel to be set, replacing background-none */
gtk_style_set_background (widget->style, widget->window, widget->state);
} else {
gdk_window_set_back_pixmap(widget->window, NULL, FALSE);
}
}
}
void set_no_focus(GtkWidget *win)
{
#if UNIX
gdk_window_set_override_redirect(gtk_widget_get_window(win), TRUE);
#else
gtk_window_set_decorated(GTK_WINDOW(win), FALSE);
gtk_window_set_keep_above(GTK_WINDOW(win), TRUE);
gtk_window_set_accept_focus(GTK_WINDOW(win), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_TOOLTIP);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(win), TRUE);
#endif
gtk_window_set_accept_focus(GTK_WINDOW(win), FALSE);
gtk_window_set_focus_on_map (GTK_WINDOW(win), FALSE);
}
static void
cheese_flash_init (CheeseFlash *self)
{
CheeseFlashPrivate *priv = CHEESE_FLASH_GET_PRIVATE (self);
GtkWindow *window;
priv->flash_timeout_tag = 0;
priv->fade_timeout_tag = 0;
window = GTK_WINDOW (gtk_window_new (GTK_WINDOW_POPUP));
/* make it so it doesn't look like a window on the desktop (+fullscreen) */
gtk_window_set_decorated (window, FALSE);
gtk_window_set_skip_taskbar_hint (window, TRUE);
gtk_window_set_skip_pager_hint (window, TRUE);
gtk_window_set_keep_above (window, TRUE);
/* Don't take focus */
gtk_window_set_accept_focus (window, FALSE);
gtk_window_set_focus_on_map (window, FALSE);
/* Don't consume input */
gtk_widget_realize (GTK_WIDGET (window));
GdkRegion *input_region;
input_region = gdk_region_new ();
gdk_window_input_shape_combine_region (gtk_widget_get_window (GTK_WIDGET (window)), input_region, 0, 0);
gdk_region_destroy (input_region);
g_signal_connect (G_OBJECT (window), "expose-event", G_CALLBACK (cheese_flash_window_expose_event_cb), NULL);
priv->window = window;
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1accept_1focus
(
JNIEnv* env,
jclass cls,
jlong _self,
jboolean _setting
)
{
GtkWindow* self;
gboolean setting;
// convert parameter self
self = (GtkWindow*) _self;
// convert parameter setting
setting = (gboolean) _setting;
// call function
gtk_window_set_accept_focus(self, setting);
// cleanup parameter self
// cleanup parameter setting
}
static void
hd_home_plugin_item_constructed (GObject *object)
{
G_OBJECT_CLASS (hd_home_plugin_item_parent_class)->constructed (object);
gtk_window_set_accept_focus (GTK_WINDOW (object), FALSE);
}
static void
hildon_banner_init (HildonBanner *self)
{
HildonBannerPrivate *priv = HILDON_BANNER_GET_PRIVATE (self);
g_assert (priv);
priv->parent = NULL;
priv->overrides_dnd = FALSE;
priv->require_override_dnd = FALSE;
priv->name_suffix = NULL;
priv->main_item = NULL;
/* Initialize the common layout inside banner */
priv->alignment = gtk_alignment_new (0.5, 0.5, 0, 0);
priv->layout = gtk_hbox_new (FALSE, HILDON_MARGIN_DEFAULT);
priv->label = g_object_new (GTK_TYPE_LABEL, NULL);
gtk_label_set_line_wrap (GTK_LABEL (priv->label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (priv->label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_justify (GTK_LABEL (priv->label), GTK_JUSTIFY_CENTER);
gtk_container_set_border_width (GTK_CONTAINER (priv->layout), HILDON_MARGIN_DEFAULT);
gtk_container_add (GTK_CONTAINER (self), priv->alignment);
gtk_container_add (GTK_CONTAINER (priv->alignment), priv->layout);
g_object_ref (priv->label);
gtk_box_pack_start (GTK_BOX (priv->layout), priv->label, FALSE, FALSE, 0);
gtk_window_set_accept_focus (GTK_WINDOW (self), FALSE);
gtk_widget_add_events (GTK_WIDGET (self), GDK_BUTTON_PRESS_MASK);
}
void ami_desktop_init(AmiDesktop *desktop) {
gint sw, sh;
gtk_window_set_screen(GTK_WINDOW(desktop->window), desktop->gscreen);
gtk_window_set_title(GTK_WINDOW(desktop->window), "Desktop");
gtk_window_set_type_hint(GTK_WINDOW(desktop->window), GDK_WINDOW_TYPE_HINT_DESKTOP);
gtk_window_set_accept_focus(GTK_WINDOW(desktop->window), FALSE);
sw = gdk_screen_get_width(desktop->gscreen);
sh = gdk_screen_get_height(desktop->gscreen);
gtk_widget_set_size_request(GTK_WIDGET(desktop->window), sw, sh);
gtk_window_resize(GTK_WINDOW(desktop->window), sw, sh);
gtk_window_move(GTK_WINDOW(desktop->window), 0, 0);
gtk_window_set_resizable(GTK_WINDOW(desktop->window), FALSE);
gtk_widget_set_events(desktop->window, GDK_BUTTON_RELEASE_MASK | GDK_KEY_RELEASE_MASK);
ami_desktop_connect_signals(desktop);
ami_desktop_set_background(desktop);
gtk_widget_show_all(desktop->window);
gtk_widget_queue_draw(GTK_WIDGET(desktop->window));
gtk_window_set_decorated(GTK_WINDOW(desktop->window), FALSE);
}
static void
cheese_flash_init (CheeseFlash *self)
{
CheeseFlashPrivate *priv = self->priv = CHEESE_FLASH_GET_PRIVATE (self);
cairo_region_t *input_region;
GtkWindow *window = GTK_WINDOW (self);
const GdkRGBA white = { 1.0, 1.0, 1.0, 1.0 };
priv->flash_timeout_tag = 0;
priv->fade_timeout_tag = 0;
/* make it so it doesn't look like a window on the desktop (+fullscreen) */
gtk_window_set_decorated (window, FALSE);
gtk_window_set_skip_taskbar_hint (window, TRUE);
gtk_window_set_skip_pager_hint (window, TRUE);
gtk_window_set_keep_above (window, TRUE);
/* Don't take focus */
gtk_window_set_accept_focus (window, FALSE);
gtk_window_set_focus_on_map (window, FALSE);
/* Make it white */
gtk_widget_override_background_color (GTK_WIDGET (window), GTK_STATE_NORMAL,
&white);
/* Don't consume input */
gtk_widget_realize (GTK_WIDGET (window));
input_region = cairo_region_create ();
gdk_window_input_shape_combine_region (gtk_widget_get_window (GTK_WIDGET (window)), input_region, 0, 0);
cairo_region_destroy (input_region);
}
void set_no_focus(GtkWidget *win)
{
gdk_window_set_override_redirect(gtk_widget_get_window(win), TRUE);
gtk_window_set_accept_focus(GTK_WINDOW(win), FALSE);
gtk_window_set_focus_on_map (GTK_WINDOW(win), FALSE);
gtk_window_set_resizable (GTK_WINDOW (win), FALSE);
}
void ZLGtkProgressDialog::run(ZLRunnable &runnable) {
while (gtk_events_pending()) {
gtk_main_iteration();
}
GtkWindow *mainWindow = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
gtk_window_set_accept_focus(mainWindow, FALSE);
myLabel = gtk_label_new(messageText().c_str());
gtk_misc_set_padding(GTK_MISC(myLabel), 10, 10); // something nice?
gtk_container_add(GTK_CONTAINER(mainWindow), myLabel);
gtk_widget_show_all(GTK_WIDGET(mainWindow));
GdkCursor *cursor = gdk_cursor_new(GDK_WATCH);
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, cursor);
}
gdk_window_set_cursor(GTK_WIDGET(mainWindow)->window, cursor);
gdk_cursor_unref(cursor);
int x, y, w, h;
if (myParent != 0) {
gtk_window_get_position(myParent, &x, &y);
gtk_window_get_size(myParent, &w, &h);
x += w / 2;
y += h / 2;
} else {
GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
gdk_window_get_geometry(root, &x, &y, &w, &h, 0);
x += w / 2;
y += h / 2;
}
gtk_window_get_size(mainWindow, &w, &h);
x -= w / 2;
y -= h / 2;
gtk_window_move(mainWindow, x, y);
while (gtk_events_pending()) {
gtk_main_iteration();
}
if (myParent != 0) {
gtk_widget_queue_draw(GTK_WIDGET(myParent));
}
while (gtk_events_pending()) {
gtk_main_iteration();
}
runnable.run();
myLabel = 0;
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, 0);
}
gtk_widget_destroy(GTK_WIDGET(mainWindow));
}
static WidgetInfo *
new_widget_info (const char *name,
GtkWidget *widget,
WidgetSize size)
{
WidgetInfo *info;
info = g_new0 (WidgetInfo, 1);
info->name = g_strdup (name);
info->size = size;
info->no_focus = TRUE;
if (GTK_IS_WINDOW (widget))
{
info->window = widget;
gtk_window_set_resizable (GTK_WINDOW (info->window), FALSE);
g_signal_connect_swapped (info->window, "realize",
G_CALLBACK (realize_callback), info);
}
else
{
info->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_accept_focus (GTK_WINDOW (info->window), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (info->window), 12);
gtk_container_add (GTK_CONTAINER (info->window), widget);
gtk_widget_show_all (widget);
}
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (info->window), TRUE);
gtk_widget_set_app_paintable (info->window, TRUE);
g_signal_connect (info->window, "focus", G_CALLBACK (gtk_true), NULL);
switch (size)
{
case SMALL:
gtk_widget_set_size_request (info->window, SMALL_WIDTH, SMALL_HEIGHT);
break;
case MEDIUM:
gtk_widget_set_size_request (info->window, MEDIUM_WIDTH, MEDIUM_HEIGHT);
break;
case LARGE:
gtk_widget_set_size_request (info->window, LARGE_WIDTH, LARGE_HEIGHT);
break;
default:
break;
}
return info;
}
JS_EXPORT_API
void osd_set_focus(gboolean focus)
{
gtk_window_set_focus_on_map (GTK_WINDOW (container), focus);
gtk_window_set_accept_focus (GTK_WINDOW (container), focus);
gtk_window_set_focus_visible (GTK_WINDOW (container), focus);
GdkWindow* gdkwindow = gtk_widget_get_window (container);
gdk_window_set_focus_on_map (gdkwindow, focus);
gdk_window_set_accept_focus (gdkwindow, focus);
gdk_window_set_override_redirect(gdkwindow, !focus);
}
int lassi_osd_init(LassiOsdInfo *osd) {
GtkWidget *hbox;
g_assert(osd);
memset(osd, 0, sizeof(*osd));
osd->window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_title(GTK_WINDOW(osd->window), "Mango Lassi OSD");
gtk_window_stick(GTK_WINDOW(osd->window));
gtk_window_set_keep_above(GTK_WINDOW(osd->window), TRUE);
gtk_window_set_decorated(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_deletable(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_type_hint(GTK_WINDOW(osd->window), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(osd->window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(osd->window), TRUE);
gtk_window_set_accept_focus(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_focus_on_map(GTK_WINDOW(osd->window), FALSE);
gtk_window_set_gravity(GTK_WINDOW(osd->window), GDK_GRAVITY_SOUTH_WEST);
gtk_widget_set_app_paintable(GTK_WIDGET(osd->window), TRUE);
g_signal_connect(osd->window, "draw", G_CALLBACK(draw_cb), NULL);
osd->label = gtk_label_new("Test");
gtk_misc_set_padding(GTK_MISC(osd->label), 16, 0);
/* gtk_label_set_line_wrap(GTK_LABEL(osd->label), TRUE); */
osd->left_icon = gtk_image_new();
osd->right_icon = gtk_image_new();
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 8);
gtk_box_pack_start(GTK_BOX(hbox), osd->left_icon, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), osd->label, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), osd->right_icon, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(osd->window), hbox);
gtk_widget_show(hbox);
gtk_widget_show(osd->label);
gtk_widget_realize(GTK_WIDGET(osd->window));
/*g_debug("WINDOW=%p", osd->window);*/
return 0;
}
void WXAppBar::SetAcceptFocus (bool accept)
{
#if defined(__WXMSW__)
// TODO
(void)(accept); // Remove warning
//assert (false);
#elif defined(__WXGTK__)
// Get X11 handle for our window
GtkWindow *gtkWindow= (GtkWindow *) GetHandle();
assert (gtkWindow);
if (!gtkWindow) return;
gtk_window_set_accept_focus (gtkWindow, (accept? TRUE : FALSE));
#else
assert (false);
#endif
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GnomenuGlobalMenuBar *menubar;
gtk_init (&argc, &argv);
menubar = gnomenu_global_menu_bar_new();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_MENU);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_accept_focus(GTK_WINDOW(window), FALSE);
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(menubar));
gtk_widget_show_all(window);
gtk_main ();
return 0;
}
ZLGtkWaitMessage::ZLGtkWaitMessage(GtkWindow *parent, const std::string& message) : myParent(parent) {
while (gtk_events_pending()) {
gtk_main_iteration();
}
myWindow = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));
gtk_window_set_accept_focus(myWindow, FALSE);
GtkWidget *label = gtk_label_new(message.c_str());
gtk_misc_set_padding(GTK_MISC(label), 10, 10); // something nice?
gtk_container_add(GTK_CONTAINER(myWindow), label);
gtk_widget_show_all(GTK_WIDGET(myWindow));
GdkCursor *cursor = gdk_cursor_new(GDK_WATCH);
if (myParent != 0) {
gdk_window_set_cursor(GTK_WIDGET(myParent)->window, cursor);
}
gdk_window_set_cursor(GTK_WIDGET(myWindow)->window, cursor);
gdk_cursor_unref(cursor);
int x, y, w, h;
if (myParent != 0) {
gtk_window_get_position(myParent, &x, &y);
gtk_window_get_size(myParent, &w, &h);
x += w / 2;
y += h / 2;
} else {
GdkWindow *root = gdk_screen_get_root_window(gdk_screen_get_default());
gdk_window_get_geometry(root, &x, &y, &w, &h, 0);
x += w / 2;
y += h / 2;
}
gtk_window_get_size(myWindow, &w, &h);
x -= w / 2;
y -= h / 2;
gtk_window_move(myWindow, x, y);
while (gtk_events_pending()) {
gtk_main_iteration();
}
}
bool VideoOverlay::initialize( const Rect &rect ) {
assert(_main);
LDEBUG("gtk::VideoOverlay", "Initialize");
// Create top level window
_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated (GTK_WINDOW (_window), FALSE);
gtk_window_set_resizable (GTK_WINDOW(_window), FALSE);
gtk_window_set_skip_taskbar_hint( GTK_WINDOW(_window), TRUE );
gtk_window_set_accept_focus( GTK_WINDOW(_window), FALSE );
gtk_window_set_destroy_with_parent( GTK_WINDOW(_window), TRUE );
gtk_widget_realize(_window);
_rect = rect;
config();
gtk_widget_show(_window);
return true;
}
static void
init_pop_win(void)
{
if (POP_WIN == NULL) {
GtkWidget *vbox, *hbox;
int i;
POP_WIN = g_new0(PopWinData, 1);
POP_WIN->window = gtk_window_new(GTK_WINDOW_POPUP);
g_signal_connect(G_OBJECT(POP_WIN->window), "size-allocate",
G_CALLBACK(pop_win_size_allocate), NULL);
gtk_window_set_accept_focus(GTK_WINDOW(POP_WIN->window), FALSE);
gtk_window_set_resizable(GTK_WINDOW(POP_WIN->window), FALSE);
vbox = gtk_vbox_new(FALSE, 5);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 5);
POP_WIN->dummy_height_widget = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), POP_WIN->dummy_height_widget,
FALSE, FALSE, 0);
init_candidate_items();
for (i = 0; i < MAX_POP_WIN_ITEMS; i++) {
gtk_box_pack_start(GTK_BOX(hbox), candidate_items[i].separator,
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), candidate_items[i].widget,
FALSE, FALSE, 0);
}
gtk_widget_show_all(vbox);
// we never show first separator;
gtk_widget_hide(candidate_items[0].separator);
gtk_container_add (GTK_CONTAINER(POP_WIN->window), vbox);
}
}
int
main (int argc,
char** argv)
{
GtkWidget* window;
guint pointer_update_id;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
if (!window)
return 0;
gtk_window_set_type_hint (GTK_WINDOW (window),
GDK_WINDOW_TYPE_HINT_DOCK);
gtk_widget_add_events (window,
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
// hook up input/event handlers to window
g_signal_connect (G_OBJECT (window),
"screen-changed",
G_CALLBACK (screen_changed_handler),
NULL);
g_signal_connect (G_OBJECT (window),
"composited-changed",
G_CALLBACK (composited_changed_handler),
NULL);
gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y);
// make sure the window opens with a RGBA-visual
screen_changed_handler (window, NULL, NULL);
gtk_widget_realize (window);
gdk_window_set_back_pixmap (gtk_widget_get_window (window), NULL, FALSE);
// hook up window-event handlers to window
g_signal_connect (G_OBJECT (window),
"expose-event",
G_CALLBACK (expose_handler),
NULL);
// FIXME: read out current mouse-pointer position every 1/25 second
pointer_update_id = g_timeout_add (1000/40,
(GSourceFunc) pointer_update,
(gpointer) window);
g_timeout_add (10000,
(GSourceFunc) quit,
NULL);
g_timeout_add (1000/40,
(GSourceFunc) grow,
(gpointer) window);
// "clear" input-mask, set title/icon/attributes
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_decorated (GTK_WINDOW (window), FALSE);
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
gtk_window_set_opacity (GTK_WINDOW (window), 1.0f);
gtk_widget_set_size_request (window,
(gint) (BUBBLE_WIDTH + 2.0f *
BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f *
BUBBLE_SHADOW_SIZE));
gtk_widget_show (window);
g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window));
update_input_shape (window, 1, 1);
update_shape (window,
(gint) CORNER_RADIUS,
(gint) BUBBLE_SHADOW_SIZE);
set_bg_blur (window, TRUE);
setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE),
(gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE));
g_print ("This test will run for 10 seconds and then quit.\n");
gtk_main ();
tile_destroy (g_tile);
return 0;
}
static GtkWidget *
mnb_notification_gtk_create ()
{
GtkWidget *widget = NULL;
GtkWindow *window;
GtkWidget *evbox;
GdkPixbuf *pixbuf;
img_normal = gtk_image_new_from_file (THEMEDIR
"/notifiers/fscreen-notif-normal.png");
if (img_normal)
g_object_ref (img_normal);
img_hover = gtk_image_new_from_file (THEMEDIR
"/notifiers/fscreen-notif-hover.png");
if (img_hover)
g_object_ref (img_hover);
widget = gtk_window_new (GTK_WINDOW_POPUP);
window = GTK_WINDOW (widget);
pixbuf = gdk_pixbuf_new_from_file (THEMEDIR
"/notifiers/fscreen-notif-normal.png",
NULL);
if (pixbuf)
{
gint width, height, rowstride, channels;
guchar *pixels;
gint x, y;
GdkDrawable *mask;
GdkGC *gc;
rowstride = gdk_pixbuf_get_rowstride (pixbuf);
pixels = gdk_pixbuf_get_pixels (pixbuf);
width = gdk_pixbuf_get_width (pixbuf);
height = gdk_pixbuf_get_height (pixbuf);
channels = gdk_pixbuf_get_n_channels (pixbuf);
g_assert (channels == 4);
mask = gdk_pixmap_new (NULL, width, height, 1);
gc = gdk_gc_new (mask);
for (x = 0; x < width; ++x)
for (y = 0; y < height; ++y)
{
GdkColor clr;
guchar *p = pixels + y * rowstride + x * channels;
if (p[3] == 0)
clr.pixel = 0;
else
clr.pixel = 1;
gdk_gc_set_foreground (gc, &clr);
gdk_draw_point (mask, gc, x, y);
}
gtk_widget_shape_combine_mask (widget, mask, 0, 0);
g_object_unref (mask);
g_object_unref (pixbuf);
g_object_unref (gc);
}
gtk_window_set_decorated (window, FALSE);
gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_window_set_resizable (window, FALSE);
gtk_window_set_title (window, "mnb-notification-gtk");
gtk_window_set_accept_focus (window, FALSE);
gtk_window_move (window, 20, 20);
evbox = gtk_event_box_new ();
gtk_event_box_set_visible_window (GTK_EVENT_BOX (evbox), FALSE);
gtk_event_box_set_above_child (GTK_EVENT_BOX (evbox), TRUE);
if (!img_normal)
{
gtk_container_add (GTK_CONTAINER (evbox),
gtk_button_new_with_label ("Notifications"));
}
else
{
gtk_container_add (GTK_CONTAINER (evbox), img_normal);
}
gtk_container_add (GTK_CONTAINER (window), evbox);
gtk_widget_show (evbox);
g_signal_connect (evbox, "button-press-event",
G_CALLBACK(mnb_notification_gtk_click_cb),
NULL);
if (img_normal && img_hover)
{
g_signal_connect (evbox, "enter-notify-event",
G_CALLBACK(mnb_notification_gtk_crossing_cb),
NULL);
g_signal_connect (evbox, "leave-notify-event",
G_CALLBACK(mnb_notification_gtk_crossing_cb),
NULL);
}
return widget;
}
static void
hd_incoming_event_window_init (HDIncomingEventWindow *window)
{
HDIncomingEventWindowPrivate *priv = HD_INCOMING_EVENT_WINDOW_GET_PRIVATE (window);
GtkWidget *main_table;
window->priv = priv;
main_table = gtk_table_new (2, 2, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (main_table), ICON_SPACING);
gtk_container_set_border_width (GTK_CONTAINER (main_table), WINDOW_MARGIN);
gtk_widget_set_size_request (GTK_WIDGET (main_table), WINDOW_WIDTH, WINDOW_HEIGHT);
gtk_widget_show (main_table);
priv->icon = gtk_image_new ();
/* gtk_image_set_pixel_size (GTK_IMAGE (priv->icon), HILDON_ICON_SIZE_STYLUS); */
gtk_widget_set_size_request (priv->icon, ICON_SIZE, ICON_SIZE);
gtk_widget_show (priv->icon);
gtk_table_attach (GTK_TABLE (main_table),
priv->icon,
0, 1,
0, 1,
0, 0,
0, 0);
priv->title = gtk_label_new (NULL);
gtk_widget_set_name (GTK_WIDGET (priv->title), "HDIncomingEventWindow-Text");
gtk_misc_set_alignment (GTK_MISC (priv->title), 0.0, 0.5);
gtk_widget_set_size_request (priv->title, TITLE_TEXT_WIDTH, TITLE_TEXT_HEIGHT);
hildon_helper_set_logical_font (priv->title, TITLE_TEXT_FONT);
gtk_widget_show (priv->title);
gtk_table_attach (GTK_TABLE (main_table),
priv->title,
1, 2,
0, 1,
GTK_EXPAND | GTK_FILL, GTK_FILL,
0, TITLE_TEXT_PADDING);
priv->amount_label = gtk_label_new (NULL);
gtk_widget_set_name (GTK_WIDGET (priv->amount_label), "HDIncomingEventWindow-Text");
gtk_misc_set_alignment (GTK_MISC (priv->amount_label), 0.5, 0.5);
gtk_widget_set_size_request (priv->amount_label, ICON_SIZE, SECONDARY_TEXT_HEIGHT);
hildon_helper_set_logical_font (priv->amount_label, SECONDARY_TEXT_FONT);
gtk_widget_show (priv->amount_label);
gtk_table_attach (GTK_TABLE (main_table),
priv->amount_label,
0, 1,
1, 2,
GTK_FILL, GTK_FILL,
0, 0);
priv->message = gtk_label_new (NULL);
gtk_widget_set_name (GTK_WIDGET (priv->message), "HDIncomingEventWindow-Secondary");
gtk_misc_set_alignment (GTK_MISC (priv->message), 0.0, 0.5);
gtk_widget_set_size_request (priv->message, SECONDARY_TEXT_WIDTH, SECONDARY_TEXT_HEIGHT);
hildon_helper_set_logical_font (priv->message, SECONDARY_TEXT_FONT);
gtk_widget_show (priv->message);
gtk_table_attach (GTK_TABLE (main_table),
priv->message,
1, 2,
1, 2,
GTK_EXPAND | GTK_FILL, GTK_FILL,
0, 0);
/* Pack containers */
gtk_container_add (GTK_CONTAINER (window), main_table);
/* Enable handling of button press events */
gtk_widget_add_events (GTK_WIDGET (window), GDK_BUTTON_PRESS_MASK);
/* Don't take focus away from the toplevel application. */
gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);
/* bg image */
priv->bg_image = hd_cairo_surface_cache_get_surface (hd_cairo_surface_cache_get (),
BACKGROUND_IMAGE_FILE);
g_signal_connect_object (hd_incoming_events_get (), "display-status-changed",
G_CALLBACK (display_status_changed), window, 0);
gtk_widget_set_size_request (GTK_WIDGET (window),
cairo_image_surface_get_width (priv->bg_image),
cairo_image_surface_get_height (priv->bg_image));
}
/**
* create store window
*/
void nsgtk_toolbar_window_open(nsgtk_scaffolding *g)
{
int x = 0, y = 0;
GError* error = NULL;
struct nsgtk_theme *theme =
nsgtk_theme_load(GTK_ICON_SIZE_LARGE_TOOLBAR);
if (theme == NULL) {
warn_user(messages_get("NoMemory"), 0);
nsgtk_toolbar_cancel_clicked(NULL, g);
return;
}
window->glade = gtk_builder_new();
if (!gtk_builder_add_from_file(window->glade,
glade_file_location->toolbar,
&error)) {
g_warning ("Couldn't load builder file: %s", error->message);
g_error_free (error);
warn_user(messages_get("NoMemory"), 0);
nsgtk_toolbar_cancel_clicked(NULL, g);
return;
}
gtk_builder_connect_signals(window->glade, NULL);
window->window = GTK_WIDGET(gtk_builder_get_object(window->glade, "toolbarwindow"));
if (window->window == NULL) {
warn_user(messages_get("NoMemory"), 0);
nsgtk_toolbar_cancel_clicked(NULL, g);
free(theme);
return;
}
window->widgetvbox = GTK_WIDGET(gtk_builder_get_object(window->glade, "widgetvbox"));
if (window->widgetvbox == NULL) {
warn_user(messages_get("NoMemory"), 0);
nsgtk_toolbar_cancel_clicked(NULL, g);
free(theme);
return;
}
window->numberh = NSGTK_STORE_WIDTH; /* preset to width [in buttons] of */
/* store to cause creation of a new toolbar */
window->currentbutton = -1;
/* load toolbuttons */
/* add toolbuttons to window */
/* set event handlers */
for (int i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++) {
if (i == URL_BAR_ITEM)
continue;
window->store_buttons[i] =
nsgtk_toolbar_make_widget(g, i, theme);
if (window->store_buttons[i] == NULL) {
warn_user(messages_get("NoMemory"), 0);
continue;
}
nsgtk_toolbar_add_store_widget(window->store_buttons[i]);
g_signal_connect(window->store_buttons[i], "drag-data-get",
G_CALLBACK(
nsgtk_scaffolding_button(g, i)->dataplus), g);
}
free(theme);
gtk_window_set_transient_for(GTK_WINDOW(window->window),
nsgtk_scaffolding_window(g));
gtk_window_set_title(GTK_WINDOW(window->window), messages_get(
"gtkToolBarTitle"));
gtk_window_set_accept_focus(GTK_WINDOW(window->window), FALSE);
gtk_drag_dest_set(GTK_WIDGET(window->window), GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_DROP, &entry, 1, GDK_ACTION_COPY);
gtk_widget_show_all(window->window);
gtk_window_set_position(GTK_WINDOW(window->window),
GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_get_position(nsgtk_scaffolding_window(g), &x, &y);
gtk_window_move(GTK_WINDOW(window->window), x, y + 100);
g_signal_connect(GTK_WIDGET(gtk_builder_get_object(window->glade, "cancelbutton")),
"clicked",
G_CALLBACK(nsgtk_toolbar_cancel_clicked),
g);
g_signal_connect(GTK_WIDGET(gtk_builder_get_object(window->glade, "okbutton")),
"clicked", G_CALLBACK(nsgtk_toolbar_persist), g);
g_signal_connect(GTK_WIDGET(gtk_builder_get_object(window->glade, "resetbutton")),
"clicked", G_CALLBACK(nsgtk_toolbar_reset), g);
g_signal_connect(window->window, "delete-event",
G_CALLBACK(nsgtk_toolbar_delete), g);
g_signal_connect(window->window, "drag-drop",
G_CALLBACK(nsgtk_toolbar_store_return), g);
g_signal_connect(window->window, "drag-motion",
G_CALLBACK(nsgtk_toolbar_store_action), g);
}
/* panel_window_set_accept_focus */
void panel_window_set_accept_focus(PanelWindow * panel, gboolean accept)
{
gtk_window_set_accept_focus(GTK_WINDOW(panel->window), accept);
}
/* 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;
}
int main (int argc, char *argv[])
{
if(argc > 1 && (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-H")))
{
printf("Ponies for Linux/GTK+ by rabbit\n");
printf("Command list:\n");
printf("No Parameters: Run with the settings used from last run\n");
printf("-h: Display this help\n");
printf("file path: Set new file path to look for pony gif files\n");
printf("ponyname: Sets to run one of the pony type listed\n");
return 0;
}
for(int i = 1; i < argc; i++)
if(*argv[i] == '/')
setPonyDirectory(argv[i]);
char* ponyDirectory = NULL;
char* ponyHomeFile = NULL;
ponyHomeFile = malloc((strlen(getenv("HOME"))+ 9) * sizeof(char));
if(!ponyHomeFile)
{
printf("Could not allocate memory for ponyHomeFile\n");
return 0;
}
strcpy(ponyHomeFile, getenv("HOME"));
strcat(ponyHomeFile,"/.ponies");
ponyDirectory = getPonyDirectory();
if(!ponyDirectory)
{
free(ponyHomeFile);
printf("Error locating pony directory\n");
return 0;
}
//Initialize GTK+ and set up loggers
GError* error = NULL;
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, (GLogFunc) gtk_false, NULL);
gtk_init (&argc, &argv);
g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, g_log_default_handler, NULL);
//For command line commands later, require input on inital load
//Normally would close, but hard coded in for easier testing
int numberOfPonies = 0;
if(argc == 1)
{
//Read in from ~/.ponies file to find saved settings
FILE* ifp = NULL;
char buffer[256];
ifp = fopen(ponyHomeFile,"r");
if(!ifp)
{
free(ponyHomeFile);
free(ponyDirectory);
printf("Could not open file for reading\n");
return 0;
}
//fread(buffer, sizeof(char), 256, ifp);
while(fgets(buffer, 256, ifp))
if(buffer[0] != '\n')
numberOfPonies++;
fclose(ifp);
numberOfPonies--;//First line is directory
}
//Not default arguments
else
{
for(int i = 1; i < argc; i++)
{
if(*argv[i] == '/')
continue;
numberOfPonies++;
}
}
//Seed the randomizer
srand(time(0));
//Number of ponies
pony ponyArray[numberOfPonies];
char buffer[256];
FILE* ifp = NULL;
ifp = fopen(ponyHomeFile,"r");
if(!ifp)
{
printf("Could not open ~/.ponies\n");
free(ponyDirectory);
free(ponyHomeFile);
return 0;
}
fgets(buffer, 256, ifp);//throw away first line
//0 Ponies
if(!numberOfPonies)
{
free(ponyDirectory);
free(ponyHomeFile);
printf("No ponies in the ~/.ponies file! Add some ponies!\n");
printf("allowable ponies are: ");
for(int i = 0; i <= Zecora; i++)
printf("%s ", getDirectoryName(i));
return 0;
}
//Make pony windows
for( int i = 0; i < numberOfPonies; i++)
{
fgets(buffer, 256, ifp);
char* temp = NULL;
temp = strchr(buffer, '\n');
if(temp)
buffer[temp - buffer] = '\0';
ponyArray[i].name = ponyNameFromString(buffer);
ponyArray[i].direction = DirNone;
ponyArray[i].dragActive = 0;
ponyArray[i].speed = SpeedStopped;
ponyArray[i].animation = AnimIdle;
ponyArray[i].active = 1;
ponyArray[i].facing = FaceLeft;
//Create animation from file, default is idle_left
char* initialPicturePath;
initialPicturePath = malloc((strlen(ponyDirectory) +
strlen(getDirectoryName(ponyArray[i].name)) +
14) * sizeof(char));
if(!initialPicturePath)
{
printf("Unable to allocate memory for directory");
continue;
}
strcpy(initialPicturePath, ponyDirectory);
strcat(initialPicturePath, getDirectoryName(ponyArray[i].name));
strcat(initialPicturePath, "/idle_left.gif");
ponyArray[i].pictureanim = gdk_pixbuf_animation_new_from_file
(initialPicturePath, &error);
free(initialPicturePath);
ponyArray[i].image = gtk_image_new_from_animation(ponyArray[i].pictureanim);
ponyArray[i].pictureanimit = gdk_pixbuf_animation_get_iter
(ponyArray[i].pictureanim, NULL);
ponyArray[i].win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//Resize everytime the gif updates
g_timeout_add(gdk_pixbuf_animation_iter_get_delay_time(ponyArray[i].
pictureanimit),(GSourceFunc)updateWinSize, &ponyArray[i]);
//Name the window the name of the pony being animated
gtk_window_set_title(GTK_WINDOW(ponyArray[i].win),
getPonyName(ponyArray[i].name));
//Size down the window before showing it
gtk_window_set_default_size(GTK_WINDOW(ponyArray[i].win),
gdk_pixbuf_animation_get_width(ponyArray[i].
pictureanim), gdk_pixbuf_animation_get_height
(ponyArray[i].pictureanim));
//Remove the titlebar
gtk_window_set_decorated(GTK_WINDOW(ponyArray[i].win), FALSE);
//Set up the signals
ponyArray[i].clickEventID = g_signal_connect(G_OBJECT(ponyArray[i].win),
"button_press_event", G_CALLBACK(click_event),
&ponyArray[i]);
ponyArray[i].enterEventID = g_signal_connect(G_OBJECT(ponyArray[i].win),
"enter-notify-event", G_CALLBACK(enter_event),
&ponyArray[i]);
ponyArray[i].leaveEventID = g_signal_connect(G_OBJECT(ponyArray[i].win),
"leave-notify-event", G_CALLBACK(enter_event),
&ponyArray[i]);
gtk_widget_add_events(ponyArray[i].win, GDK_BUTTON_PRESS_MASK);
gtk_container_add(GTK_CONTAINER(ponyArray[i].win), GTK_WIDGET(ponyArray[i].
image));
//Get rid of taskbar item
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(ponyArray[i].win), TRUE);
//Make it so it can't be selected
gtk_window_set_accept_focus(GTK_WINDOW(ponyArray[i].win), FALSE);
gtk_widget_realize(ponyArray[i].win);
//Always on top
gtk_window_set_keep_above(GTK_WINDOW(ponyArray[i].win), TRUE);
updateWinSize(&ponyArray[i]);
if(error != NULL)
break;
}
free(ponyDirectory);
free(ponyHomeFile);
//Quit out if there were any errors and give a message
if( error != NULL)
{
printf("%s\n",error->message);
return 0;
}
//Make it transparent?
/*cr = gdk_cairo_create(win->window);
cairo_set_source_rgba(cr, 1.0, 1.0, 1.0, 0);
cairo_set_operator( cr, CAIRO_OPERATOR_SOURCE);
cairo_paint(cr);
gtk_container_add(GTK_CONTAINER(win), GTK_WIDGET(image));*/
//Main loop
for( int i = 0; i < numberOfPonies; i++)
gtk_widget_show_all(ponyArray[i].win);
gtk_main();
return 0;
}
static void otrg_gtk_ui_config_buddy(PurpleBuddy *buddy)
{
GtkWidget *dialog;
GtkWidget *label;
char *label_text;
char *label_markup;
struct cbdata *data = malloc(sizeof(struct cbdata));
if (!data) return;
dialog = gtk_dialog_new_with_buttons(_("OTR Settings"),
NULL, 0,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_window_set_accept_focus(GTK_WINDOW(dialog), FALSE);
gtk_window_set_role(GTK_WINDOW(dialog), "otr_settings");
gtk_container_set_border_width(GTK_CONTAINER(dialog), 6);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(dialog)->vbox), 0);
gtk_container_set_border_width(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), 0);
data->dialog = dialog;
data->buddy = buddy;
/* Set the title */
label_text = g_strdup_printf(_("OTR Settings for %s"),
purple_buddy_get_contact_alias(buddy));
label_markup = g_strdup_printf("<span weight=\"bold\" size=\"larger\">"
"%s</span>", label_text);
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label), label_markup);
g_free(label_markup);
g_free(label_text);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), label,
FALSE, FALSE, 5);
/* Make the cascaded checkboxes */
data->defaultbox = gtk_check_button_new_with_label(_("Use default "
"OTR settings for this buddy"));
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), data->defaultbox,
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), gtk_hseparator_new(),
FALSE, FALSE, 5);
create_otrsettings_buttons(&(data->os), GTK_DIALOG(dialog)->vbox);
g_signal_connect(G_OBJECT(data->defaultbox), "clicked",
G_CALLBACK(default_clicked_cb), data);
g_signal_connect(G_OBJECT(data->defaultbox), "clicked",
G_CALLBACK(config_buddy_clicked_cb), data);
g_signal_connect(G_OBJECT(data->os.enablebox), "clicked",
G_CALLBACK(config_buddy_clicked_cb), data);
g_signal_connect(G_OBJECT(data->os.automaticbox), "clicked",
G_CALLBACK(config_buddy_clicked_cb), data);
g_signal_connect(G_OBJECT(data->os.onlyprivatebox), "clicked",
G_CALLBACK(config_buddy_clicked_cb), data);
g_signal_connect(G_OBJECT(data->os.avoidloggingotrbox), "clicked",
G_CALLBACK(config_buddy_clicked_cb), data);
/* Set the inital states of the buttons */
load_buddyprefs(data);
g_signal_connect(G_OBJECT(dialog), "destroy",
G_CALLBACK(config_buddy_destroy_cb), data);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(config_buddy_response_cb), data);
gtk_widget_show_all(dialog);
}
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);
}
}
static gboolean notification_popup_create(MsgInfo *msginfo)
{
GdkColor bg;
GdkColor fg;
NotificationPopup *ppopup;
g_return_val_if_fail(msginfo, FALSE);
ppopup = &popup;
/* Window */
ppopup->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "notification_popup");
gtk_window_set_decorated(GTK_WINDOW(ppopup->window), FALSE);
gtk_window_set_keep_above(GTK_WINDOW(ppopup->window), TRUE);
gtk_window_set_accept_focus(GTK_WINDOW(ppopup->window), FALSE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(ppopup->window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(ppopup->window), TRUE);
gtk_window_move(GTK_WINDOW(ppopup->window), notify_config.popup_root_x,
notify_config.popup_root_y);
gtk_window_resize(GTK_WINDOW(ppopup->window), notify_config.popup_width, 1);
if(notify_config.popup_sticky)
gtk_window_stick(GTK_WINDOW(ppopup->window));
/* Signals */
gtk_widget_set_events(ppopup->window,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_signal_connect(ppopup->window, "button_press_event",
G_CALLBACK(notification_popup_button), NULL);
/* Event box */
ppopup->event_box = gtk_event_box_new();
gtk_container_add(GTK_CONTAINER(ppopup->window), ppopup->event_box);
/* Frame */
ppopup->frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(ppopup->frame), GTK_SHADOW_ETCHED_OUT);
gtk_container_add(GTK_CONTAINER(ppopup->event_box), ppopup->frame);
/* Vbox with labels */
ppopup->vbox = gtk_vbox_new(FALSE, 2);
gtk_container_set_border_width(GTK_CONTAINER(ppopup->vbox), 5);
ppopup->label1 = gtk_label_new(msginfo->from ?
msginfo->from : _("(No From)"));
gtk_box_pack_start(GTK_BOX(ppopup->vbox), ppopup->label1, FALSE, FALSE, 0);
ppopup->label2 = gtk_label_new(msginfo->subject ?
msginfo->subject : _("(No Subject)"));
gtk_box_pack_start(GTK_BOX(ppopup->vbox), ppopup->label2, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(ppopup->frame), ppopup->vbox);
gtk_widget_set_size_request(ppopup->vbox, notify_config.popup_width, -1);
/* Color */
if(notify_config.popup_enable_colors) {
gtkut_convert_int_to_gdk_color(notify_config.popup_color_bg,&bg);
gtkut_convert_int_to_gdk_color(notify_config.popup_color_fg,&fg);
gtk_widget_modify_bg(ppopup->event_box,GTK_STATE_NORMAL,&bg);
gtk_widget_modify_fg(ppopup->label1,GTK_STATE_NORMAL,&fg);
gtk_widget_modify_fg(ppopup->label2,GTK_STATE_NORMAL,&fg);
}
gtk_widget_show_all(ppopup->window);
ppopup->count = 1;
if(msginfo->folder && msginfo->folder->name) {
gchar *ident;
ident = folder_item_get_identifier(msginfo->folder);
ppopup->msg_path = g_strdup_printf("%s%s%u", ident,G_DIR_SEPARATOR_S,
msginfo->msgnum);
g_free(ident);
}
return TRUE;
}
static void
panel_start_gui(panel *p)
{
ENTER;
// main toplevel window
p->topgwin = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(p->topgwin), 0);
g_signal_connect(G_OBJECT(p->topgwin), "destroy-event",
(GCallback) panel_destroy_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "size-request",
(GCallback) panel_size_req, p);
g_signal_connect(G_OBJECT(p->topgwin), "map-event",
(GCallback) panel_mapped, p);
g_signal_connect(G_OBJECT(p->topgwin), "configure-event",
(GCallback) panel_configure_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "button-press-event",
(GCallback) panel_button_press_event, p);
g_signal_connect(G_OBJECT(p->topgwin), "scroll-event",
(GCallback) panel_scroll_event, p);
gtk_window_set_resizable(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_wmclass(GTK_WINDOW(p->topgwin), "panel", "fbpanel");
gtk_window_set_title(GTK_WINDOW(p->topgwin), "panel");
gtk_window_set_position(GTK_WINDOW(p->topgwin), GTK_WIN_POS_NONE);
gtk_window_set_decorated(GTK_WINDOW(p->topgwin), FALSE);
gtk_window_set_accept_focus(GTK_WINDOW(p->topgwin), FALSE);
if (p->setdocktype)
gtk_window_set_type_hint(GTK_WINDOW(p->topgwin),
GDK_WINDOW_TYPE_HINT_DOCK);
if (p->layer == LAYER_ABOVE)
gtk_window_set_keep_above(GTK_WINDOW(p->topgwin), TRUE);
else if (p->layer == LAYER_BELOW)
gtk_window_set_keep_below(GTK_WINDOW(p->topgwin), TRUE);
gtk_window_stick(GTK_WINDOW(p->topgwin));
gtk_widget_realize(p->topgwin);
p->topxwin = GDK_WINDOW_XWINDOW(p->topgwin->window);
DBG("topxwin = %lx\n", p->topxwin);
/* ensure configure event */
XMoveWindow(GDK_DISPLAY(), p->topxwin, 20, 20);
XSync(GDK_DISPLAY(), False);
gtk_widget_set_app_paintable(p->topgwin, TRUE);
calculate_position(p);
gtk_window_move(GTK_WINDOW(p->topgwin), p->ax, p->ay);
gtk_window_resize(GTK_WINDOW(p->topgwin), p->aw, p->ah);
DBG("move-resize x %d y %d w %d h %d\n", p->ax, p->ay, p->aw, p->ah);
//XSync(GDK_DISPLAY(), False);
//gdk_flush();
// background box all over toplevel
p->bbox = gtk_bgbox_new();
gtk_container_add(GTK_CONTAINER(p->topgwin), p->bbox);
gtk_container_set_border_width(GTK_CONTAINER(p->bbox), 0);
if (p->transparent) {
p->bg = fb_bg_get_for_display();
gtk_bgbox_set_background(p->bbox, BG_ROOT, p->tintcolor, p->alpha);
}
// main layout manager as a single child of background widget box
p->lbox = p->my_box_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(p->lbox), 0);
gtk_container_add(GTK_CONTAINER(p->bbox), p->lbox);
p->box = p->my_box_new(FALSE, p->spacing);
gtk_container_set_border_width(GTK_CONTAINER(p->box), 0);
gtk_box_pack_start(GTK_BOX(p->lbox), p->box, TRUE, TRUE,
(p->round_corners) ? p->round_corners_radius : 0);
if (p->round_corners) {
make_round_corners(p);
DBG("make_round_corners\n");
}
/* start window creation process */
gtk_widget_show_all(p->topgwin);
/* .. and hide it from user until everything is done */
gtk_widget_hide(p->topgwin);
p->menu = panel_make_menu(p);
if (p->setstrut)
panel_set_wm_strut(p);
XSelectInput(GDK_DISPLAY(), GDK_ROOT_WINDOW(), PropertyChangeMask);
gdk_window_add_filter(gdk_get_default_root_window(),
(GdkFilterFunc)panel_event_filter, p);
//XSync(GDK_DISPLAY(), False);
gdk_flush();
RET();
}
