void addButton(std::string IP){
cout << IP << endl;
for (int i = 0; i<5;i++){ //Check if it already exists as a button
std::string ButtonString = (std::string) gtk_button_get_label(Button[i]);
if(IP==ButtonString){
gtk_widget_set_opacity((GtkWidget*) Button[i],1);
gtk_widget_set_sensitive ((GtkWidget*) Button[i], true);
return;
}
}
for (int i = 0; i<5;i++){
const char* lol = IP.c_str();
std::string ButtonString = (std::string) gtk_button_get_label(Button[i]);
cout << ButtonString << endl;
if(ButtonString=="NONE"){
gtk_button_set_label(Button[i], lol);
IPtoBuffer[IP] = Counter;
gtk_widget_set_opacity((GtkWidget*) Button[i],1);
gtk_widget_set_sensitive ((GtkWidget*) Button[i], true);
Counter++;
return;
}
}
}
static void
set_locale_id (GtkDialog *chooser,
const gchar *locale_id)
{
CcLanguageChooserPrivate *priv = GET_PRIVATE (chooser);
GList *children, *l;
children = gtk_container_get_children (GTK_CONTAINER (priv->language_list));
for (l = children; l; l = l->next) {
GtkWidget *row = l->data;
GtkWidget *check = g_object_get_data (G_OBJECT (row), "check");
const gchar *language = g_object_get_data (G_OBJECT (row), "locale-id");
if (check == NULL || language == NULL)
continue;
if (g_strcmp0 (locale_id, language) == 0) {
gboolean is_extra;
gtk_widget_set_opacity (check, 1.0);
/* make sure the selected language is shown */
is_extra = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (row), "is-extra"));
if (!priv->showing_extra && is_extra) {
g_object_set_data (G_OBJECT (row), "is-extra", GINT_TO_POINTER (FALSE));
gtk_list_box_invalidate_filter (GTK_LIST_BOX (priv->language_list));
}
} else {
gtk_widget_set_opacity (check, 0.0);
}
}
g_list_free (children);
g_free (priv->language);
priv->language = g_strdup (locale_id);
}
GtkWidget *
do_transparent (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *overlay;
GtkWidget *button;
GtkWidget *label;
GtkWidget *picture;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_display (GTK_WINDOW (window),
gtk_widget_get_display (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 450, 450);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
gtk_window_set_title (GTK_WINDOW (window), "Transparency");
overlay = blur_overlay_new ();
gtk_container_add (GTK_CONTAINER (window), overlay);
button = gtk_button_new_with_label ("Don't click this button!");
label = gtk_bin_get_child (GTK_BIN (button));
g_object_set (label, "margin", 50, NULL);
gtk_widget_set_opacity (button, 0.7);
gtk_widget_set_halign (button, GTK_ALIGN_FILL);
gtk_widget_set_valign (button, GTK_ALIGN_START);
blur_overlay_add_overlay (BLUR_OVERLAY (overlay), button, 5.0);
button = gtk_button_new_with_label ("Maybe this one?");
label = gtk_bin_get_child (GTK_BIN (button));
g_object_set (label, "margin", 50, NULL);
gtk_widget_set_opacity (button, 0.7);
gtk_widget_set_halign (button, GTK_ALIGN_FILL);
gtk_widget_set_valign (button, GTK_ALIGN_END);
blur_overlay_add_overlay (BLUR_OVERLAY (overlay), button, 5.0);
picture = gtk_picture_new_for_resource ("/transparent/portland-rose.jpg");
gtk_container_add (GTK_CONTAINER (overlay), picture);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show (window);
else
gtk_widget_destroy (window);
return window;
}
void
ide_widget_show_with_fade (GtkWidget *widget)
{
GdkFrameClock *frame_clock;
EggAnimation *anim;
g_return_if_fail (GTK_IS_WIDGET (widget));
if (!gtk_widget_get_visible (widget))
{
anim = g_object_get_data (G_OBJECT (widget), "FADE_ANIMATION");
if (anim != NULL)
egg_animation_stop (anim);
frame_clock = gtk_widget_get_frame_clock (widget);
gtk_widget_set_opacity (widget, 0.0);
gtk_widget_show (widget);
anim = egg_object_animate_full (widget,
EGG_ANIMATION_LINEAR,
500,
frame_clock,
show_callback,
g_object_ref (widget),
"opacity", 1.0,
NULL);
g_object_set_data_full (G_OBJECT (widget), "FADE_ANIMATION",
g_object_ref (anim), g_object_unref);
}
}
static gboolean
gd_stack_transition_cb (GdStack *stack,
GdkFrameClock *frame_clock,
gpointer user_data)
{
GdStackPrivate *priv = stack->priv;
gint64 now;
gdouble t;
now = gdk_frame_clock_get_frame_time (frame_clock);
t = 1.0;
if (now < priv->end_time)
t = (now - priv->start_time) / (double) (priv->end_time - priv->start_time);
/* Finish animation early if not mapped anymore */
if (!gtk_widget_get_mapped (GTK_WIDGET (stack)))
t = 1.0;
if (gd_stack_set_transition_position (stack, t))
{
gtk_widget_set_opacity (GTK_WIDGET (stack), 1.0);
priv->tick_id = 0;
return FALSE;
}
return TRUE;
}
static void
gd_stack_start_transition (GdStack *stack)
{
GdStackPrivate *priv = stack->priv;
GtkWidget *widget = GTK_WIDGET (stack);
gboolean animations_enabled;
g_object_get (gtk_widget_get_settings (widget),
"gtk-enable-animations", &animations_enabled,
NULL);
if (gtk_widget_get_mapped (widget) &&
animations_enabled &&
priv->transition_type != GD_STACK_TRANSITION_TYPE_NONE &&
priv->last_visible_child != NULL)
{
gtk_widget_set_opacity (widget, 0.999);
priv->transition_pos = 0.0;
priv->start_time = gdk_frame_clock_get_frame_time (gtk_widget_get_frame_clock (widget));
priv->end_time = priv->start_time + (priv->transition_duration * 1000);
gd_stack_schedule_ticks (stack);
}
else
{
gd_stack_unschedule_ticks (stack);
gd_stack_set_transition_position (stack, 1.0);
}
}
static gboolean fs_control_leave_handler( GtkWidget *widget,
GdkEvent *event,
gpointer data )
{
gtk_widget_set_opacity(data, 0);
return FALSE;
}
static GtkWidget *
language_widget_new (const gchar *locale_id,
const gchar *current_locale_id,
gboolean is_extra)
{
gchar *locale_name;
gchar *locale_current_name;
gchar *locale_untranslated_name;
GtkWidget *row;
GtkWidget *check;
GtkWidget *box;
locale_name = gnome_get_language_from_locale (locale_id, locale_id);
locale_current_name = gnome_get_language_from_locale (locale_id, NULL);
locale_untranslated_name = gnome_get_language_from_locale (locale_id, "C");
row = gtk_list_box_row_new ();
box = padded_label_new (locale_name, is_extra);
gtk_container_add (GTK_CONTAINER (row), box);
/* We add a check on each side of the label to keep it centered. */
check = gtk_image_new ();
gtk_image_set_from_icon_name (GTK_IMAGE (check), "object-select-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_opacity (check, 0.0);
g_object_set (check, "icon-size", GTK_ICON_SIZE_MENU, NULL);
gtk_box_pack_start (GTK_BOX (box), check, FALSE, FALSE, 0);
gtk_box_reorder_child (GTK_BOX (box), check, 0);
check = gtk_image_new ();
gtk_image_set_from_icon_name (GTK_IMAGE (check), "object-select-symbolic", GTK_ICON_SIZE_MENU);
gtk_widget_set_opacity (check, 0.0);
g_object_set (check, "icon-size", GTK_ICON_SIZE_MENU, NULL);
gtk_box_pack_start (GTK_BOX (box), check, FALSE, FALSE, 0);
if (g_strcmp0 (locale_id, current_locale_id) == 0)
gtk_widget_set_opacity (check, 1.0);
g_object_set_data (G_OBJECT (row), "check", check);
g_object_set_data_full (G_OBJECT (row), "locale-id", g_strdup (locale_id), g_free);
g_object_set_data_full (G_OBJECT (row), "locale-name", locale_name, g_free);
g_object_set_data_full (G_OBJECT (row), "locale-current-name", locale_current_name, g_free);
g_object_set_data_full (G_OBJECT (row), "locale-untranslated-name", locale_untranslated_name, g_free);
g_object_set_data (G_OBJECT (row), "is-extra", GUINT_TO_POINTER (is_extra));
return row;
}
static void _hide_close_button(DeepinWorkspaceOverview* self)
{
if (self->priv->close_button) {
gtk_widget_set_opacity(self->priv->close_button, 0.0);
deepin_fixed_move(DEEPIN_FIXED(self), self->priv->close_button,
-100, -100,
FALSE);
}
}
static void
hide_callback (gpointer data)
{
GtkWidget *widget = data;
gtk_widget_hide (widget);
gtk_widget_set_opacity (widget, 1.0);
g_object_unref (widget);
}
static void
hide_callback (gpointer data)
{
GtkWidget *widget = data;
g_object_set_data (data, "FADE_ANIMATION", NULL);
gtk_widget_hide (widget);
gtk_widget_set_opacity (widget, 1.0);
g_object_unref (widget);
}
static void
row_activated (GtkListBox *box, GtkListBoxRow *row)
{
GtkWidget *image;
GtkWidget *dialog;
image = (GtkWidget *)g_object_get_data (G_OBJECT (row), "image");
dialog = (GtkWidget *)g_object_get_data (G_OBJECT (row), "dialog");
if (image)
{
if (gtk_widget_get_opacity (image) > 0)
gtk_widget_set_opacity (image, 0);
else
gtk_widget_set_opacity (image, 1);
}
else if (dialog)
{
gtk_window_present (GTK_WINDOW (dialog));
}
}
static int gtkDialogSetOpacityAttrib(Ihandle *ih, const char *value)
{
int opacity;
if (!iupStrToInt(value, &opacity))
return 0;
#if GTK_CHECK_VERSION(3, 8, 0)
gtk_widget_set_opacity(ih->handle, (double)opacity/255.0);
#else
gtk_window_set_opacity((GtkWindow*)ih->handle, (double)opacity/255.0);
#endif
return 1;
}
void deleteButton(std::string IP){
for (int i = 0; i<5;i++){
std::string ButtonString = (std::string) gtk_button_get_label(Button[i]);
if(IP==ButtonString){
//gtk_button_set_label(Button[i], "NONE");
gtk_widget_set_opacity((GtkWidget*) Button[i],0.5);
gtk_widget_set_sensitive ((GtkWidget*) Button[i], false);
if(getNextHop(DestinationIP, fwdTable) == ButtonString){
DestinationIP = "";
gtk_editable_set_editable( (GtkEditable*) InputBar, false);
}
}
}
}
bool wxTopLevelWindowGTK::SetTransparent(wxByte alpha)
{
if (m_widget == NULL)
return false;
#if GTK_CHECK_VERSION(2,12,0)
#ifndef __WXGTK3__
if (gtk_check_version(2,12,0) == NULL)
#endif
{
#if GTK_CHECK_VERSION(3,8,0)
if(gtk_check_version(3,8,0) == NULL)
{
gtk_widget_set_opacity(m_widget, alpha / 255.0);
}
else
#endif
{
// Can't avoid using this deprecated function with older GTK+.
wxGCC_WARNING_SUPPRESS(deprecated-declarations);
gtk_window_set_opacity(GTK_WINDOW(m_widget), alpha / 255.0);
wxGCC_WARNING_RESTORE();
}
return true;
}
#endif // GTK_CHECK_VERSION(2,12,0)
#ifndef __WXGTK3__
#ifdef GDK_WINDOWING_X11
GdkWindow* window = gtk_widget_get_window(m_widget);
if (window == NULL)
return false;
Display* dpy = GDK_WINDOW_XDISPLAY(window);
Window win = GDK_WINDOW_XID(window);
if (alpha == 0xff)
XDeleteProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False));
else
{
long opacity = alpha * 0x1010101L;
XChangeProperty(dpy, win, XInternAtom(dpy, "_NET_WM_WINDOW_OPACITY", False),
XA_CARDINAL, 32, PropModeReplace,
(unsigned char *) &opacity, 1L);
}
XSync(dpy, False);
return true;
#else // !GDK_WINDOWING_X11
return false;
#endif // GDK_WINDOWING_X11 / !GDK_WINDOWING_X11
#endif // !__WXGTK3__
}
static void
sw_delay_notify (GObject *obj, GParamSpec *pspec, gpointer data)
{
GtkWidget *spinner = data;
gboolean active;
gboolean state;
g_object_get (obj,
"active", &active,
"state", &state,
NULL);
if (active != state)
{
gtk_spinner_start (GTK_SPINNER (spinner));
gtk_widget_set_opacity (spinner, 1.0);
}
else
{
gtk_widget_set_opacity (spinner, 0.0);
gtk_spinner_stop (GTK_SPINNER (spinner));
}
}
static void
reemphasize_window (GtkWidget *window)
{
GdkDisplay *display;
display = gtk_widget_get_display (window);
if (gdk_display_is_composited (display))
{
gtk_widget_set_opacity (window, 1.0);
gtk_widget_input_shape_combine_region (window, NULL);
}
else
gdk_window_raise (gtk_widget_get_window (window));
}
static void
ide_workbench_actions_opacity (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
IdeWorkbench *workbench = user_data;
gdouble opacity;
g_assert (IDE_IS_WORKBENCH (workbench));
g_assert (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32));
opacity = CLAMP (g_variant_get_int32 (variant), 10, 100) / 100.0;
gtk_widget_set_opacity (GTK_WIDGET (workbench), opacity);
}
static void
update_color (GcalEventWidget *self)
{
GtkStyleContext *context;
GdkRGBA *color;
GQuark color_id;
gchar *color_str;
gchar *css_class;
GDateTime *now;
gint date_compare;
context = gtk_widget_get_style_context (GTK_WIDGET (self));
color = gcal_event_get_color (self->event);
now = g_date_time_new_now_local ();
date_compare = g_date_time_compare (self->dt_end, now);
/* Fades out an event that's earlier than the current date */
gtk_widget_set_opacity (GTK_WIDGET (self), date_compare < 0 ? 0.6 : 1.0);
/* Remove the old style class */
if (self->css_class)
{
gtk_style_context_remove_class (context, self->css_class);
g_clear_pointer (&self->css_class, g_free);
}
color_str = gdk_rgba_to_string (color);
color_id = g_quark_from_string (color_str);
css_class = g_strdup_printf ("color-%d", color_id);
gtk_style_context_add_class (context, css_class);
if (INTENSITY (color) > 0.5)
{
gtk_style_context_remove_class (context, "color-dark");
gtk_style_context_add_class (context, "color-light");
}
else
{
gtk_style_context_remove_class (context, "color-light");
gtk_style_context_add_class (context, "color-dark");
}
/* Keep the current style around, so we can remove it later */
self->css_class = css_class;
g_clear_pointer (&now, g_date_time_unref);
g_free (color_str);
}
// propagate from cloned
static gboolean on_deepin_cloned_widget_entered(MetaDeepinClonedWidget* cloned,
GdkEvent* event, gpointer data)
{
DeepinWorkspaceOverview* self = (DeepinWorkspaceOverview*)data;
DeepinWorkspaceOverviewPrivate* priv = self->priv;
if (!priv->ready) return FALSE;
meta_verbose ("%s\n", __func__);
priv->hovered_clone = cloned;
if (priv->ready) {
_move_close_button_for(self, cloned);
gtk_widget_set_opacity(priv->close_button, 1.0);
}
return TRUE;
}
static gboolean
fade_in (gpointer data)
{
GtkWidget *spinner = data;
gdouble opacity;
opacity = gtk_widget_get_opacity (spinner);
opacity = opacity + 0.1;
gtk_widget_set_opacity (spinner, opacity);
if (opacity >= 1.0) {
g_object_steal_data (G_OBJECT (spinner), "fade-timeout");
return G_SOURCE_REMOVE;
}
return G_SOURCE_CONTINUE;
}
static gboolean
start_spinning (gpointer data)
{
GtkWidget *spinner = data;
guint id;
gtk_widget_set_opacity (spinner, 0);
gtk_spinner_start (GTK_SPINNER (spinner));
id = g_timeout_add (100, fade_in, spinner);
g_object_set_data_full (G_OBJECT (spinner), "fade-timeout",
GUINT_TO_POINTER (id), remove_source);
/* don't try to remove this source in the future */
g_object_steal_data (G_OBJECT (spinner), "start-timeout");
return G_SOURCE_REMOVE;
}
void
gs_start_spinner (GtkSpinner *spinner)
{
gboolean active;
guint id;
/* Don't do anything if it's already spinning */
g_object_get (spinner, "active", &active, NULL);
if (active || g_object_get_data (G_OBJECT (spinner), "start-timeout") != NULL)
return;
gtk_widget_set_opacity (GTK_WIDGET (spinner), 0);
id = g_timeout_add (SPINNER_DELAY, start_spinning, spinner);
g_object_set_data_full (G_OBJECT (spinner), "start-timeout",
GUINT_TO_POINTER (id), remove_source);
}
static void
photos_dropdown_init (PhotosDropdown *self)
{
PhotosDropdownPrivate *priv;
GApplication *app;
GtkStyleContext *context;
GtkWidget *frame;
PhotosSearchContextState *state;
self->priv = photos_dropdown_get_instance_private (self);
priv = self->priv;
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
priv->srch_mtch_mngr = g_object_ref (state->srch_mtch_mngr);
priv->srch_typ_mngr = g_object_ref (state->srch_typ_mngr);
priv->src_mngr = g_object_ref (state->src_mngr);
priv->match_view = photos_base_view_new (priv->srch_mtch_mngr);
priv->source_view = photos_base_view_new (priv->src_mngr);
priv->type_view = photos_base_view_new (priv->srch_typ_mngr);
g_signal_connect_swapped (priv->match_view, "item-activated", G_CALLBACK (photos_dropdown_item_activated), self);
g_signal_connect_swapped (priv->source_view, "item-activated", G_CALLBACK (photos_dropdown_item_activated), self);
g_signal_connect_swapped (priv->type_view, "item-activated", G_CALLBACK (photos_dropdown_item_activated), self);
frame = gtk_frame_new (NULL);
gtk_widget_set_opacity (frame, 0.9);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
context = gtk_widget_get_style_context (frame);
gtk_style_context_add_class (context, "photos-dropdown");
gtk_container_add (GTK_CONTAINER (self), frame);
priv->grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (priv->grid), GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (frame), priv->grid);
gtk_container_add (GTK_CONTAINER (priv->grid), priv->source_view);
gtk_container_add (GTK_CONTAINER (priv->grid), priv->type_view);
gtk_container_add (GTK_CONTAINER (priv->grid), priv->match_view);
photos_dropdown_hide (self);
gtk_widget_show_all (GTK_WIDGET (self));
}
static GtkWidget *
make_delayed_switch (gboolean is_on,
gboolean is_sensitive)
{
GtkWidget *hbox;
GtkWidget *sw, *label, *spinner, *check;
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
sw = gtk_switch_new ();
gtk_switch_set_active (GTK_SWITCH (sw), is_on);
gtk_box_pack_start (GTK_BOX (hbox), sw, FALSE, FALSE, 0);
gtk_widget_set_sensitive (sw, is_sensitive);
gtk_widget_show (sw);
g_signal_connect (sw, "state-set", G_CALLBACK (set_state), NULL);
spinner = gtk_spinner_new ();
gtk_box_pack_start (GTK_BOX (hbox), spinner, FALSE, TRUE, 0);
gtk_widget_set_opacity (spinner, 0.0);
gtk_widget_show (spinner);
check = gtk_check_button_new ();
gtk_box_pack_end (GTK_BOX (hbox), check, FALSE, TRUE, 0);
gtk_widget_show (check);
g_object_bind_property (sw, "state",
check, "active",
G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE);
label = gtk_label_new (is_on ? "Enabled" : "Disabled");
gtk_box_pack_end (GTK_BOX (hbox), label, TRUE, TRUE, 0);
gtk_widget_show (label);
g_object_bind_property_full (sw, "active",
label, "label",
G_BINDING_DEFAULT,
boolean_to_text,
NULL,
NULL, NULL);
g_signal_connect (sw, "notify", G_CALLBACK (sw_delay_notify), spinner);
return hbox;
}
static void
sync_checkmark (GtkWidget *row,
gpointer user_data)
{
GtkWidget *child;
LanguageWidget *widget;
gchar *locale_id;
gboolean should_be_visible;
child = gtk_bin_get_child (GTK_BIN (row));
widget = get_language_widget (child);
if (widget == NULL)
return;
locale_id = user_data;
should_be_visible = g_str_equal (widget->locale_id, locale_id);
gtk_widget_set_opacity (widget->checkmark, should_be_visible ? 1.0 : 0.0);
}
static gboolean
cheese_flash_opacity_fade (gpointer data)
{
CheeseFlash *flash = data;
CheeseFlashPrivate *flash_priv = CHEESE_FLASH_GET_PRIVATE (flash);
GtkWidget *flash_window = GTK_WIDGET (flash_priv->window);
double opacity = gtk_widget_get_opacity (flash_window);
/* exponentially decrease */
gtk_widget_set_opacity (flash_window, opacity * FLASH_FADE_FACTOR);
if (opacity <= FLASH_LOW_THRESHOLD)
{
/* the flasher has finished when we reach the quit value */
gtk_widget_hide (flash_window);
return FALSE;
}
return TRUE;
}
static void
deemphasize_window (GtkWidget *window)
{
GdkDisplay *display;
display = gtk_widget_get_display (window);
if (gdk_display_is_composited (display))
{
cairo_rectangle_int_t rect;
cairo_region_t *region;
gtk_widget_set_opacity (window, 0.3);
rect.x = rect.y = rect.width = rect.height = 0;
region = cairo_region_create_rectangle (&rect);
gtk_widget_input_shape_combine_region (window, region);
cairo_region_destroy (region);
}
else
gdk_window_lower (gtk_widget_get_window (window));
}
void
gb_widget_fade_show (GtkWidget *widget)
{
GdkFrameClock *frame_clock;
g_return_if_fail (GTK_IS_WIDGET (widget));
if (!gtk_widget_get_visible (widget))
{
frame_clock = gtk_widget_get_frame_clock (widget);
gtk_widget_set_opacity (widget, 0.0);
gtk_widget_show (widget);
ide_object_animate_full (widget,
IDE_ANIMATION_LINEAR,
500,
frame_clock,
NULL,
NULL,
"opacity", 1.0,
NULL);
}
}
void
cheese_flash_fire (CheeseFlash *flash,
GdkRectangle *rect)
{
CheeseFlashPrivate *flash_priv = CHEESE_FLASH_GET_PRIVATE (flash);
GtkWindow *flash_window = flash_priv->window;
if (flash_priv->flash_timeout_tag > 0)
g_source_remove (flash_priv->flash_timeout_tag);
if (flash_priv->fade_timeout_tag > 0)
g_source_remove (flash_priv->fade_timeout_tag);
gtk_window_resize (flash_window, rect->width, rect->height);
gtk_window_move (flash_window, rect->x, rect->y);
gtk_widget_set_opacity (GTK_WIDGET (flash_window), 0.99);
gtk_widget_show_all (GTK_WIDGET (flash_window));
flash_priv->flash_timeout_tag =
g_timeout_add_full (G_PRIORITY_DEFAULT,
FLASH_DURATION,
cheese_flash_start_fade,
g_object_ref (flash), g_object_unref);
}
