gboolean af_window_restore()
{
if (!af_window_get_visible()) return FALSE;
GtkWidget *window = global_get("window");
switch(af_window_get_state()){
case GDK_WINDOW_STATE_WITHDRAWN: af_window_set_visible(TRUE);
break;
case GDK_WINDOW_STATE_ICONIFIED: gtk_window_deiconify(GTK_WINDOW(window));
break;
case GDK_WINDOW_STATE_MAXIMIZED: gtk_window_unmaximize(GTK_WINDOW(window));
break;
case GDK_WINDOW_STATE_STICKY: gtk_window_unstick(GTK_WINDOW(window));
break;
case GDK_WINDOW_STATE_FULLSCREEN: af_window_set_fullscreen(FALSE);
break;
case GDK_WINDOW_STATE_ABOVE: af_window_set_above(FALSE);
break;
case GDK_WINDOW_STATE_BELOW: af_window_set_below(FALSE);
break;
default:
return FALSE;
}
return TRUE;
}
void gldi_desklet_set_sticky (CairoDesklet *pDesklet, gboolean bSticky)
{
//g_print ("%s (%d)\n", __func__, bSticky);
int iNumDesktop;
if (bSticky)
{
gtk_window_stick (GTK_WINDOW (pDesklet->container.pWidget));
iNumDesktop = -1;
}
else
{
gtk_window_unstick (GTK_WINDOW (pDesklet->container.pWidget));
int iCurrentDesktop, iCurrentViewportX, iCurrentViewportY;
gldi_desktop_get_current (&iCurrentDesktop, &iCurrentViewportX, &iCurrentViewportY);
iNumDesktop = iCurrentDesktop * g_desktopGeometry.iNbViewportX * g_desktopGeometry.iNbViewportY + iCurrentViewportX * g_desktopGeometry.iNbViewportY + iCurrentViewportY;
cd_debug (">>> on colle ce desklet sur le bureau %d", iNumDesktop);
}
//\_________________ On enregistre le nouvel etat.
Icon *icon = pDesklet->pIcon;
if (CAIRO_DOCK_IS_APPLET (icon))
cairo_dock_update_conf_file (icon->pModuleInstance->cConfFilePath,
G_TYPE_BOOLEAN, "Desklet", "sticky", bSticky,
G_TYPE_INT, "Desklet", "num desktop", iNumDesktop,
G_TYPE_INVALID);
}
void
cid_read_config_after_update (CidMainContainer **pCid, const char *f)
{
CidMainContainer *cid = *pCid;
cid_read_config (pCid, f);
// Si on active les fonctions 'instables', on détruit puis recree la fenetre
if ((cid->config->bChangedTestingConf != (cid->config->bUnstable && cid->config->bTesting)))
{
cid->config->bChangedTestingConf = cid->config->bTesting && cid->config->bUnstable;
gtk_widget_destroy(cid->pWindow);
cid_create_main_window();
}
// Si on change de lecteur
if (iPlayerChanged != cid->config->iPlayer)
{
cid_disconnect_player ();
cid_free_musicData();
if (cid->runtime->pMonitorList)
{
//g_slice_free (CidControlFunctionsList,cid->runtime->pMonitorList);
cid->runtime->pMonitorList = NULL;
}
cid_run_with_player(pCid);
}
// Si la couleur des controles change, on les recharge
if (iSymbolChanged != cid->config->iSymbolColor || iPlayerChanged != cid->config->iPlayer)
cid_load_symbols();
cid_check_position();
gtk_window_move (GTK_WINDOW(cid->pWindow), cid->config->iPosX, cid->config->iPosY);
gtk_window_resize (GTK_WINDOW (cid->pWindow), cid->config->iWidth, cid->config->iHeight);
// Si on change l'affichage
if (bChangedDesktop != cid->config->bAllDesktop)
{
if (!cid->config->bAllDesktop)
gtk_window_unstick(GTK_WINDOW(cid->pWindow));
else
gtk_window_stick(GTK_WINDOW(cid->pWindow));
}
// Enfin, si on redimenssionne, on recharge les images
if (cid->config->iWidth != iOldWidth || cid->config->iHeight != iOldHeight)
{
cid_display_image (musicData.playing_cover);
cid_load_symbols();
}
CID_REDRAW;
}
void gMainWindow::setSticky(bool vl)
{
sticky=vl;
if (!isTopLevel()) return;
if (vl) gtk_window_stick(GTK_WINDOW(border));
else gtk_window_unstick(GTK_WINDOW(border));
}
/**
* gedit_app_create_window:
* @app: the #GeditApp
* @screen: (allow-none):
*
* Create a new #GeditWindow part of @app.
*
* Return value: (transfer none): the new #GeditWindow
*/
GeditWindow *
gedit_app_create_window (GeditApp *app,
GdkScreen *screen)
{
GeditAppPrivate *priv;
GeditWindow *window;
gchar *role;
GdkWindowState state;
gint w, h;
gedit_debug (DEBUG_APP);
priv = gedit_app_get_instance_private (app);
window = GEDIT_APP_GET_CLASS (app)->create_window (app);
if (screen != NULL)
{
gtk_window_set_screen (GTK_WINDOW (window), screen);
}
role = gen_role ();
gtk_window_set_role (GTK_WINDOW (window), role);
g_free (role);
state = g_settings_get_int (priv->window_settings,
GEDIT_SETTINGS_WINDOW_STATE);
g_settings_get (priv->window_settings,
GEDIT_SETTINGS_WINDOW_SIZE,
"(ii)", &w, &h);
gtk_window_set_default_size (GTK_WINDOW (window), w, h);
if ((state & GDK_WINDOW_STATE_MAXIMIZED) != 0)
{
gtk_window_maximize (GTK_WINDOW (window));
}
else
{
gtk_window_unmaximize (GTK_WINDOW (window));
}
if ((state & GDK_WINDOW_STATE_STICKY ) != 0)
{
gtk_window_stick (GTK_WINDOW (window));
}
else
{
gtk_window_unstick (GTK_WINDOW (window));
}
return window;
}
JNIEXPORT void JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1unstick
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
gtk_window_unstick(self);
// cleanup parameter self
}
void WXAppBar::SetSticky (bool stick)
{
#if defined(__WXMSW__)
// TODO
(void)(stick); // Remove warning
//assert (false);
#elif defined(__WXGTK__)
// Get X11 handle for our window
GtkWindow *gtkWindow= (GtkWindow *) GetHandle();
assert (gtkWindow);
if (!gtkWindow) return;
if (stick)
gtk_window_stick (gtkWindow);
else
gtk_window_unstick (gtkWindow);
#else
assert (false);
#endif
}
/* Preferences Callback : Apply to existing notes. */
void preferences_apply_cb(GSettings *settings, gchar *key, gpointer data)
{
GList *l;
StickyNote *note;
if (!strcmp (key, "sticky"))
{
if (g_settings_get_boolean (settings, key))
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
gtk_window_stick (GTK_WINDOW (note->w_window));
}
else
for (l= stickynotes->notes; l; l = l->next)
{
note = l->data;
gtk_window_unstick (GTK_WINDOW (
note->w_window));
}
}
else if (!strcmp (key, "locked"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_locked (note,
g_settings_get_boolean (settings, key));
}
stickynotes_save();
}
else if (!strcmp (key, "use-system-color") ||
!strcmp (key, "default-color"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_color (note,
note->color, note->font_color,
FALSE);
}
}
else if (!strcmp (key, "use-system-font") ||
!strcmp (key, "default-font"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_font (note, note->font, FALSE);
}
}
else if (!strcmp (key, "force-default"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_color(note,
note->color, note->font_color,
FALSE);
stickynote_set_font(note, note->font, FALSE);
}
}
stickynotes_applet_update_prefs();
stickynotes_applet_update_menus();
}
void gldi_desklet_configure (CairoDesklet *pDesklet, CairoDeskletAttr *pAttribute)
{
//g_print ("%s (%dx%d ; (%d,%d) ; %d)\n", __func__, pAttribute->iDeskletWidth, pAttribute->iDeskletHeight, pAttribute->iDeskletPositionX, pAttribute->iDeskletPositionY, pAttribute->iVisibility);
if (pAttribute->bDeskletUseSize && (pAttribute->iDeskletWidth != pDesklet->container.iWidth || pAttribute->iDeskletHeight != pDesklet->container.iHeight))
{
pDesklet->iDesiredWidth = pAttribute->iDeskletWidth;
pDesklet->iDesiredHeight = pAttribute->iDeskletHeight;
gdk_window_resize (gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet)),
pAttribute->iDeskletWidth,
pAttribute->iDeskletHeight);
}
if (! pAttribute->bDeskletUseSize)
{
gtk_container_set_border_width (GTK_CONTAINER (pDesklet->container.pWidget), 0);
gtk_window_set_resizable (GTK_WINDOW(pDesklet->container.pWidget), FALSE);
}
int iAbsolutePositionX = (pAttribute->iDeskletPositionX < 0 ? gldi_desktop_get_width() + pAttribute->iDeskletPositionX : pAttribute->iDeskletPositionX);
iAbsolutePositionX = MAX (0, MIN (gldi_desktop_get_width() - pAttribute->iDeskletWidth, iAbsolutePositionX));
int iAbsolutePositionY = (pAttribute->iDeskletPositionY < 0 ? gldi_desktop_get_height() + pAttribute->iDeskletPositionY : pAttribute->iDeskletPositionY);
iAbsolutePositionY = MAX (0, MIN (gldi_desktop_get_height() - pAttribute->iDeskletHeight, iAbsolutePositionY));
//g_print (" let's place the deklet at (%d;%d)", iAbsolutePositionX, iAbsolutePositionY);
if (pAttribute->bOnAllDesktops)
{
gtk_window_stick (GTK_WINDOW (pDesklet->container.pWidget));
gdk_window_move (gldi_container_get_gdk_window (CAIRO_CONTAINER (pDesklet)),
iAbsolutePositionX,
iAbsolutePositionY);
}
else
{
gtk_window_unstick (GTK_WINDOW (pDesklet->container.pWidget));
if (g_desktopGeometry.iNbViewportX > 0 && g_desktopGeometry.iNbViewportY > 0)
{
int iNumDesktop, iNumViewportX, iNumViewportY;
iNumDesktop = pAttribute->iNumDesktop / (g_desktopGeometry.iNbViewportX * g_desktopGeometry.iNbViewportY);
int index2 = pAttribute->iNumDesktop % (g_desktopGeometry.iNbViewportX * g_desktopGeometry.iNbViewportY);
iNumViewportX = index2 / g_desktopGeometry.iNbViewportY;
iNumViewportY = index2 % g_desktopGeometry.iNbViewportY;
int iCurrentDesktop, iCurrentViewportX, iCurrentViewportY;
gldi_desktop_get_current (&iCurrentDesktop, &iCurrentViewportX, &iCurrentViewportY);
cd_debug (">>> on fixe le desklet sur le bureau (%d,%d,%d) (cur : %d,%d,%d)", iNumDesktop, iNumViewportX, iNumViewportY, iCurrentDesktop, iCurrentViewportX, iCurrentViewportY);
iNumViewportX -= iCurrentViewportX;
iNumViewportY -= iCurrentViewportY;
cd_debug ("on le place en %d + %d", iNumViewportX * gldi_desktop_get_width(), iAbsolutePositionX);
gldi_container_move (CAIRO_CONTAINER (pDesklet), iNumDesktop, iNumViewportX * gldi_desktop_get_width() + iAbsolutePositionX, iNumViewportY * gldi_desktop_get_height() + iAbsolutePositionY);
}
}
pDesklet->bPositionLocked = pAttribute->bPositionLocked;
pDesklet->bNoInput = pAttribute->bNoInput;
pDesklet->fRotation = pAttribute->iRotation / 180. * G_PI ;
pDesklet->fDepthRotationY = pAttribute->iDepthRotationY / 180. * G_PI ;
pDesklet->fDepthRotationX = pAttribute->iDepthRotationX / 180. * G_PI ;
g_free (pDesklet->cDecorationTheme);
pDesklet->cDecorationTheme = pAttribute->cDecorationTheme;
pAttribute->cDecorationTheme = NULL;
gldi_desklet_decoration_free (pDesklet->pUserDecoration);
pDesklet->pUserDecoration = pAttribute->pUserDecoration;
pAttribute->pUserDecoration = NULL;
gldi_desklet_set_accessibility (pDesklet, pAttribute->iVisibility, FALSE);
//cd_debug ("%s (%dx%d ; %d)", __func__, pDesklet->iDesiredWidth, pDesklet->iDesiredHeight, pDesklet->iSidWriteSize);
if (pDesklet->iDesiredWidth == 0 && pDesklet->iDesiredHeight == 0 && pDesklet->iSidWriteSize == 0)
{
gldi_desklet_load_desklet_decorations (pDesklet);
}
}
/* Preferences Callback : Apply to existing notes. */
void preferences_apply_cb(GConfClient *client, guint cnxn_id, GConfEntry *entry, gpointer data)
{
GList *l;
StickyNote *note;
if (!strcmp (entry->key, GCONF_PATH "/settings/sticky"))
{
if (gconf_value_get_bool(entry->value))
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
gtk_window_stick (GTK_WINDOW (note->w_window));
}
else
for (l= stickynotes->notes; l; l = l->next)
{
note = l->data;
gtk_window_unstick (GTK_WINDOW (
note->w_window));
}
}
else if (!strcmp (entry->key, GCONF_PATH "/settings/locked"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_locked (note,
gconf_value_get_bool (entry->value));
}
stickynotes_save();
}
else if (!strcmp (entry->key,
GCONF_PATH "/settings/use_system_color") ||
!strcmp (entry->key, GCONF_PATH "/defaults/color"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_color (note,
note->color, note->font_color,
FALSE);
}
}
else if (!strcmp (entry->key, GCONF_PATH "/settings/use_system_font") ||
!strcmp (entry->key, GCONF_PATH "/defaults/font"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_font (note, note->font, FALSE);
}
}
else if (!strcmp (entry->key, GCONF_PATH "/settings/force_default"))
{
for (l = stickynotes->notes; l; l = l->next)
{
note = l->data;
stickynote_set_color(note,
note->color, note->font_color,
FALSE);
stickynote_set_font(note, note->font, FALSE);
}
}
stickynotes_applet_update_prefs();
stickynotes_applet_update_menus();
}
