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);
}
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);
}
static gboolean
gtk_frame_map_callback( GtkWidget*,
GdkEvent * WXUNUSED(event),
wxTopLevelWindow *win )
{
const bool wasIconized = win->IsIconized();
if (wasIconized)
{
// Because GetClientSize() returns (0,0) when IsIconized() is true,
// a size event must be generated, just in case GetClientSize() was
// called while iconized. This specifically happens when restoring a
// tlw that was "rolled up" with some WMs.
// Queue a resize rather than sending size event directly to allow
// children to be made visible first.
win->m_useCachedClientSize = false;
win->m_clientWidth = 0;
gtk_widget_queue_resize(win->m_wxwindow);
}
// it is possible for m_isShown to be false here, see bug #9909
if (win->wxWindowBase::Show(true))
{
wxShowEvent eventShow(win->GetId(), true);
eventShow.SetEventObject(win);
win->GetEventHandler()->ProcessEvent(eventShow);
}
// restore focus-on-map setting in case ShowWithoutActivating() was called
gtk_window_set_focus_on_map(GTK_WINDOW(win->m_widget), true);
return false;
}
void deja_dup_show_background_window_for_shell (GtkWindow* win) {
GtkWindow* _tmp0_;
GtkWindow* _tmp1_;
GtkWindow* _tmp2_;
DejaDupShellEnv _tmp3_ = 0;
g_return_if_fail (win != NULL);
_tmp0_ = win;
gtk_window_set_focus_on_map (_tmp0_, FALSE);
_tmp1_ = win;
gtk_window_set_urgency_hint (_tmp1_, TRUE);
_tmp2_ = win;
g_signal_connect ((GtkWidget*) _tmp2_, "focus-in-event", (GCallback) _deja_dup_user_focused_gtk_widget_focus_in_event, NULL);
_tmp3_ = deja_dup_get_shell ();
if (_tmp3_ == DEJA_DUP_SHELL_ENV_UNITY) {
GtkWindow* _tmp4_;
GtkWindow* _tmp5_;
GtkWindow* _tmp6_;
_tmp4_ = win;
gtk_window_iconify (_tmp4_);
_tmp5_ = win;
gtk_widget_show ((GtkWidget*) _tmp5_);
_tmp6_ = win;
gtk_window_iconify (_tmp6_);
} else {
GtkWindow* _tmp7_;
_tmp7_ = win;
gtk_widget_show ((GtkWidget*) _tmp7_);
}
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1set_1focus_1on_1map
(
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_focus_on_map(self, setting);
// cleanup parameter self
// cleanup parameter setting
}
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;
}
void wxTopLevelWindowGTK::ShowWithoutActivating()
{
if (!m_isShown)
{
gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false);
Show(true);
}
}
void wxTopLevelWindowGTK::ShowWithoutActivating()
{
if (!m_isShown)
{
#if GTK_CHECK_VERSION(2,6,0)
if (!gtk_check_version(2,6,0))
gtk_window_set_focus_on_map(GTK_WINDOW(m_widget), false);
#endif // GTK+ 2.6+
Show(true);
}
}
static void
auth_dialog (DBusGProxy *adapter,
DBusGProxy *device,
const char *name,
const char *long_name,
const char *uuid,
DBusGMethodInvocation *context)
{
GtkBuilder *xml;
GtkWidget *dialog;
GtkWidget *button;
char *str;
input_data *input;
input = g_new0 (input_data, 1);
input->path = g_strdup (dbus_g_proxy_get_path (adapter));
input->uuid = g_strdup (uuid);
input->device = g_object_ref (device);
input->context = context;
xml = gtk_builder_new ();
if (gtk_builder_add_from_file (xml, "authorisation-dialogue.ui", NULL) == 0)
gtk_builder_add_from_file (xml, PKGDATADIR "/authorisation-dialogue.ui", NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
if (notification_supports_actions () != FALSE)
gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
else
gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
input->dialog = dialog;
/* translators: Whether to grant access to a particular service */
str = g_strdup_printf (_("Grant access to '%s'"), uuid);
g_object_set (G_OBJECT (dialog), "text", str, NULL);
g_free (str);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("Device %s wants access to the service '%s'."),
long_name, uuid);
button = GTK_WIDGET (gtk_builder_get_object (xml, "always_button"));
input->button = button;
input_list = g_list_append (input_list, input);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (auth_callback), input);
enable_blinking ();
}
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);
}
static void
gimp_dialog_factories_show_foreach (gconstpointer key,
GimpDialogFactory *factory,
gpointer data)
{
GList *list;
for (list = factory->open_dialogs; list; list = g_list_next (list))
{
if (GTK_IS_WIDGET (list->data) && GTK_WIDGET_TOPLEVEL (list->data))
{
GimpDialogVisibilityState visibility;
visibility =
GPOINTER_TO_INT (g_object_get_data (G_OBJECT (list->data),
GIMP_DIALOG_VISIBILITY_KEY));
if (! GTK_WIDGET_VISIBLE (list->data) &&
visibility == GIMP_DIALOG_VISIBILITY_VISIBLE)
{
GtkWindow *window = GTK_WINDOW (list->data);
gboolean focus_on_map = gtk_window_get_focus_on_map (window);
if (focus_on_map)
gtk_window_set_focus_on_map (window, FALSE);
gtk_widget_show (GTK_WIDGET (window));
if (GTK_WIDGET_VISIBLE (window))
gdk_window_raise (GTK_WIDGET (window)->window);
if (focus_on_map)
gtk_window_set_focus_on_map (window, TRUE);
}
}
}
}
static void
confirm_dialog (DBusGProxy *adapter,
DBusGProxy *device,
const char *name,
const char *long_name,
const char *value,
DBusGMethodInvocation *context)
{
GtkWidget *dialog;
GtkBuilder *xml;
char *str;
input_data *input;
input = g_new0 (input_data, 1);
input->path = g_strdup (dbus_g_proxy_get_path(adapter));
input->device = g_object_ref (device);
input->context = context;
xml = gtk_builder_new ();
if (gtk_builder_add_from_file (xml, "confirm-dialogue.ui", NULL) == 0)
gtk_builder_add_from_file (xml, PKGDATADIR "/confirm-dialogue.ui", NULL);
dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
if (notification_supports_actions () != FALSE)
gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
else
gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
input->dialog = dialog;
str = g_strdup_printf (_("Device '%s' wants to pair with this computer"),
name);
g_object_set (G_OBJECT (dialog), "text", str, NULL);
g_free (str);
str = g_strdup_printf ("<b>%s</b>", value);
gtk_message_dialog_format_secondary_markup (GTK_MESSAGE_DIALOG (dialog),
_("Please confirm whether the PIN '%s' matches the one on device %s."),
str, long_name);
g_free (str);
input_list = g_list_append (input_list, input);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (confirm_callback), input);
enable_blinking ();
}
static void *krad_gui_gtk_init(gpointer data) {
krad_gui_gtk_t *krad_gui_gtk = (krad_gui_gtk_t *)data;
gtk_init (NULL, NULL);
krad_gui_gtk->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (krad_gui_gtk->window), "Krad GUI");
g_signal_connect (krad_gui_gtk->window, "destroy", G_CALLBACK (close_window), krad_gui_gtk);
//gtk_container_set_border_width (GTK_CONTAINER (krad_gui_gtk->window), 8);
//krad_gui_gtk->frame = gtk_frame_new (NULL);
//gtk_frame_set_shadow_type (GTK_FRAME (krad_gui_gtk->frame), GTK_SHADOW_IN);
//gtk_container_add (GTK_CONTAINER (krad_gui_gtk->window), krad_gui_gtk->frame);
krad_gui_gtk->da = gtk_drawing_area_new ();
/* set a minimum size */
gtk_window_set_position (GTK_WINDOW(krad_gui_gtk->window), GTK_WIN_POS_CENTER);
//gtk_window_set_decorated (GTK_WINDOW(krad_gui_gtk->window), FALSE);
gtk_window_set_has_resize_grip (GTK_WINDOW(krad_gui_gtk->window), FALSE);
gtk_window_set_resizable (GTK_WINDOW(krad_gui_gtk->window), FALSE);
gtk_window_set_focus_on_map (GTK_WINDOW(krad_gui_gtk->window), TRUE);
gtk_widget_set_size_request (krad_gui_gtk->da, krad_gui_gtk->width, krad_gui_gtk->height);
gtk_container_add (GTK_CONTAINER (krad_gui_gtk->window), krad_gui_gtk->da);
/* Signals used to handle the backing surface */
g_signal_connect (krad_gui_gtk->da, "draw",
G_CALLBACK (draw_cb), krad_gui_gtk);
g_signal_connect (krad_gui_gtk->da,"configure-event",
G_CALLBACK (configure_event_cb), krad_gui_gtk);
gtk_widget_show_all (krad_gui_gtk->window);
gtk_window_present (GTK_WINDOW(krad_gui_gtk->window));
g_timeout_add (30, update_gui, krad_gui_gtk);
gtk_main ();
free(krad_gui_gtk->krad_gui->gui_ptr);
krad_gui_gtk->krad_gui->gui_ptr = NULL;
return 0;
}
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);
}
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;
}
AwnApplet *
awn_applet_factory_initp (const gchar *name, gchar* uid, gint panel_id)
{
g_on_error_stack_trace (NULL);
html_init ();
WebApplet *webapplet = g_malloc (sizeof (WebApplet));
webapplet->uid=g_strdup(uid);
webapplet->check_home = NULL;
webapplet->location_dialog = NULL;
webapplet->start = NULL;
webapplet->applet = AWN_APPLET (awn_applet_simple_new (name, uid, panel_id));
init_config (webapplet);
gint height = awn_applet_get_size(webapplet->applet);
awn_applet_simple_set_icon_name(AWN_APPLET_SIMPLE(webapplet->applet),
ICON_NAME);
/*gtk_widget_show_all (GTK_WIDGET (webapplet->applet));*/
awn_html_dialog_new (webapplet);
gtk_window_set_focus_on_map (GTK_WINDOW (webapplet->mainwindow), TRUE);
g_signal_connect_after (G_OBJECT (webapplet->applet), "realize",
G_CALLBACK (_bloody_thing_has_style), webapplet);
return webapplet->applet;
}
/* 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;
}
void gcb_main()
{
GtkWidget *hbox,*vbox;
int i;
#if 1
if (gcb_enabled==old_gcb_enabled && gcb_position==old_gcb_position && gcb_position_x==old_gcb_position_x
&& gcb_position_y==old_gcb_position_y)
return;
#endif
old_gcb_enabled = gcb_enabled;
old_gcb_position = gcb_position;
old_gcb_position_x = gcb_position_x;
old_gcb_position_y = gcb_position_y;
if (mainwin) {
gtk_widget_destroy(mainwin);
mainwin = NULL;
}
#if 0
if (button_bar_tips)
gtk_widget_destroy(button_bar_tips);
#endif
if (hist_window) {
gtk_widget_destroy(hist_window);
hist_window = NULL;
}
if (!gcb_enabled)
return;
// printf("gcb_position:%d\n", gcb_position);
static char geo[][2]={{0,0},{'+','-'},{'+','+'},{'-','-'},{'-','+'}};
g_free(geomstr);
geomstr = g_strdup_printf("%c%d%c%d",
geo[gcb_position][0], gcb_position_x, geo[gcb_position][1], gcb_position_y);
dbg("geomstr %s\n", geomstr);
if (!buttonArr) {
buttonArr=(GtkWidget**)g_malloc(gcb_button_n * sizeof(GtkWidget *));
buttonStr=(gchar**)g_malloc0(gcb_button_n * sizeof(gchar *));
}
if (!hist_strArr) {
hist_strArr=(gchar**)g_malloc0(gcb_history_n * sizeof(gchar *));
hist_buttonArr=(GtkWidget**)g_malloc(gcb_history_n * sizeof(GtkWidget *));
}
mainwin = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(mainwin), FALSE);
gtk_window_set_decorated(GTK_WINDOW(mainwin),FALSE);
gtk_window_set_focus_on_map (GTK_WINDOW(mainwin), FALSE);
hist_window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_has_resize_grip(GTK_WINDOW(hist_window), FALSE);
char icon_path[40];
sys_icon_fname("gcb.png", icon_path);
GtkWidget *win_icon=gtk_image_new_from_file(icon_path);
gtk_window_set_icon(GTK_WINDOW(mainwin),
gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
gtk_window_set_icon(GTK_WINDOW(hist_window),
gtk_image_get_pixbuf(GTK_IMAGE(win_icon)));
// Under gnome 2.0, the mainwin is not fixed if decorated, annoying
gtk_window_set_decorated(GTK_WINDOW(hist_window),FALSE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(hist_window),TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(hist_window),TRUE);
gtk_window_set_title (GTK_WINDOW (hist_window),"gcb history");
gtk_window_set_title (GTK_WINDOW(mainwin), "gcb: gtk copy-paste buffer");
gtk_window_stick(GTK_WINDOW(mainwin));
// g_signal_connect(G_OBJECT (mainwin),"destroy", G_CALLBACK (do_exit), NULL);
g_signal_connect(G_OBJECT (hist_window),"delete_event",
G_CALLBACK (delete_hist_win), NULL);
g_signal_connect(G_OBJECT (hist_window),"focus-out-event",
G_CALLBACK (hist_focus_out_callback), NULL);
#if !GTK_CHECK_VERSION(2,12,0)
button_bar_tips = gtk_tooltips_new ();
#endif
hbox = gtk_hbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER(mainwin), hbox);
gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
for(i=0;i<gcb_button_n;i++) {
buttonArr[i] = gtk_button_new_with_label ("---");
// gtk_container_set_border_width(GTK_CONTAINER(buttonArr[i]),0);
gtk_box_pack_start (GTK_BOX(hbox), buttonArr[i], TRUE, TRUE, FALSE);
gtk_widget_show (buttonArr[i]);
g_signal_connect (G_OBJECT (buttonArr[i]), "button-press-event",
G_CALLBACK (get_mouse_button), (gpointer) buttonArr[i]);
#if 0
g_signal_connect (G_OBJECT (buttonArr[i]), "key-press-event",
G_CALLBACK (key_press_event), NULL);
#endif
#if 1
g_signal_connect (G_OBJECT (buttonArr[i]), "scroll-event",
G_CALLBACK (gcb_button_scroll_event), NULL);
#endif
}
vbox = gtk_vbox_new (FALSE, 1);
gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER(hist_window), vbox);
for(i=0;i<gcb_history_n;i++) {
hist_buttonArr[i] = gtk_button_new_with_label ("---");
gtk_container_set_border_width(GTK_CONTAINER(hist_buttonArr[i]),0);
gtk_box_pack_start (GTK_BOX(vbox), hist_buttonArr[i], TRUE, TRUE, FALSE);
gtk_widget_show (hist_buttonArr[i]);
g_signal_connect (G_OBJECT (hist_buttonArr[i]), "button-press-event",
G_CALLBACK (hist_get_mouse_button), (gpointer) hist_buttonArr[i]);
#if 1
g_signal_connect (G_OBJECT (hist_buttonArr[i]), "key-press-event",
G_CALLBACK (hist_key_press_event), NULL);
#endif
}
#if 1
// need this because on win32 scoll is not recieved if win is not focused.
gtk_box_pack_start (GTK_BOX (hbox), gtk_vseparator_new(), FALSE, FALSE, 0);
GtkWidget *eve_arrow = gtk_event_box_new();
gtk_event_box_set_visible_window (GTK_EVENT_BOX(eve_arrow), FALSE);
gtk_box_pack_start (GTK_BOX(hbox), eve_arrow, FALSE, FALSE, FALSE);
g_signal_connect(G_OBJECT(eve_arrow),"button-press-event", G_CALLBACK(mouse_button_callback), NULL);
gtk_container_add(GTK_CONTAINER(eve_arrow), gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN));
#endif
gtk_widget_show_all(hbox);
gtk_widget_show (vbox);
gtk_widget_show (mainwin);
pclipboard_prim = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
pclipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
set_snoop_button(buttonArr[0]);
get_selection(pclipboard);
get_selection(pclipboard_prim);
gtk_container_set_border_width(GTK_CONTAINER(hbox),0);
gtk_container_set_border_width(GTK_CONTAINER(mainwin),0);
gtk_window_parse_geometry(GTK_WINDOW(mainwin),geomstr);
#if GTK_CHECK_VERSION(2,6,0)
g_signal_connect(pclipboard, "owner-change", G_CALLBACK (cb_owner_change), NULL);
g_signal_connect(pclipboard_prim, "owner-change", G_CALLBACK (cb_owner_change), NULL);
#endif
}
static void
pin_dialog (DBusGProxy *adapter,
DBusGProxy *device,
const char *name,
const char *long_name,
gboolean numeric,
DBusGMethodInvocation *context)
{
GtkWidget *dialog;
GtkWidget *button;
GtkWidget *entry;
GtkBuilder *xml;
char *str;
input_data *input;
xml = gtk_builder_new ();
if (gtk_builder_add_from_file (xml, "passkey-dialogue.ui", NULL) == 0)
gtk_builder_add_from_file (xml, PKGDATADIR "/passkey-dialogue.ui", NULL);
input = g_new0 (input_data, 1);
input->path = g_strdup (dbus_g_proxy_get_path(adapter));
input->numeric = numeric;
input->context = context;
input->device = g_object_ref (device);
dialog = GTK_WIDGET (gtk_builder_get_object (xml, "dialog"));
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
if (notification_supports_actions () != FALSE)
gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
else
gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
input->dialog = dialog;
gtk_dialog_set_default_response (GTK_DIALOG (dialog),
GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
FALSE);
str = g_strdup_printf (_("Device '%s' wants to pair with this computer"),
name);
g_object_set (G_OBJECT (dialog), "text", str, NULL);
g_free (str);
gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (dialog),
_("Please enter the PIN mentioned on device %s."),
long_name);
entry = GTK_WIDGET (gtk_builder_get_object (xml, "entry"));
if (numeric == TRUE) {
gtk_entry_set_max_length (GTK_ENTRY (entry), 6);
gtk_entry_set_width_chars (GTK_ENTRY (entry), 6);
g_signal_connect (G_OBJECT (entry), "insert-text",
G_CALLBACK (insert_callback), input);
} else {
gtk_entry_set_max_length (GTK_ENTRY (entry), 16);
gtk_entry_set_width_chars (GTK_ENTRY (entry), 16);
gtk_entry_set_visibility (GTK_ENTRY (entry), FALSE);
}
gtk_entry_set_activates_default (GTK_ENTRY (entry), TRUE);
input->entry = entry;
g_signal_connect (G_OBJECT (entry), "changed",
G_CALLBACK (changed_callback), input);
button = GTK_WIDGET (gtk_builder_get_object (xml, "showinput_button"));
if (numeric == FALSE) {
g_signal_connect (G_OBJECT (button), "toggled",
G_CALLBACK (toggled_callback), input);
} else {
gtk_widget_set_no_show_all (button, TRUE);
gtk_widget_hide (button);
}
input_list = g_list_append(input_list, input);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (pin_callback), input);
enable_blinking();
}
/*!
\brief load_status_pf() is called to create the ECU status window, load the
settings from the StatusMapFile.
*/
G_MODULE_EXPORT void load_status_pf(void)
{
gchar *filename = NULL;
gint x = 0;
gint y = 0;
gint w = 0;
gint h = 0;
GtkWidget * window;
GtkWidget * parent;
GladeXML *xml = NULL;
gboolean xml_result = FALSE;
xmlDoc *doc = NULL;
xmlNode *root_element = NULL;
GladeXML *main_xml;
Firmware_Details *firmware = NULL;
CmdLineArgs *args = NULL;
args = DATA_GET(global_data,"args");
firmware = DATA_GET(global_data,"firmware");
g_return_if_fail(firmware);
g_return_if_fail(args);
if (!(DATA_GET(global_data,"interrogated")))
return;
if (!firmware->status_map_file)
{
//dbg_func(CRITICAL,g_strdup_printf(__FILE__": firmware->status_map_file is UNDEFINED,\n\texiting status window creation routine!!!!\n"));
return;
}
gdk_threads_enter();
set_title(g_strdup(_("Loading RT Status...")));
filename = get_file(g_build_path(PSEP,RTSTATUS_DATA_DIR,firmware->status_map_file,NULL),g_strdup("xml"));
if (!filename)
{
dbg_func(CRITICAL,g_strdup_printf(__FILE__": load_runtime_status()\n\t File \"%s.xml\" not found!!, exiting function\n",firmware->status_map_file));
set_title(g_strdup(_("ERROR RT Statusfile DOES NOT EXIST!!!")));
gdk_threads_leave();
return;
}
main_xml = (GladeXML *)DATA_GET(global_data,"main_xml");
xml = glade_xml_new(main_xml->filename,"status_window",NULL);
window = glade_xml_get_widget(xml,"status_window");
register_widget("status_window",window);
gtk_window_set_focus_on_map((GtkWindow *)window,FALSE);
gtk_window_set_title(GTK_WINDOW(window),_("ECU Status"));
x = (GINT)DATA_GET(global_data,"status_x_origin");
y = (GINT)DATA_GET(global_data,"status_y_origin");
gtk_window_move(GTK_WINDOW(window),x,y);
w = (GINT)DATA_GET(global_data,"status_width");
h = (GINT)DATA_GET(global_data,"status_height");
gtk_window_set_default_size(GTK_WINDOW(window),w,h);
/*
if (g_strcasecmp(firmware->actual_signature,DATA_GET(global_data,"last_signature")) == 0)
gtk_window_set_default_size(GTK_WINDOW(window),w,h);
else
gtk_window_set_default_size(GTK_WINDOW(window),-1,-1);
*/
// gtk_window_resize(GTK_WINDOW(window),w,h);
// g_object_set(window, "resizable", FALSE, NULL);
parent = glade_xml_get_widget(xml,"status_vbox");
glade_xml_signal_autoconnect(xml);
LIBXML_TEST_VERSION
doc = xmlReadFile(filename, NULL, 0);
g_free(filename);
if (doc == NULL)
{
printf(_("error: could not parse file %s\n"),filename);
gdk_threads_leave();
return;
}
root_element = xmlDocGetRootElement(doc);
xml_result = load_status_xml_elements(root_element,parent);
xmlFreeDoc(doc);
xmlCleanupParser();
if (xml_result == FALSE)
gtk_widget_destroy(window);
else if ((!args->hide_status) && (xml_result))
gtk_widget_show_all(window);
set_title(g_strdup(_("RT Status Loaded...")));
gdk_threads_leave();
return;
}
/* desktopicon_new_do */
static DesktopIcon * _desktopicon_new_do(Desktop * desktop, GdkPixbuf * image,
char const * name)
{
DesktopIcon * desktopicon;
GtkWindow * window;
GtkWidget * vbox;
GdkGeometry geometry;
if((desktopicon = malloc(sizeof(*desktopicon))) == NULL)
return NULL;
memset(desktopicon, 0, sizeof(*desktopicon));
desktopicon->desktop = desktop;
desktopicon->confirm = TRUE;
desktopicon->updated = TRUE;
/* window */
desktopicon->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
window = GTK_WINDOW(desktopicon->window);
gtk_window_set_decorated(window, FALSE);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_focus_on_map(window, FALSE);
#endif
gtk_window_set_keep_below(window, TRUE);
gtk_window_set_resizable(window, FALSE);
gtk_window_set_skip_pager_hint(window, TRUE);
#ifdef EMBEDDED
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_UTILITY);
#else
gtk_window_set_type_hint(window, GDK_WINDOW_TYPE_HINT_DOCK);
#endif
g_signal_connect(G_OBJECT(desktopicon->window), "delete-event",
G_CALLBACK(_on_desktopicon_closex), NULL);
/* event */
desktopicon->event = gtk_event_box_new();
g_signal_connect(G_OBJECT(desktopicon->event), "button-press-event",
G_CALLBACK(_on_icon_button_press), desktopicon);
g_signal_connect(G_OBJECT(desktopicon->event), "key-press-event",
G_CALLBACK(_on_icon_key_press), desktopicon);
vbox = gtk_vbox_new(FALSE, 4);
geometry.min_width = DESKTOPICON_MIN_WIDTH;
geometry.min_height = DESKTOPICON_MIN_HEIGHT;
geometry.max_width = DESKTOPICON_MAX_WIDTH;
geometry.max_height = DESKTOPICON_MAX_HEIGHT;
geometry.base_width = DESKTOPICON_MIN_WIDTH;
geometry.base_height = DESKTOPICON_MIN_HEIGHT;
gtk_window_set_geometry_hints(window, vbox, &geometry, /* XXX check */
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE
| GDK_HINT_BASE_SIZE);
/* image */
desktopicon->image = gtk_image_new();
gtk_widget_set_size_request(desktopicon->image, DESKTOPICON_ICON_SIZE,
DESKTOPICON_ICON_SIZE);
gtk_box_pack_start(GTK_BOX(vbox), desktopicon->image, FALSE, TRUE, 0);
/* label */
desktopicon->label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(desktopicon->label), 0.5, 0.0);
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_label_set_line_wrap_mode(GTK_LABEL(desktopicon->label),
PANGO_WRAP_WORD_CHAR);
#endif
gtk_label_set_line_wrap(GTK_LABEL(desktopicon->label), TRUE);
gtk_box_pack_start(GTK_BOX(vbox), desktopicon->label, TRUE, TRUE, 4);
gtk_container_add(GTK_CONTAINER(desktopicon->event), vbox);
gtk_container_add(GTK_CONTAINER(desktopicon->window),
desktopicon->event);
if(image == NULL)
image = desktop_get_file(desktop);
_desktopicon_set_icon(desktopicon, image);
_desktopicon_set_name(desktopicon, name);
_desktopicon_update_transparency(desktopicon);
return desktopicon;
}
static void
gimp_color_picker_tool_info_create (GimpColorPickerTool *picker_tool)
{
GimpTool *tool = GIMP_TOOL (picker_tool);
GtkWidget *content_area;
GtkWidget *hbox;
GtkWidget *frame;
GimpRGB color;
g_return_if_fail (tool->drawable != NULL);
picker_tool->dialog = gimp_tool_dialog_new (tool->tool_info,
gimp_display_get_shell (tool->display),
_("Color Picker Information"),
GTK_STOCK_CLOSE,
GTK_RESPONSE_CLOSE,
NULL);
gtk_window_set_focus_on_map (GTK_WINDOW (picker_tool->dialog), FALSE);
gimp_viewable_dialog_set_viewable (GIMP_VIEWABLE_DIALOG (picker_tool->dialog),
GIMP_VIEWABLE (tool->drawable),
GIMP_CONTEXT (gimp_tool_get_options (tool)));
g_signal_connect (picker_tool->dialog, "response",
G_CALLBACK (gimp_color_picker_tool_info_response),
picker_tool);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (picker_tool->dialog));
hbox = gtk_hbox_new (FALSE, 6);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 6);
gtk_box_pack_start (GTK_BOX (content_area), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
picker_tool->color_frame1 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame1),
GIMP_COLOR_FRAME_MODE_PIXEL);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame1,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame1);
picker_tool->color_frame2 = gimp_color_frame_new ();
gimp_color_frame_set_mode (GIMP_COLOR_FRAME (picker_tool->color_frame2),
GIMP_COLOR_FRAME_MODE_RGB);
gtk_box_pack_start (GTK_BOX (hbox), picker_tool->color_frame2,
FALSE, FALSE, 0);
gtk_widget_show (picker_tool->color_frame2);
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, TRUE, TRUE, 0);
gtk_widget_show (frame);
gimp_rgba_set (&color, 0.0, 0.0, 0.0, 0.0);
picker_tool->color_area =
gimp_color_area_new (&color,
gimp_drawable_has_alpha (tool->drawable) ?
GIMP_COLOR_AREA_LARGE_CHECKS :
GIMP_COLOR_AREA_FLAT,
GDK_BUTTON1_MASK | GDK_BUTTON2_MASK);
gtk_widget_set_size_request (picker_tool->color_area, 48, -1);
gtk_drag_dest_unset (picker_tool->color_area);
gtk_container_add (GTK_CONTAINER (frame), picker_tool->color_area);
gtk_widget_show (picker_tool->color_area);
}
static void
gsd_ldsm_dialog_init (GsdLdsmDialog *dialog)
{
GtkWidget *main_vbox, *text_vbox, *hbox;
GtkWidget *image;
dialog->priv = GSD_LDSM_DIALOG_GET_PRIVATE (dialog);
main_vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
/* Set up all the window stuff here */
gtk_window_set_title (GTK_WINDOW (dialog), _("Low Disk Space"));
gtk_window_set_icon_name (GTK_WINDOW (dialog),
GTK_STOCK_DIALOG_WARNING);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_window_set_urgency_hint (GTK_WINDOW (dialog), TRUE);
gtk_window_set_focus_on_map (GTK_WINDOW (dialog), FALSE);
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
/* Create the image */
image = gtk_image_new_from_stock (GTK_STOCK_DIALOG_WARNING, GTK_ICON_SIZE_DIALOG);
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
/* Create the labels */
dialog->priv->primary_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->primary_label), TRUE);
gtk_label_set_single_line_mode (GTK_LABEL (dialog->priv->primary_label), FALSE);
gtk_misc_set_alignment (GTK_MISC (dialog->priv->primary_label), 0.0, 0.0);
dialog->priv->secondary_label = gtk_label_new (NULL);
gtk_label_set_line_wrap (GTK_LABEL (dialog->priv->secondary_label), TRUE);
gtk_label_set_single_line_mode (GTK_LABEL (dialog->priv->secondary_label), FALSE);
gtk_misc_set_alignment (GTK_MISC (dialog->priv->secondary_label), 0.0, 0.0);
/* Create the check button to ignore future warnings */
dialog->priv->ignore_check_button = gtk_check_button_new ();
/* The button should be inactive if the dialog was just called.
* I suppose it could be possible for the user to manually edit the GSettings key between
* the mount being checked and the dialog appearing, but I don't think it matters
* too much */
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (dialog->priv->ignore_check_button), FALSE);
g_signal_connect (dialog->priv->ignore_check_button, "toggled",
G_CALLBACK (ignore_check_button_toggled_cb), dialog);
/* Now set up the dialog's GtkBox's' */
gtk_box_set_spacing (GTK_BOX (main_vbox), 14);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
text_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
gtk_box_pack_start (GTK_BOX (text_vbox), dialog->priv->primary_label, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (text_vbox), dialog->priv->secondary_label, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (text_vbox), dialog->priv->ignore_check_button, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), image, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), text_vbox, TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (main_vbox), hbox, FALSE, FALSE, 0);
/* Set up the action area */
gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), 6);
gtk_container_set_border_width (GTK_CONTAINER (gtk_dialog_get_action_area (GTK_DIALOG (dialog))), 5);
gtk_widget_show_all (hbox);
}
int
wCreateSplash( char *appName, char *appVer )
{
GtkWidget *vbox;
GtkWidget *image;
GtkWidget *label;
char *temp;
char logoPath[BUFSIZ];
/* create the basic window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated( GTK_WINDOW (window), FALSE );
gtk_window_set_title (GTK_WINDOW (window), appName);
gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
gtk_window_set_resizable (GTK_WINDOW (window), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
#if GTK_MINOR_VERSION > 5
gtk_window_set_focus_on_map (GTK_WINDOW (window), FALSE);
#endif
vbox = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox);
gtk_container_add (GTK_CONTAINER (window), vbox);
/* add the logo image to the top of the splash window */
sprintf( logoPath, "%s/" LOGOFILENAME, wGetAppLibDir());
image = gtk_image_new_from_file ( logoPath );
gtk_widget_show (image);
gtk_box_pack_start (GTK_BOX (vbox), image, TRUE, TRUE, 0);
gtk_misc_set_alignment (GTK_MISC (image), 0, 0);
/* put the product name into the window */
temp = malloc( strlen( appName ) + strlen( appVer ) + 2 );
if( !temp )
return( FALSE );
sprintf( temp, "%s %s", appName, appVer );
label = gtk_label_new ( temp );
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_FILL);
gtk_label_set_selectable (GTK_LABEL (label), FALSE);
gtk_misc_set_padding (GTK_MISC (label), 6, 2);
free( temp );
label = gtk_label_new ("Application is starting...");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
gtk_label_set_line_wrap (GTK_LABEL (label), FALSE);
gtk_misc_set_padding (GTK_MISC (label), 6, 2);
#if GTK_MINOR_VERSION > 5
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_START);
#endif
message = label;
gtk_widget_show( window );
return( TRUE );
}
