int
main(int argc, char **argv)
{
GError *error = NULL;
GdkMonitor *monitor;
GdkRectangle monitor_bounds;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
g_option_context_add_group (context,
gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
g_print ("# Load factor: %g\n",
load_factor);
g_print ("# Resizing?: %s\n",
cb_no_resize ? "no" : "yes");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_gravity (GTK_WINDOW (window), GDK_GRAVITY_CENTER);
gtk_widget_set_app_paintable (window, TRUE);
g_signal_connect (window, "draw",
G_CALLBACK (on_window_draw), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, "map-event",
G_CALLBACK (on_map_event), NULL);
on_frame (0.);
monitor = gdk_display_get_primary_monitor (gtk_widget_get_display (window));
gdk_monitor_get_geometry (monitor, &monitor_bounds);
gtk_window_move (GTK_WINDOW (window),
monitor_bounds.x + (monitor_bounds.width - window_width) / 2,
monitor_bounds.y + (monitor_bounds.height - window_height) / 2);
gtk_widget_show (window);
gtk_main ();
return 0;
}
static void
update_from_state (XplayerOntopPluginPrivate *priv)
{
GValue has_video = { 0, };
bacon_video_widget_get_metadata (priv->bvw, BVW_INFO_HAS_VIDEO, &has_video);
gtk_window_set_keep_above (priv->window,
(xplayer_is_playing (priv->xplayer) != FALSE &&
g_value_get_boolean (&has_video) != FALSE));
g_value_unset (&has_video);
}
/**
* fm_show_error
* @parent: a window to place dialog over it
* @title: title for dialog window
* @msg: message to present
*
* Presents error message to user and gives user no choices but close.
*
* Before 0.1.16 this call had different arguments.
*
* Since: 0.1.0
*/
void fm_show_error(GtkWindow* parent, const char* title, const char* msg)
{
GtkWidget* dlg = gtk_message_dialog_new(parent, 0,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK, "%s", msg);
/* g_message("(!) %s", msg); */
gtk_window_set_title(GTK_WINDOW(dlg), title ? title : _("Error"));
/* #3606577: error window if parent is desktop is below other windows */
gtk_window_set_keep_above(GTK_WINDOW(dlg), TRUE);
gtk_dialog_run(GTK_DIALOG(dlg));
gtk_widget_destroy(dlg);
}
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 ();
}
CDListing *cd_do_create_listing (void)
{
CDListing *pListing = g_new0 (CDListing, 1);
pListing->container.iType = CAIRO_DOCK_NB_CONTAINER_TYPES+1;
pListing->container.bIsHorizontal = TRUE;
pListing->container.bDirectionUp = TRUE;
pListing->container.fRatio = 1.;
GtkWidget *pWindow = cairo_dock_create_container_window_no_opengl ();
gtk_window_set_title (GTK_WINDOW (pWindow), "cairo-dock-listing");
//gtk_widget_add_events (pWindow, GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
g_signal_connect (G_OBJECT (pWindow),
"expose-event",
G_CALLBACK (on_expose_listing),
pListing);
g_signal_connect (G_OBJECT (pWindow),
"configure-event",
G_CALLBACK (on_configure_listing),
pListing);
g_signal_connect (G_OBJECT (pWindow),
"key-press-event",
G_CALLBACK (on_key_press_listing),
pListing);
/*g_signal_connect (G_OBJECT (pWindow),
"motion-notify-event",
G_CALLBACK (on_motion_notify_listing),
pListing);
g_signal_connect (G_OBJECT (pWindow),
"button-press-event",
G_CALLBACK (on_button_press_listing),
pListing);
g_signal_connect (G_OBJECT (pWindow),
"scroll-event",
G_CALLBACK (on_scroll_listing),
pListing);*/
pListing->container.pWidget = pWindow;
gtk_widget_show_all (pWindow);
gtk_window_stick (GTK_WINDOW (pWindow));
gtk_window_set_keep_above (GTK_WINDOW (pWindow), TRUE);
pListing->container.iWidth = _listing_compute_width (pListing);
pListing->container.iHeight = _listing_compute_height (pListing);
gtk_window_resize (GTK_WINDOW (pWindow),
pListing->container.iWidth,
pListing->container.iHeight);
_place_listing (pListing);
return pListing;
}
static void
empathy_tls_dialog_constructed (GObject *object)
{
GtkWidget *content_area, *expander, *details, *checkbox;
gchar *text;
EmpathyTLSDialog *self = EMPATHY_TLS_DIALOG (object);
GtkMessageDialog *message_dialog = GTK_MESSAGE_DIALOG (self);
GtkDialog *dialog = GTK_DIALOG (self);
EmpathyTLSDialogPriv *priv = GET_PRIV (self);
gtk_dialog_add_buttons (dialog,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
_("C_ontinue"), GTK_RESPONSE_YES,
NULL);
text = reason_to_string (self);
g_object_set (message_dialog,
"title", _("Untrusted connection"),
"text", _("This connection is untrusted. Would you like to "
"continue anyway?"),
"secondary-text", text,
NULL);
g_free (text);
content_area = gtk_dialog_get_content_area (dialog);
checkbox = gtk_check_button_new_with_label (
_("Remember this choice for future connections"));
gtk_box_pack_end (GTK_BOX (content_area), checkbox, FALSE, FALSE, 0);
gtk_widget_show (checkbox);
g_signal_connect (checkbox, "toggled", G_CALLBACK (checkbox_toggled_cb),
self);
text = g_strdup_printf ("<b>%s</b>", _("Certificate Details"));
expander = gtk_expander_new (text);
gtk_expander_set_use_markup (GTK_EXPANDER (expander), TRUE);
gtk_box_pack_end (GTK_BOX (content_area), expander, TRUE, TRUE, 0);
gtk_widget_show (expander);
g_free (text);
details = build_gcr_widget (self);
gtk_container_add (GTK_CONTAINER (expander), details);
gtk_widget_show (details);
gtk_window_set_keep_above (GTK_WINDOW (self), TRUE);
tp_g_signal_connect_object (priv->certificate, "invalidated",
G_CALLBACK (certificate_invalidated_cb), self, 0);
}
void MusikFrame::SetStayOnTop( bool bStayOnTop )
{
#if defined (__WXGTK__)
gtk_window_set_keep_above(GTK_WINDOW(GetHandle()),bStayOnTop ? TRUE:FALSE);
#else
long style = GetWindowStyle();
if ( bStayOnTop )
style |= wxSTAY_ON_TOP;
else
style &= ~wxSTAY_ON_TOP;
SetWindowStyle( style );
#endif
}
static void _panel_helper_shutdown_dialog(Panel * panel)
{
#ifdef EMBEDDED
const char message[] = N_("This will shutdown your device,"
" therefore closing any application currently opened"
" and losing any unsaved data.\n"
"Do you really want to proceed?");
#else
const char message[] = N_("This will shutdown your computer,"
" therefore closing any application currently opened"
" and losing any unsaved data.\n"
"Do you really want to proceed?");
#endif
GtkWidget * widget;
if(panel->sh_window != NULL)
{
gtk_window_present(GTK_WINDOW(panel->sh_window));
return;
}
panel->sh_window = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE, "%s",
#if GTK_CHECK_VERSION(2, 6, 0)
_("Shutdown"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(
panel->sh_window),
#endif
"%s", _(message));
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(panel->sh_window),
gtk_image_new_from_icon_name("gnome-shutdown",
GTK_ICON_SIZE_DIALOG));
#endif
gtk_dialog_add_buttons(GTK_DIALOG(panel->sh_window), GTK_STOCK_CANCEL,
RES_CANCEL, _("Restart"), RES_REBOOT, NULL);
widget = gtk_button_new_with_label(_("Shutdown"));
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(
"gnome-shutdown", GTK_ICON_SIZE_BUTTON));
gtk_widget_show_all(widget);
gtk_dialog_add_action_widget(GTK_DIALOG(panel->sh_window), widget,
RES_SHUTDOWN);
gtk_window_set_keep_above(GTK_WINDOW(panel->sh_window), TRUE);
gtk_window_set_position(GTK_WINDOW(panel->sh_window),
GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(panel->sh_window), _("Shutdown"));
g_signal_connect(panel->sh_window, "delete-event", G_CALLBACK(
_shutdown_dialog_on_closex), panel);
g_signal_connect(panel->sh_window, "response", G_CALLBACK(
_shutdown_dialog_on_response), panel);
gtk_widget_show_all(panel->sh_window);
}
int
main(int argc, char **argv)
{
GError *error = NULL;
GdkScreen *screen;
GdkRectangle monitor_bounds;
if (!gtk_init_with_args (&argc, &argv, "",
options, NULL, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
g_print ("%sLoad factor: %g\n",
machine_readable ? "# " : "",
load_factor);
g_print ("%sResizing?: %s\n",
machine_readable ? "# " : "",
cb_no_resize ? "no" : "yes");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_keep_above (GTK_WINDOW (window), TRUE);
gtk_window_set_gravity (GTK_WINDOW (window), GDK_GRAVITY_CENTER);
gtk_widget_set_app_paintable (window, TRUE);
g_signal_connect (window, "draw",
G_CALLBACK (on_window_draw), NULL);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
g_signal_connect (window, "map-event",
G_CALLBACK (on_map_event), NULL);
on_frame (0.);
screen = gtk_widget_get_screen (window);
gdk_screen_get_monitor_geometry (screen,
gdk_screen_get_primary_monitor (screen),
&monitor_bounds);
gtk_window_move (GTK_WINDOW (window),
monitor_bounds.x + (monitor_bounds.width - window_width) / 2,
monitor_bounds.y + (monitor_bounds.height - window_height) / 2);
gtk_widget_show (window);
gtk_main ();
return 0;
}
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 createProfileWindow(gchar *user,gchar *group,gchar *ip,gchar *absence)
{
GtkWidget *usr_info;
GtkWidget *table;
GtkWidget *label;
GtkWidget *pic;
GtkWidget *usr;
usr_info = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (GTK_WIDGET (usr_info), 300, 300);
gtk_window_set_keep_above(GTK_WINDOW (usr_info),TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW (usr_info),TRUE);
gtk_window_set_resizable(GTK_WINDOW (usr_info),FALSE);
gtk_window_set_title (GTK_WINDOW (usr_info), "查看资料");
pic = gtk_image_new_from_file ("Icon/1.gif");
table = gtk_table_new(8,7,TRUE);
gtk_container_add (GTK_CONTAINER (usr_info), table);
label = gtk_label_new("用户名:");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0,2,0,1);
label = gtk_label_new("群组:");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0,2,1,2);
label = gtk_label_new("IP:");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0,2,2,3);
label = gtk_label_new("个性签名:");
gtk_table_attach_defaults(GTK_TABLE (table), label, 0,2,3,4);
gtk_table_attach_defaults(GTK_TABLE (table), pic, 5,7,0,2);
label = gtk_label_new(user);
gtk_table_attach_defaults(GTK_TABLE (table), label, 2,5,0,1);
label = gtk_label_new(group);
gtk_table_attach_defaults(GTK_TABLE (table), label, 2,5,1,2);
label = gtk_label_new(ip);
gtk_table_attach_defaults(GTK_TABLE (table), label, 2,5,2,3);
label = gtk_label_new(absence);
gtk_table_attach_defaults(GTK_TABLE (table), label, 2,5,3,4);
gtk_widget_show_all(usr_info);
}
static gboolean _cairo_dock_set_one_desklet_visibility_to_default (CairoDesklet *pDesklet, CairoDockModule *pModule, CairoDockMinimalAppletConfig *pMinimalConfig)
{
GKeyFile *pKeyFile = cairo_dock_pre_read_module_config (pModule, pMinimalConfig);
g_key_file_free (pKeyFile);
gtk_window_set_keep_below (GTK_WINDOW (pDesklet->pWidget), pMinimalConfig->bKeepBelow);
gtk_window_set_keep_above (GTK_WINDOW (pDesklet->pWidget), pMinimalConfig->bKeepAbove);
Window Xid = GDK_WINDOW_XID (pDesklet->pWidget->window);
if (pMinimalConfig->bOnWidgetLayer)
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_UTILITY");
else
cairo_dock_set_xwindow_type_hint (Xid, "_NET_WM_WINDOW_TYPE_NORMAL");
return 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);
}
/**
* fm_yes_no
* @parent: a window to place dialog over it
* @title: title for dialog window
* @question: the question to present to the user
* @default_yes: the default answer
*
* Presents the question to user and gives user choices 'Yes' and 'No'.
*
* Before 0.1.16 this call had different arguments.
*
* Returns: %TRUE if user chose 'Yes'.
*
* Since: 0.1.0
*/
gboolean fm_yes_no(GtkWindow* parent, const char* title, const char* question, gboolean default_yes)
{
int ret;
GtkDialog* dlg = GTK_DIALOG(gtk_message_dialog_new_with_markup(parent, 0,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
"%s", question));
gtk_window_set_title(GTK_WINDOW(dlg), title ? title : _("Confirm"));
gtk_dialog_set_default_response(dlg, default_yes ? GTK_RESPONSE_YES : GTK_RESPONSE_NO);
/* #3300797: Delete prompt isn't on the first layer */
gtk_window_set_keep_above(GTK_WINDOW(dlg), TRUE);
ret = gtk_dialog_run(dlg);
gtk_widget_destroy((GtkWidget*)dlg);
return ret == GTK_RESPONSE_YES;
}
static void
impl_deactivate (PeasActivatable *plugin)
{
XplayerOntopPlugin *pi = XPLAYER_ONTOP_PLUGIN (plugin);
g_signal_handler_disconnect (G_OBJECT (pi->priv->xplayer), pi->priv->handler_id);
g_signal_handler_disconnect (G_OBJECT (pi->priv->bvw), pi->priv->handler_id_metadata);
g_object_unref (pi->priv->bvw);
/* We can't really "restore" the previous state, as there's
* no way to find the old state */
gtk_window_set_keep_above (pi->priv->window, FALSE);
g_object_unref (pi->priv->window);
}
/**
* builder: ignored
* dialog: The dialog to set the title for
*
* Sets a new title to the dialog. The title is extracted from the input_data
*
**/
static void
prepare_titlebar (GtkBuilder *builder, GtkDialog *dialog)
{
gchar *title;
title = g_key_file_get_string (input_data, "prompt", "title", NULL);
if (title)
gtk_window_set_title (GTK_WINDOW (dialog), title);
gtk_window_set_icon_name(GTK_WINDOW(dialog), "stock_lock");
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_window_set_keep_above (GTK_WINDOW (dialog), TRUE);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
gtk_window_set_type_hint (GTK_WINDOW (dialog), GDK_WINDOW_TYPE_HINT_NORMAL);
}
static GtkWidget *ccma_confirm_dialog_new(CCManagerApplet * applet)
{
g_message(" ccma_confirm_dialog_new()..");
GtkWidget *dialog, *label, *entry, *box, *bt_ok, *bt_cancel;
if (CC_MANAGERAPPLET(applet)->is_confirm_showed == TRUE)
return NULL;
CC_MANAGERAPPLET(applet)->confirm_dialog = gtk_dialog_new();
dialog = CC_MANAGERAPPLET(applet)->confirm_dialog;
CC_MANAGERAPPLET(applet)->is_confirm_showed = TRUE;
gtk_window_set_title(GTK_WINDOW(dialog), "管理认证");
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
bt_ok =
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_OK,
GTK_RESPONSE_OK);
bt_cancel =
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL);
label = gtk_label_new("口令 :");
entry = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(entry), 20);
gtk_entry_set_visibility(GTK_ENTRY(entry), FALSE);
box=gtk_box_new(GTK_ORIENTATION_HORIZONTAL,5);
gtk_box_pack_start(GTK_BOX(box),label, FALSE, FALSE, 5);
gtk_box_pack_end(GTK_BOX(box),entry, TRUE, TRUE, 10);
gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(dialog))),box);
// gtk_window_set_has_resize_grip(GTK_WINDOW(dialog),TRUE);
gtk_window_set_resizable(GTK_WINDOW(dialog), FALSE);
gtk_widget_grab_focus(entry);
g_signal_connect(dialog, "delete-event",
G_CALLBACK(ccma_confirm_dialog_leave_cb), applet);
g_signal_connect(entry, "activate",
G_CALLBACK(ccma_dialog_entry_enter_cb), applet);
g_signal_connect(dialog, "response",
G_CALLBACK(ccma_dialog_response_cb), applet);
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ALWAYS);
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
g_message("ccma_confirm_dialog_new()..");
gtk_widget_show_all(dialog);
return dialog;
}
GtkWidget* create_dropzone ()
{
dropzone = gtk_window_new (GTK_WINDOW_TOPLEVEL);
drawzone = gtk_label_new ("drag");
gtk_window_set_decorated (GTK_WINDOW (dropzone), FALSE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dropzone), TRUE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dropzone), TRUE);
gtk_window_set_keep_above (GTK_WINDOW (dropzone), TRUE);
gtk_container_add (GTK_CONTAINER (dropzone), drawzone);
gtk_widget_show (drawzone);
gtk_drag_dest_set (dropzone,
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT,
targets, n_targets,
GDK_ACTION_COPY);
gtk_widget_add_events (dropzone,
GDK_BUTTON_MOTION_MASK |
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK);
gtk_window_set_geometry_hints (GTK_WINDOW (dropzone),
dropzone, NULL,
GDK_HINT_POS | GDK_HINT_USER_POS);
g_signal_connect (dropzone, "button-press-event",
G_CALLBACK(on_button_press), NULL);
g_signal_connect (dropzone, "motion-notify-event",
G_CALLBACK(on_motion_notify), NULL);
g_signal_connect (dropzone, "button-release-event",
G_CALLBACK(on_button_release), NULL);
g_signal_connect (dropzone, "drag-drop",
G_CALLBACK(on_drag_drop), NULL);
g_signal_connect (dropzone, "drag-data-received",
G_CALLBACK(on_drag_data_received), NULL);
gtk_window_resize (GTK_WINDOW(dropzone),
rookie_settings_get_dropzone_width (),
rookie_settings_get_dropzone_height());
gtk_window_move (GTK_WINDOW(dropzone),
rookie_settings_get_dropzone_xpos (),
rookie_settings_get_dropzone_ypos());
return dropzone;
}
static void
impl_deactivate (IdolPlugin *plugin,
IdolObject *idol)
{
IdolOntopPlugin *pi = IDOL_ONTOP_PLUGIN (plugin);
g_signal_handler_disconnect (G_OBJECT (idol), pi->priv->handler_id);
g_signal_handler_disconnect (G_OBJECT (pi->priv->bvw), pi->priv->handler_id_metadata);
g_object_unref (pi->priv->bvw);
/* We can't really "restore" the previous state, as there's
* no way to find the old state */
gtk_window_set_keep_above (pi->priv->window, FALSE);
g_object_unref (pi->priv->window);
}
static void _panel_helper_lock_dialog(Panel * panel)
{
#ifdef EMBEDDED
const char message[] = N_("This will lock your device.\n"
"Do you really want to proceed?");
#else
const char message[] = N_("This will lock your session.\n"
"Do you really want to proceed?");
#endif
GtkWidget * widget;
if(panel->lk_window != NULL)
{
gtk_window_present(GTK_WINDOW(panel->lk_window));
return;
}
panel->lk_window = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE, "%s",
#if GTK_CHECK_VERSION(2, 6, 0)
_("Shutdown"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(
panel->lk_window),
#endif
"%s", _(message));
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(panel->lk_window),
gtk_image_new_from_icon_name("gnome-lockscreen",
GTK_ICON_SIZE_DIALOG));
#endif
gtk_dialog_add_buttons(GTK_DIALOG(panel->lk_window), GTK_STOCK_CANCEL,
FALSE, NULL);
widget = gtk_button_new_with_label(_("Lock"));
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(
"gnome-lockscreen", GTK_ICON_SIZE_BUTTON));
gtk_widget_show_all(widget);
gtk_dialog_add_action_widget(GTK_DIALOG(panel->lk_window), widget,
TRUE);
gtk_window_set_keep_above(GTK_WINDOW(panel->lk_window), TRUE);
gtk_window_set_position(GTK_WINDOW(panel->lk_window),
GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(panel->lk_window), _("Lock"));
g_signal_connect(panel->lk_window, "delete-event", G_CALLBACK(
_lock_dialog_on_closex), panel);
g_signal_connect(panel->lk_window, "response", G_CALLBACK(
_lock_dialog_on_response), panel);
gtk_widget_show_all(panel->lk_window);
}
static void
gm_window_set_property (GObject *obj,
guint prop_id,
const GValue *value,
GParamSpec *spec)
{
GmWindow *self = NULL;
const gchar *str = NULL;
self = GM_WINDOW (obj);
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, GM_TYPE_WINDOW, GmWindowPrivate);
switch (prop_id) {
case GM_WINDOW_KEY:
if (self->priv->key)
g_free (self->priv->key);
str = g_value_get_string (value);
self->priv->key = g_strdup (str ? str : "");
if (self->priv->settings)
g_clear_object (&self->priv->settings);
self->priv->settings = g_settings_new (self->priv->key);
break;
case GM_HIDE_ON_ESC:
self->priv->hide_on_esc = g_value_get_boolean (value);
if (!self->priv->hide_on_esc)
gtk_accel_group_disconnect_key (self->priv->accel, GDK_KEY_Escape, (GdkModifierType) 0);
else
gtk_accel_group_connect (self->priv->accel, GDK_KEY_Escape, (GdkModifierType) 0, GTK_ACCEL_LOCKED,
g_cclosure_new_swap (G_CALLBACK (gtk_widget_hide), (gpointer) self, NULL));
break;
case GM_HIDE_ON_DELETE:
self->priv->hide_on_delete = g_value_get_boolean (value);
break;
case GM_STAY_ON_TOP:
self->priv->stay_on_top = g_value_get_boolean (value);
gtk_window_set_keep_above (GTK_WINDOW (self), self->priv->stay_on_top);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (obj, prop_id, spec);
break;
}
}
static void
setup_settings (PtWindow *win)
{
win->priv->editor = g_settings_new ("org.gnome.parlatype");
g_settings_bind (
win->priv->editor, "rewind-on-pause",
win, "pause",
G_SETTINGS_BIND_GET);
g_settings_bind (
win->priv->editor, "jump-back",
win, "back",
G_SETTINGS_BIND_GET);
g_settings_bind (
win->priv->editor, "jump-forward",
win, "forward",
G_SETTINGS_BIND_GET);
/* connect to tooltip changer */
g_signal_connect (
win->priv->editor, "changed",
G_CALLBACK (settings_changed_cb),
win);
/* Default speed
Other solutions would be
- Automatically save last known speed in GSettings
- Add a default speed option to preferences dialog
- Save last known speed in metadata for each file */
win->priv->speed = 1.0;
if (g_settings_get_boolean (win->priv->editor, "start-on-top")) {
gtk_window_set_keep_above (GTK_WINDOW (win), TRUE);
}
if (g_settings_get_boolean (win->priv->editor, "remember-position")) {
gtk_window_move (GTK_WINDOW (win),
g_settings_get_int (win->priv->editor, "x-pos"),
g_settings_get_int (win->priv->editor, "y-pos"));
gtk_window_resize (GTK_WINDOW (win),
g_settings_get_int (win->priv->editor, "width"),
g_settings_get_int (win->priv->editor, "height"));
}
}
/* Create the background window. */
GtkWidget *
create_background_window ()
{
GError *error = (GError *) NULL;
GObject *background_obj = (GObject *) NULL;
background_data = allocate_background_data ();
/* Initialize the background window. */
background_data->background_window_gtk_builder = gtk_builder_new ();
/* Load the gtk builder file created with glade. */
gtk_builder_add_from_file (background_data->background_window_gtk_builder, BACKGROUND_UI_FILE, &error);
if (error)
{
g_warning ("Failed to load builder file: %s", error->message);
g_error_free (error);
return background_data->background_window;
}
background_obj = gtk_builder_get_object (background_data->background_window_gtk_builder, "backgroundWindow");
background_data->background_window = GTK_WIDGET (background_obj);
gtk_window_set_keep_above (GTK_WINDOW (background_data->background_window), TRUE);
/* This trys to set an alpha channel. */
on_back_screen_changed (background_data->background_window, NULL, background_data);
/* In the gtk 2.16.6 used for windows the gtkbuilder the double buffered property
* is not parsed from glade and then I set this by hands.
*/
gtk_widget_set_double_buffered (background_data->background_window, FALSE);
gtk_window_set_opacity (GTK_WINDOW (background_data->background_window), BACKGROUND_OPACITY);
gtk_widget_set_size_request (background_data->background_window, gdk_screen_width (), gdk_screen_height ());
/* Connect all the callback from gtkbuilder xml file. */
gtk_builder_connect_signals (background_data->background_window_gtk_builder, (gpointer) background_data);
//gtk_widget_show_all (background_data->background_window);
/* This put in full screen; this will generate an exposure. */
gtk_window_fullscreen (GTK_WINDOW (background_data->background_window));
return background_data->background_window;
}
int main(int argc, char **argv) {
gtk_init(&argc, &argv);
struct data_t data = {0};
data.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
assert(data.window);
gtk_window_set_title(GTK_WINDOW(data.window), "Plasma Cleaner");
gtk_window_set_keep_above(GTK_WINDOW(data.window), TRUE);
gtk_widget_add_events(data.window, GDK_BUTTON_PRESS_MASK|GDK_KEY_PRESS_MASK);
gtk_window_fullscreen(GTK_WINDOW(data.window));
g_signal_connect(G_OBJECT(data.window), "draw", G_CALLBACK(&on_draw), &data);
g_signal_connect(G_OBJECT(data.window), "destroy", G_CALLBACK(&on_destroy),
&data);
g_signal_connect(G_OBJECT(data.window), "button-press-event",
G_CALLBACK(&on_button_or_key_press), NULL);
g_signal_connect(G_OBJECT(data.window), "key-press-event",
G_CALLBACK(&on_button_or_key_press), NULL);
gtk_widget_realize(data.window);
GdkCursor *cursor = gdk_cursor_new(GDK_BLANK_CURSOR);
assert(cursor);
gdk_window_set_cursor(gtk_widget_get_window(data.window), cursor);
g_object_unref(cursor);
gtk_window_present(GTK_WINDOW(data.window));
data.pattern = cairo_pattern_create_linear(0.0, 0.0, 1.0, 0.0);
cairo_pattern_add_color_stop_rgb(data.pattern, 0.0, BAR_COLOUR_R,
BAR_COLOUR_G, BAR_COLOUR_B);
cairo_pattern_add_color_stop_rgb(data.pattern, BAR_FRACTION, BAR_COLOUR_R,
BAR_COLOUR_G, BAR_COLOUR_B);
cairo_pattern_add_color_stop_rgb(data.pattern, BAR_FRACTION, 0.0, 0.0, 0.0);
cairo_pattern_add_color_stop_rgb(data.pattern, 1.0, 0.0, 0.0, 0.0);
cairo_pattern_set_extend(data.pattern, CAIRO_EXTEND_REPEAT);
guint screensaver_suppression_timeout_id = g_timeout_add(
SCREENSAVER_SUPPRESSION_PERIOD_MS, &on_screensaver_suppression_timer,
NULL);
gtk_main();
g_source_remove(screensaver_suppression_timeout_id);
cairo_pattern_destroy(data.pattern);
return 0;
}
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;
}
// Make the GTK dialog passed in (p_widget) transient for the toplevel or
// default stack -- i.e. it will float above it.
void make_front_widget ( GtkWidget *p_widget)
{
Window t_window = MCdefaultstackptr -> getwindow();
if (t_window == DNULL && MCtopstackptr != DNULL)
t_window = MCtopstackptr -> getwindow();
gtk_widget_realize( GTK_WIDGET( p_widget )) ;
if ( t_window != NULL)
{
GdkWindow * gdk_window = NULL ;
gdk_window = GTK_WIDGET ( p_widget ) -> window ;
if ( gdk_window != NULL )
XSetTransientForHint ( ((MCScreenDC*)MCscreen) -> getDisplay(), GDK_WINDOW_XWINDOW ( ( gdk_window ) ), t_window ) ;
else
gtk_window_set_keep_above ( GTK_WINDOW ( p_widget ) , True ) ;
}
}
static void _panel_helper_logout_dialog(Panel * panel)
{
const char message[] = N_("This will log you out of the current session"
", therefore closing any application currently opened"
" and losing any unsaved data.\n"
"Do you really want to proceed?");
GtkWidget * widget;
if(panel->lo_window != NULL)
{
gtk_window_present(GTK_WINDOW(panel->lo_window));
return;
}
panel->lo_window = gtk_message_dialog_new(NULL, 0, GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
#if GTK_CHECK_VERSION(2, 6, 0)
"%s", _("Logout"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(
panel->lo_window),
#endif
"%s", _(message));
#if GTK_CHECK_VERSION(2, 10, 0)
gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(panel->lo_window),
gtk_image_new_from_icon_name("gnome-logout",
GTK_ICON_SIZE_DIALOG));
#endif
gtk_dialog_add_buttons(GTK_DIALOG(panel->lo_window), GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, NULL);
widget = gtk_button_new_with_label(_("Logout"));
gtk_button_set_image(GTK_BUTTON(widget), gtk_image_new_from_icon_name(
"gnome-logout", GTK_ICON_SIZE_BUTTON));
gtk_widget_show_all(widget);
gtk_dialog_add_action_widget(GTK_DIALOG(panel->lo_window), widget,
GTK_RESPONSE_ACCEPT);
gtk_window_set_keep_above(GTK_WINDOW(panel->lo_window), TRUE);
gtk_window_set_position(GTK_WINDOW(panel->lo_window),
GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(panel->lo_window), _("Logout"));
g_signal_connect_swapped(panel->lo_window, "delete-event", G_CALLBACK(
_logout_dialog_on_closex), panel);
g_signal_connect(panel->lo_window, "response", G_CALLBACK(
_logout_dialog_on_response), panel);
gtk_widget_show_all(panel->lo_window);
}
static void create_splash() {
splash_screen = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(splash_screen), "Splash Screen");
gtk_container_set_border_width(GTK_CONTAINER(splash_screen), 0);
gtk_widget_set_size_request(splash_screen, 640, 384);
gtk_window_set_keep_above(GTK_WINDOW(splash_screen), TRUE);
gtk_window_set_decorated(GTK_WINDOW(splash_screen), FALSE);
gtk_window_set_position(GTK_WINDOW(splash_screen), GTK_WIN_POS_CENTER);
gtk_window_set_resizable(GTK_WINDOW(splash_screen), FALSE);
CString str = g_strBitmapsPath;
str += "splash.png";
GtkWidget *image = gtk_image_new_from_file(str.GetBuffer());
gtk_container_add(GTK_CONTAINER(splash_screen), image);
gtk_widget_show_all(splash_screen);
while(gtk_events_pending())
gtk_main_iteration();
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
gtk_init(&argc,&argv);
window = create_window ();
gtk_window_set_default_size (GTK_WINDOW(window), 400, 400);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
navigator = xml_navigator_new();
g_signal_connect(navigator, "xml-row-activated",
G_CALLBACK(on_navigator_activated), NULL);
/* Create the Main Toolbar*/
GtkWidget *toolbar;
tools_view_vbox = gtk_vbox_new(FALSE, 3);
toolbar = make_toolbar();
gtk_box_pack_start(GTK_BOX(tools_view_vbox), toolbar, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(tools_view_vbox), navigator);
gtk_container_add(GTK_CONTAINER(window), tools_view_vbox);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static void create_volume_scale(void)
{
// Create a popup window
window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_keep_above(GTK_WINDOW(window), TRUE);
gtk_window_set_default_size(GTK_WINDOW(window), 0, 120);
// Create the scale and add it to the window
scale = gtk_scale_new_with_range(GTK_ORIENTATION_VERTICAL, 0.0, 100.0, 1.0);
gtk_scale_set_draw_value(GTK_SCALE(scale), FALSE);
gtk_range_set_inverted(GTK_RANGE(scale), TRUE);
gtk_container_add(GTK_CONTAINER(window), scale);
gtk_widget_show(scale);
// Connect the value changed signal
g_signal_connect(G_OBJECT(scale), "value-changed", G_CALLBACK(on_scale_value_change), NULL);
}
