static AtkStateSet*
gail_window_ref_state_set (AtkObject *accessible)
{
AtkStateSet *state_set;
GtkWidget *widget;
GtkWindow *window;
GdkWindowState state;
state_set = ATK_OBJECT_CLASS (gail_window_parent_class)->ref_state_set (accessible);
widget = GTK_ACCESSIBLE (accessible)->widget;
if (widget == NULL)
return state_set;
window = GTK_WINDOW (widget);
if (window->has_focus)
atk_state_set_add_state (state_set, ATK_STATE_ACTIVE);
if (widget->window)
{
state = gdk_window_get_state (widget->window);
if (state & GDK_WINDOW_STATE_ICONIFIED)
atk_state_set_add_state (state_set, ATK_STATE_ICONIFIED);
}
if (gtk_window_get_modal (window))
atk_state_set_add_state (state_set, ATK_STATE_MODAL);
if (gtk_window_get_resizable (window))
atk_state_set_add_state (state_set, ATK_STATE_RESIZABLE);
return state_set;
}
JNIEXPORT jboolean JNICALL
Java_org_gnome_gtk_GtkWindow_gtk_1window_1get_1resizable
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
gboolean result;
jboolean _result;
GtkWindow* self;
// convert parameter self
self = (GtkWindow*) _self;
// call function
result = gtk_window_get_resizable(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jboolean) result;
// and finally
return _result;
}
void wxTopLevelWindowGTK::DoSetClientSize(int width, int height)
{
base_type::DoSetClientSize(width, height);
// Since client size is being explicitly set, don't change it later
// Has to be done after calling base because it calls SetSize,
// which sets this true
m_deferShowAllowed = false;
if (m_wxwindow)
{
// If window is not resizable or not yet shown, set size request on
// client widget, to make it more likely window will get correct size
// even if our decorations size cache is incorrect (as it will be before
// showing first TLW).
if (!gtk_window_get_resizable(GTK_WINDOW(m_widget)))
{
gtk_widget_set_size_request(m_widget, -1, -1);
gtk_widget_set_size_request(m_wxwindow, m_clientWidth, m_clientHeight);
}
else if (!IsShown())
{
gtk_widget_set_size_request(m_wxwindow, m_clientWidth, m_clientHeight);
// Cancel size request at next idle to allow resizing
g_idle_add_full(G_PRIORITY_LOW, reset_size_request, m_wxwindow, NULL);
}
}
}
bool gMainWindow::isResizable()
{
if (isTopLevel())
return gtk_window_get_resizable(GTK_WINDOW(border));
else
return false;
}
void wxTopLevelWindowGTK::GTKUpdateDecorSize(const DecorSize& decorSize)
{
if (!IsMaximized() && !IsFullScreen())
GetCachedDecorSize() = decorSize;
if (m_updateDecorSize && memcmp(&m_decorSize, &decorSize, sizeof(DecorSize)))
{
m_useCachedClientSize = false;
const wxSize diff(
decorSize.left - m_decorSize.left + decorSize.right - m_decorSize.right,
decorSize.top - m_decorSize.top + decorSize.bottom - m_decorSize.bottom);
m_decorSize = decorSize;
bool resized = false;
if (m_minWidth > 0 || m_minHeight > 0 || m_maxWidth > 0 || m_maxHeight > 0)
{
// update size hints, they depend on m_decorSize
DoSetSizeHints(m_minWidth, m_minHeight, m_maxWidth, m_maxHeight, m_incWidth, m_incHeight);
}
if (m_deferShow)
{
// keep overall size unchanged by shrinking m_widget
int w, h;
GTKDoGetSize(&w, &h);
// but not if size would be less than minimum, it won't take effect
if (w >= m_minWidth - (decorSize.left + decorSize.right) &&
h >= m_minHeight - (decorSize.top + decorSize.bottom))
{
gtk_window_resize(GTK_WINDOW(m_widget), w, h);
if (!gtk_window_get_resizable(GTK_WINDOW(m_widget)))
gtk_widget_set_size_request(GTK_WIDGET(m_widget), w, h);
resized = true;
}
}
if (!resized)
{
// adjust overall size to match change in frame extents
m_width += diff.x;
m_height += diff.y;
if (m_width < 1) m_width = 1;
if (m_height < 1) m_height = 1;
m_clientWidth = 0;
gtk_widget_queue_resize(m_wxwindow);
}
}
if (m_deferShow)
{
// gtk_widget_show() was deferred, do it now
m_deferShow = false;
DoGetClientSize(&m_clientWidth, &m_clientHeight);
wxSizeEvent sizeEvent(GetSize(), GetId());
sizeEvent.SetEventObject(this);
HandleWindowEvent(sizeEvent);
gtk_widget_show(m_widget);
wxShowEvent showEvent(GetId(), true);
showEvent.SetEventObject(this);
HandleWindowEvent(showEvent);
}
}
void wxTopLevelWindowGTK::DoSetSize( int x, int y, int width, int height, int sizeFlags )
{
wxCHECK_RET( m_widget, wxT("invalid frame") );
// deal with the position first
int old_x = m_x;
int old_y = m_y;
if ( !(sizeFlags & wxSIZE_ALLOW_MINUS_ONE) )
{
// -1 means "use existing" unless the flag above is specified
if ( x != -1 )
m_x = x;
if ( y != -1 )
m_y = y;
}
else // wxSIZE_ALLOW_MINUS_ONE
{
m_x = x;
m_y = y;
}
const wxSize oldSize(m_width, m_height);
if (width >= 0)
m_width = width;
if (height >= 0)
m_height = height;
ConstrainSize();
if (m_width < 1) m_width = 1;
if (m_height < 1) m_height = 1;
if ( m_x != old_x || m_y != old_y )
{
gtk_window_move( GTK_WINDOW(m_widget), m_x, m_y );
wxMoveEvent event(wxPoint(m_x, m_y), GetId());
event.SetEventObject(this);
HandleWindowEvent(event);
}
if (m_width != oldSize.x || m_height != oldSize.y)
{
m_deferShowAllowed = true;
m_useCachedClientSize = false;
int w, h;
GTKDoGetSize(&w, &h);
gtk_window_resize(GTK_WINDOW(m_widget), w, h);
if (!gtk_window_get_resizable(GTK_WINDOW(m_widget)))
gtk_widget_set_size_request(GTK_WIDGET(m_widget), w, h);
DoGetClientSize(&m_clientWidth, &m_clientHeight);
wxSizeEvent event(GetSize(), GetId());
event.SetEventObject(this);
HandleWindowEvent(event);
}
}
void af_window_set_height(int height)
{
if (height < 0) return ;
global_set("height", (gpointer)height);
GtkWidget *window = global_get("window");
if (gtk_window_get_resizable(GTK_WINDOW(window))) {
gtk_window_resize(GTK_WINDOW(window), (gint)global_get("width"), (gint)global_get("height"));
} else {
gtk_widget_set_size_request(GTK_WIDGET(window), (gint)global_get("width"), (gint)global_get("height"));
}
}
int af_window_get_height()
{
int width, height;
GtkWidget *window = global_get("window");
if (gtk_window_get_resizable(GTK_WINDOW(window))) {
gtk_window_get_size(GTK_WINDOW(window), &width, &height);
} else {
gtk_widget_get_size_request(window, &width, &height);
}
return height;
}
void
gnomemeeting_window_hide (GtkWidget *w)
{
int x = 0;
int y = 0;
gchar *window_name = NULL;
gchar *conf_key_size = NULL;
gchar *conf_key_position = NULL;
gchar *size = NULL;
gchar *position = NULL;
g_return_if_fail (w != NULL);
window_name = (char *) g_object_get_data (G_OBJECT (w), "window_name");
g_return_if_fail (window_name != NULL);
conf_key_position =
g_strdup_printf ("%s%s/position", USER_INTERFACE_KEY, window_name);
conf_key_size =
g_strdup_printf ("%s%s/size", USER_INTERFACE_KEY, window_name);
/* If the window is visible, save its position and hide the window */
if (gnomemeeting_window_is_visible (w)) {
gtk_window_get_position (GTK_WINDOW (w), &x, &y);
position = g_strdup_printf ("%d,%d", x, y);
gm_conf_set_string (conf_key_position, position);
g_free (position);
if (gtk_window_get_resizable (GTK_WINDOW (w))) {
gtk_window_get_size (GTK_WINDOW (w), &x, &y);
size = g_strdup_printf ("%d,%d", x, y);
gm_conf_set_string (conf_key_size, size);
g_free (size);
}
gnomemeeting_threads_dialog_hide (w);
}
g_free (conf_key_position);
g_free (conf_key_size);
}
void
gm_window_restore (GmWindow *self)
{
int x = 0;
int y = 0;
gchar *size = NULL;
gchar *position = NULL;
gchar **couple = NULL;
g_return_if_fail (g_strcmp0 (self->priv->key, "") && self);
if (gtk_window_get_resizable (GTK_WINDOW (self))) {
size = g_settings_get_string (self->priv->settings, "size");
if (size)
couple = g_strsplit (size, ",", 0);
if (couple && couple [0])
x = atoi (couple [0]);
if (couple && couple [1])
y = atoi (couple [1]);
if (x > 0 && y > 0) {
gtk_window_resize (GTK_WINDOW (self), x, y);
}
g_strfreev (couple);
g_free (size);
}
position = g_settings_get_string (self->priv->settings, "position");
if (position)
couple = g_strsplit (position, ",", 0);
if (couple && couple [0])
x = atoi (couple [0]);
if (couple && couple [1])
y = atoi (couple [1]);
if (x != 0 && y != 0)
gtk_window_move (GTK_WINDOW (self), x, y);
g_strfreev (couple);
couple = NULL;
g_free (position);
}
void
gm_window_save (GmWindow *self)
{
gchar *size = NULL;
gchar *position = NULL;
g_return_if_fail (g_strcmp0 (self->priv->key, "") || self);
position = g_strdup_printf ("%d,%d", self->priv->x, self->priv->y);
g_settings_set_string (self->priv->settings, "position", position);
g_free (position);
if (gtk_window_get_resizable (GTK_WINDOW (self))) {
size = g_strdup_printf ("%d,%d", self->priv->width, self->priv->height);
g_settings_set_string (self->priv->settings, "size", size);
g_free (size);
}
}
static void
gm_window_hide (GtkWidget *w,
G_GNUC_UNUSED gpointer data)
{
GmWindow *self = NULL;
gchar *conf_key_size = NULL;
gchar *conf_key_position = NULL;
gchar *size = NULL;
gchar *position = NULL;
g_return_if_fail (w != NULL);
self = GM_WINDOW (w);
g_return_if_fail (strcmp (self->priv->key, ""));
conf_key_position =
g_strdup_printf ("%s/position", self->priv->key);
conf_key_size =
g_strdup_printf ("%s/size", self->priv->key);
position = g_strdup_printf ("%d,%d", self->priv->x, self->priv->y);
gm_conf_set_string (conf_key_position, position);
g_free (position);
if (gtk_window_get_resizable (GTK_WINDOW (w))) {
size = g_strdup_printf ("%d,%d", self->priv->width, self->priv->height);
gm_conf_set_string (conf_key_size, size);
g_free (size);
}
g_free (conf_key_position);
g_free (conf_key_size);
}
void
gb_window_write_standard_source (GtkWidget * widget,
GbWidgetWriteSourceData * data,
gchar *title_p,
gchar *type_p,
gchar *position_p,
gchar *modal_p,
gchar *default_width_p,
gchar *default_height_p,
gchar *shrink_p,
gchar *grow_p,
gchar *auto_shrink_p,
gchar *wmname_p,
gchar *wmclass_p,
gchar *resizable_p,
gchar *destroy_with_parent_p,
gchar *icon_p)
{
gint type, position, default_width, default_height;
#if 0
gchar *wmname, *wmclass;
#endif
if (title_p)
{
if (GTK_WINDOW (widget)->title
&& strlen (GTK_WINDOW (widget)->title) > 0)
source_add (data, " gtk_window_set_title (GTK_WINDOW (%s), %s);\n",
data->wname,
source_make_string (GTK_WINDOW (widget)->title,
data->use_gettext));
}
if (type_p)
{
type = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
type_p));
if (type != GTK_WINDOW_TOPLEVEL)
{
/* Note: there is no gtk_window_set_type () */
source_add (data, " GTK_WINDOW (%s)->type = %s;\n",
data->wname, GbTypeSymbols[type]);
}
}
if (position_p)
{
position = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
position_p));
if (GbPositionValues[position] != GTK_WIN_POS_NONE)
{
source_add (data,
" gtk_window_set_position (GTK_WINDOW (%s), %s);\n",
data->wname, GbPositionSymbols[position]);
}
}
if (modal_p)
{
if (gtk_object_get_data (GTK_OBJECT (widget), modal_p))
{
source_add (data,
" gtk_window_set_modal (GTK_WINDOW (%s), TRUE);\n",
data->wname);
}
}
if (default_width_p && default_height_p)
{
default_width = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
DefaultWidth));
default_height = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
DefaultHeight));
if (default_width || default_height )
{
source_add (data,
" gtk_window_set_default_size (GTK_WINDOW (%s), %i, %i);\n",
data->wname,
default_width ? default_width : -1,
default_height ? default_height : -1);
}
}
#if 0
if (shrink_p && grow_p)
{
if (GTK_WINDOW (widget)->allow_grow != TRUE
|| GTK_WINDOW (widget)->allow_shrink != FALSE)
source_add (data,
" gtk_window_set_policy (GTK_WINDOW (%s), %s, %s, %s);\n",
data->wname,
GTK_WINDOW (widget)->allow_shrink ? "TRUE" : "FALSE",
GTK_WINDOW (widget)->allow_grow ? "TRUE" : "FALSE",
"FALSE");
}
#endif
#if 0
/* These aren't necessary, and have been used incorrectly for ages. */
if (wmname_p && wmclass_p)
{
wmname = gtk_object_get_data (GTK_OBJECT (widget), wmname_p);
wmclass = gtk_object_get_data (GTK_OBJECT (widget), wmclass_p);
if (wmname || wmclass)
{
source_add (data,
" gtk_window_set_wmclass (GTK_WINDOW (%s), %s,",
data->wname,
wmname ? source_make_string (wmname, FALSE) : "\"\"");
source_add (data, " %s);\n",
wmclass ? source_make_string (wmclass, FALSE) : "\"\"");
}
}
#endif
if (resizable_p)
{
if (!gtk_window_get_resizable (GTK_WINDOW (widget)))
source_add (data,
" gtk_window_set_resizable (GTK_WINDOW (%s), FALSE);\n",
data->wname);
}
if (destroy_with_parent_p)
{
if (gtk_window_get_destroy_with_parent (GTK_WINDOW (widget)))
source_add (data,
" gtk_window_set_destroy_with_parent (GTK_WINDOW (%s), TRUE);\n",
data->wname);
}
if (icon_p)
{
gchar *filename = gtk_object_get_data (GTK_OBJECT (widget), icon_p);
if (filename && *filename)
{
char *pixbuf_name = g_strdup_printf ("%s_icon_pixbuf", data->wname);
source_add_decl (data, " GdkPixbuf *%s;\n", pixbuf_name);
source_create_pixbuf (data, pixbuf_name, filename);
source_add (data,
" if (%s)\n"
" {\n"
" gtk_window_set_icon (GTK_WINDOW (%s), %s);\n"
" gdk_pixbuf_unref (%s);\n"
" }\n",
pixbuf_name,
data->wname, pixbuf_name,
pixbuf_name);
g_free (pixbuf_name);
}
}
}
void
gb_window_get_standard_properties (GtkWidget * widget,
GbWidgetGetArgData * data,
gchar *title_p,
gchar *type_p,
gchar *position_p,
gchar *modal_p,
gchar *default_width_p,
gchar *default_height_p,
gchar *shrink_p,
gchar *grow_p,
gchar *auto_shrink_p,
gchar *wmname_p,
gchar *wmclass_p,
gchar *resizable_p,
gchar *destroy_with_parent_p,
gchar *icon_p)
{
gint type, position, default_width, default_height;
if (title_p)
gb_widget_output_translatable_string (data, title_p,
GTK_WINDOW (widget)->title);
/* The type is stored in the object datalist as we can't change it after the
window is realized. It will default to 0, which is OK. */
if (type_p)
{
type = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
type_p));
gb_widget_output_choice (data, type_p, type, GbTypeSymbols[type]);
}
/* The position is stored in the object datalist so that it doesn't affect
the displaying of the window within Glade. It will default to 0, i.e.
GTK_WIN_POS_NONE, which is OK. */
if (position_p)
{
position = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
position_p));
gb_widget_output_choice (data, position_p, position,
GbPositionSymbols[position]);
}
if (modal_p)
{
gb_widget_output_bool (data, modal_p,
gtk_object_get_data (GTK_OBJECT (widget), modal_p)
!= NULL ? TRUE : FALSE);
}
if (default_width_p && default_height_p)
{
default_width = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
DefaultWidth));
gb_widget_output_optional_int (data, default_width_p, default_width,
default_width != 0 ? TRUE : FALSE);
default_height = GPOINTER_TO_INT (gtk_object_get_data (GTK_OBJECT (widget),
DefaultHeight));
gb_widget_output_optional_int (data, default_height_p, default_height,
default_height != 0 ? TRUE : FALSE);
}
#if 0
/* These are deprecated. */
if (grow_p && shrink_p)
{
gb_widget_output_bool (data, grow_p,
GTK_WINDOW (widget)->allow_grow);
gb_widget_output_bool (data, shrink_p,
GTK_WINDOW (widget)->allow_shrink);
}
#endif
/* These are stored in the object hash since we can't set them after the
window is realized. */
#if 0
/* These aren't necessary, and have been used incorrectly for ages. */
if (wmname_p)
gb_widget_output_string (data, wmname_p,
gtk_object_get_data (GTK_OBJECT (widget),
wmname_p));
if (wmclass_p)
gb_widget_output_string (data, wmclass_p,
gtk_object_get_data (GTK_OBJECT (widget),
wmclass_p));
#endif
if (resizable_p)
gb_widget_output_bool (data, resizable_p,
gtk_window_get_resizable (GTK_WINDOW (widget)));
if (destroy_with_parent_p)
gb_widget_output_bool (data, destroy_with_parent_p,
gtk_window_get_destroy_with_parent (GTK_WINDOW (widget)));
if (icon_p)
gb_widget_output_pixmap_filename (data, icon_p,
gtk_object_get_data (GTK_OBJECT (widget),
icon_p));
}
static int init_setting(GtkWidget * window, GtkWidget * view)
{
gint root_x, root_y;
gint screen_width, screen_height;
/* Setting Window */
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_title(GTK_WINDOW(window), global_get("title"));
gtk_widget_set_size_request(GTK_WIDGET(window), 10, 10);
gtk_window_set_resizable(GTK_WINDOW(window), (gboolean)global_get("resizeable"));
gtk_window_set_decorated(GTK_WINDOW(window), (gboolean)global_get("border"));
if (gtk_window_get_resizable(GTK_WINDOW(window))) {
gtk_window_resize(GTK_WINDOW(window), (gint)global_get("width"), (gint)global_get("height"));
} else {
gtk_widget_set_size_request(GTK_WIDGET(window), (gint)global_get("width"), (gint)global_get("height"));
}
/* Move Window */
screen_get_size(&screen_width, &screen_height);
root_x = (screen_width - (gint)global_get("width")) / 2;
root_y = (screen_height - (gint)global_get("height")) / 2;
if ((gint)global_get("x") != 10000) root_x = (gint)global_get("x");
if ((gint)global_get("y") != 10000) root_y = (gint)global_get("y");
if (root_x < 0) root_x = screen_width + root_x;
if (root_y < 0) root_y = screen_height + root_y;
gtk_window_move(GTK_WINDOW(window), root_x, root_y);
/* Setting Icon */
if (g_file_test(global_get("icon"), G_FILE_TEST_EXISTS)) {
gtk_window_set_icon_from_file(GTK_WINDOW(window), global_get("icon"), NULL);
}
/* Fullscreen */
if ((gboolean)global_get("fullscreen")) af_window_set_fullscreen(TRUE);
g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(af_exit), NULL);
g_signal_connect(G_OBJECT(window), "window-state-event", G_CALLBACK(window_onstatechange), NULL);
/* Setting Webkit */
WebKitWebSettings *setting = webkit_web_view_get_settings (WEBKIT_WEB_VIEW(view));
g_object_set(G_OBJECT(setting), "default-encoding", global_get("encode"), NULL);
g_object_set(G_OBJECT(setting), "enable-webgl", TRUE, NULL);
//g_object_set(G_OBJECT(view), "self-scrolling", TRUE, NULL);
g_object_set(G_OBJECT(setting), "default-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "monospace-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "sans-serif-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "serif-font-family", "SimSun", NULL);
g_object_set(G_OBJECT(setting), "cursive-font-family", "SimSun", NULL);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(view), setting);
g_signal_connect(WEBKIT_WEB_VIEW(view), "window-object-cleared", G_CALLBACK(js_callback), NULL);
g_signal_connect(WEBKIT_WEB_VIEW(view), "close-web-view", G_CALLBACK(webview_onclose), NULL);
return 0;
}
gboolean af_window_get_resizable()
{
GtkWidget *window = global_get("window");
return gtk_window_get_resizable(GTK_WINDOW(window));
}
void
gnomemeeting_window_show (GtkWidget *w)
{
int x = 0;
int y = 0;
gchar *window_name = NULL;
gchar *conf_key_size = NULL;
gchar *conf_key_position = NULL;
gchar *size = NULL;
gchar *position = NULL;
gchar **couple = NULL;
g_return_if_fail (w != NULL);
window_name = (char *) g_object_get_data (G_OBJECT (w), "window_name");
g_return_if_fail (window_name != NULL);
conf_key_position =
g_strdup_printf ("%s%s/position", USER_INTERFACE_KEY, window_name);
conf_key_size =
g_strdup_printf ("%s%s/size", USER_INTERFACE_KEY, window_name);
if (!gnomemeeting_window_is_visible (w)) {
position = gm_conf_get_string (conf_key_position);
if (position)
couple = g_strsplit (position, ",", 0);
if (couple && couple [0])
x = atoi (couple [0]);
if (couple && couple [1])
y = atoi (couple [1]);
if (x != 0 && y != 0)
gtk_window_move (GTK_WINDOW (w), x, y);
g_strfreev (couple);
couple = NULL;
g_free (position);
if (gtk_window_get_resizable (GTK_WINDOW (w))) {
size = gm_conf_get_string (conf_key_size);
if (size)
couple = g_strsplit (size, ",", 0);
if (couple && couple [0])
x = atoi (couple [0]);
if (couple && couple [1])
y = atoi (couple [1]);
if (x > 0 && y > 0)
gtk_window_resize (GTK_WINDOW (w), x, y);
g_strfreev (couple);
g_free (size);
}
gnomemeeting_threads_dialog_show (w);
}
g_free (conf_key_position);
g_free (conf_key_size);
}
static void
gm_window_show (GtkWidget *w,
G_GNUC_UNUSED gpointer data)
{
int x = 0;
int y = 0;
GmWindow *self = NULL;
gchar *conf_key_size = NULL;
gchar *conf_key_position = NULL;
gchar *size = NULL;
gchar *position = NULL;
gchar **couple = NULL;
g_return_if_fail (w != NULL);
self = GM_WINDOW (w);
g_return_if_fail (strcmp (self->priv->key, ""));
conf_key_position =
g_strdup_printf ("%s/position", self->priv->key);
conf_key_size =
g_strdup_printf ("%s/size", self->priv->key);
if (gtk_window_get_resizable (GTK_WINDOW (w))) {
size = gm_conf_get_string (conf_key_size);
if (size)
couple = g_strsplit (size, ",", 0);
if (couple && couple [0])
x = atoi (couple [0]);
if (couple && couple [1])
y = atoi (couple [1]);
if (x > 0 && y > 0) {
gtk_window_resize (GTK_WINDOW (w), x, y);
}
g_strfreev (couple);
g_free (size);
}
position = gm_conf_get_string (conf_key_position);
if (position)
couple = g_strsplit (position, ",", 0);
if (couple && couple [0])
x = atoi (couple [0]);
if (couple && couple [1])
y = atoi (couple [1]);
if (x != 0 && y != 0)
gtk_window_move (GTK_WINDOW (w), x, y);
g_strfreev (couple);
couple = NULL;
g_free (position);
gtk_widget_realize (GTK_WIDGET (w));
g_free (conf_key_position);
g_free (conf_key_size);
}
