static void set_geometry_hints(void)
{
GdkGeometry geometry;
geometry.min_width = -1;
geometry.min_height = -1;
geometry.max_width = -1;
geometry.max_height = -1;
/* Use window geometry to force the window to be as large as the
screen */
if (window_docked)
geometry.max_width = geometry.min_width = screen_width;
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geometry,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
trace("%dx%d", geometry.min_width, geometry.min_height);
#ifdef WINDOW_GRAVITY
/* In some bright and sunny alternate universe when specifications are
actually implemented as inteded, this function alone would cause the
window frame to expand upwards without having to perform the ugly
hack in window_configure(). */
geometry.win_gravity = GDK_GRAVITY_SOUTH_WEST;
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geometry,
GDK_HINT_WIN_GRAVITY);
#endif
}
static void
char_size_realized(GtkWidget *widget, gpointer data)
{
VteTerminal *terminal;
GtkWindow *window;
GdkGeometry geometry;
guint width, height;
GtkBorder *inner_border;
g_assert(GTK_IS_WINDOW(data));
g_assert(VTE_IS_TERMINAL(widget));
terminal = VTE_TERMINAL(widget);
window = GTK_WINDOW(data);
if (!GTK_WIDGET_REALIZED (window))
return;
gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
width = vte_terminal_get_char_width (terminal);
height = vte_terminal_get_char_height (terminal);
geometry.width_inc = width;
geometry.height_inc = height;
geometry.base_width = inner_border ? (inner_border->left + inner_border->right) : 0;
geometry.base_height = inner_border ? (inner_border->top + inner_border->bottom) : 0;
geometry.min_width = geometry.base_width + width * 2;
geometry.min_height = geometry.base_height + height * 2;
gtk_border_free (inner_border);
gtk_window_set_geometry_hints(window, widget, &geometry,
GDK_HINT_RESIZE_INC |
GDK_HINT_BASE_SIZE |
GDK_HINT_MIN_SIZE);
}
static void gtkDialogSetMinMax(Ihandle* ih, int min_w, int min_h, int max_w, int max_h)
{
/* The minmax size restricts the client area */
GdkGeometry geometry;
int decorwidth = 0, decorheight = 0;
iupDialogGetDecorSize(ih, &decorwidth, &decorheight);
geometry.min_width = 1;
if (min_w > decorwidth)
geometry.min_width = min_w-decorwidth;
geometry.min_height = 1;
if (min_h > decorheight)
geometry.min_height = min_h-decorheight;
geometry.max_width = 65535;
if (max_w > decorwidth && max_w > geometry.min_width)
geometry.max_width = max_w-decorwidth;
geometry.max_height = 65535;
if (max_h > decorheight && max_w > geometry.min_height)
geometry.max_height = max_h-decorheight;
/* must set both at the same time, or GTK will assume its default */
gtk_window_set_geometry_hints((GtkWindow*)ih->handle, ih->handle,
&geometry, (GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
}
static void termit_set_fonts()
{
gint page_num = gtk_notebook_get_n_pages(GTK_NOTEBOOK(termit.notebook));
gint minWidth = 0, minHeight = 0;
gint i=0;
for (; i<page_num; ++i) {
TERMIT_GET_TAB_BY_INDEX(pTab, i);
vte_terminal_set_font(VTE_TERMINAL(pTab->vte), pTab->style.font);
GtkBorder* border;
gtk_widget_style_get(GTK_WIDGET(pTab->vte), "inner-border", &border, NULL);
gint w = vte_terminal_get_char_width(VTE_TERMINAL(pTab->vte)) * configs.cols + border->left + border->right;
if (w > minWidth)
minWidth = w;
gint h = vte_terminal_get_char_height(VTE_TERMINAL(pTab->vte)) * configs.rows + border->top + border->bottom;
if (h > minHeight)
minHeight = h;
}
gint oldWidth, oldHeight;
gtk_window_get_size(GTK_WINDOW(termit.main_window), &oldWidth, &oldHeight);
gint width = (minWidth > oldWidth) ? minWidth : oldWidth;
gint height = (minHeight > oldHeight) ? minHeight : oldHeight;
gtk_window_resize(GTK_WINDOW(termit.main_window), width, height);
GdkGeometry geom;
geom.min_width = minWidth;
geom.min_height = minHeight;
TRACE("width=%d height=%d", width, height);
TRACE("minWidth=%d minHeight=%d", minWidth, minHeight);
gtk_window_set_geometry_hints(GTK_WINDOW(termit.main_window), termit.main_window, &geom, GDK_HINT_MIN_SIZE);
}
gboolean
rookie_misc_run_confirm_dialog (const gchar * title,
const gchar * message,
const gchar * ok_button,
GtkWindow * modal)
{
GtkWidget * dialog = gtk_message_dialog_new_with_markup (
modal,
GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_NONE,
"<b>%s</b>\n\n%s",
title,
message);
gtk_dialog_add_buttons (GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
ok_button, GTK_RESPONSE_OK, NULL);
gtk_window_set_geometry_hints (GTK_WINDOW (dialog),
dialog, NULL,
GDK_HINT_USER_SIZE | GDK_HINT_USER_POS);
gtk_widget_set_size_request (dialog, 400, 40);
int response = gtk_dialog_run (GTK_DIALOG(dialog));
gtk_widget_destroy (dialog);
return response == GTK_RESPONSE_OK;
}
static gboolean
gimp_dialog_factory_set_user_pos (GtkWidget *dialog,
GdkEventConfigure *cevent,
gpointer data)
{
GdkWindowHints geometry_mask;
#ifdef DEBUG_FACTORY
GimpDialogFactoryEntry *entry;
gimp_dialog_factory_from_widget (dialog, &entry);
if (entry)
g_print ("%s: setting GDK_HINT_USER_POS for \"%s\"\n",
G_STRFUNC, entry->identifier);
#endif /* DEBUG_FACTORY */
g_signal_handlers_disconnect_by_func (dialog,
gimp_dialog_factory_set_user_pos,
data);
geometry_mask = GDK_HINT_USER_POS;
if (gimp_dialog_factory_get_has_min_size (GTK_WINDOW (dialog)))
geometry_mask |= GDK_HINT_MIN_SIZE;
gtk_window_set_geometry_hints (GTK_WINDOW (dialog), NULL, NULL,
geometry_mask);
return FALSE;
}
widget_t *
widget_window(widget_t *w)
{
w->index = luaH_window_index;
w->newindex = luaH_window_newindex;
w->destructor = widget_destructor;
/* create and setup window widget */
w->widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_object_set_data(G_OBJECT(w->widget), "lua_widget", (gpointer) w);
gtk_window_set_wmclass(GTK_WINDOW(w->widget), "luakit", "luakit");
gtk_window_set_default_size(GTK_WINDOW(w->widget), 800, 600);
gtk_window_set_title(GTK_WINDOW(w->widget), "luakit");
GdkGeometry hints;
hints.min_width = 1;
hints.min_height = 1;
gtk_window_set_geometry_hints(GTK_WINDOW(w->widget), NULL, &hints, GDK_HINT_MIN_SIZE);
g_object_connect(G_OBJECT(w->widget),
"signal::add", G_CALLBACK(add_cb), w,
"signal::destroy", G_CALLBACK(destroy_cb), w,
"signal::key-press-event", G_CALLBACK(key_press_cb), w,
"signal::remove", G_CALLBACK(remove_cb), w,
NULL);
/* add to global windows list */
g_ptr_array_add(globalconf.windows, w);
return w;
}
static void
toggle_aspect_ratio (GSimpleAction *action,
GVariant *parameter,
gpointer data)
{
GtkWidget *window;
GdkGeometry geom;
GtkWidget *widget = GTK_WIDGET (data);
if (aspect_on)
{
geom.min_aspect = 0;
geom.max_aspect = 65535;
}
else
{
geom.min_aspect = 1.777778;
geom.max_aspect = 1.777778;
}
aspect_on = !aspect_on;
window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
if (window)
gtk_window_set_geometry_hints (GTK_WINDOW (window),
GTK_WIDGET (data),
&geom,
GDK_HINT_ASPECT);
}
static void
term_char_size_changed (VteTerminal *vtterm,
guint width,
guint height,
gpointer userdata)
{
GdkGeometry geometry;
geometry.height_inc = height;
geometry.width_inc = width;
GtkBorder padding;
gtk_style_context_get_padding (gtk_widget_get_style_context (GTK_WIDGET (vtterm)),
gtk_widget_get_state_flags (GTK_WIDGET (vtterm)),
&padding);
geometry.base_height = padding.top + padding.bottom;
geometry.base_width = padding.left + padding.right;
geometry.min_height = geometry.base_height + 3 * geometry.height_inc;
geometry.min_width = geometry.base_width + 10 * geometry.width_inc;
gtk_window_set_geometry_hints (GTK_WINDOW (userdata),
GTK_WIDGET (vtterm),
&geometry,
GDK_HINT_MIN_SIZE |
GDK_HINT_BASE_SIZE |
GDK_HINT_RESIZE_INC);
gtk_widget_queue_resize (GTK_WIDGET (vtterm));
}
static void gtkDialogLayoutUpdateMethod(Ihandle *ih)
{
int border, caption, menu;
int width, height;
if (ih->data->ignore_resize ||
iupAttribGet(ih, "_IUPGTK_FS_STYLE"))
return;
/* for dialogs the position is not updated here */
ih->data->ignore_resize = 1;
iupdrvDialogGetDecoration(ih, &border, &caption, &menu);
/* set size excluding the border */
width = ih->currentwidth - 2*border;
height = ih->currentheight - 2*border - caption; /* menu is inside the client area. */
gtk_window_resize((GtkWindow*)ih->handle, width, height);
if (!iupAttribGetBoolean(ih, "RESIZE"))
{
GdkGeometry geometry;
geometry.min_width = width;
geometry.min_height = height;
geometry.max_width = width;
geometry.max_height = height;
gtk_window_set_geometry_hints((GtkWindow*)ih->handle, ih->handle,
&geometry, (GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
}
ih->data->ignore_resize = 0;
}
Win*
win_create(void) {
Win *w;
GdkGeometry g;
GtkPolicyType h, v;
w = emalloc(sizeof(Win));
w->win = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
w->scroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
w->web = WEBKIT_WEB_VIEW(webkit_web_view_new());
w->ignore = w->zoom = FALSE;
g.min_width = g.min_height = 1;
data.wins = g_list_append(data.wins, w);
webkit_web_view_set_full_content_zoom(w->web, TRUE);
webkit_web_view_set_zoom_level(w->web, ZOOM);
gtk_window_set_geometry_hints(w->win, NULL, &g, GDK_HINT_MIN_SIZE);
gtk_window_set_default_size(w->win, WIDTH, HEIGHT);
gtk_container_add(GTK_CONTAINER(w->scroll), GTK_WIDGET(w->web));
gtk_container_add(GTK_CONTAINER(w->win), GTK_WIDGET(w->scroll));
gtk_widget_show_all(GTK_WIDGET(w->win));
gdk_window_set_events(GWIN(w), GDK_PROPERTY_CHANGE_MASK);
gdk_window_add_filter(GWIN(w), atom_propertynotify, w);
event_init(w);
h = SHOW_HSCROLL ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER;
v = SHOW_VSCROLL ? GTK_POLICY_AUTOMATIC : GTK_POLICY_NEVER;
gtk_scrolled_window_set_policy(w->scroll, h, v);
gtk_widget_grab_focus(GTK_WIDGET(w->web));
return w;
}
void _HYPlatformWindow::_SetContentSize (int w, int h)
{
if (hScroll == nil)
return;
_HYWindow* theParent = (_HYWindow*)this;
int windowW = windowContent->allocation.width,
windowH = windowContent->allocation.height;
GdkGeometry windowG;
windowG.max_width = w+vScroll->allocation.width;
windowG.max_height = h+hScroll->allocation.height+(windowMB?windowMB->allocation.height:0);
gtk_window_set_geometry_hints (GTK_WINDOW(theWindow), NULL, &windowG, (GdkWindowHints)(GDK_HINT_MAX_SIZE));
//printf ("Window Size Allocation %d %d %d\n", windowG.max_width, windowG.max_height, windowMB->allocation.height);
gtk_widget_set_sensitive(hScroll,w>windowW);
AdjustScroller (hScroll, windowW, w);
gtk_widget_set_sensitive(vScroll,h>windowH);
AdjustScroller (vScroll, windowH, h);
}
static GtkWidget *CreateURLDialog(void)
{
GtkWidget *vbox1;
GtkWidget *hbox1;
GtkWidget *hbuttonbox1;
GtkWidget *Ok;
GtkWidget *Cancel;
GtkAccelGroup *accel_group;
GdkGeometry geometry;
accel_group = gtk_accel_group_new();
URLDialog = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_usize(URLDialog, 384, -1);
gtk_window_set_title(GTK_WINDOW(URLDialog), MSGTR_Network);
gtk_window_set_position(GTK_WINDOW(URLDialog), GTK_WIN_POS_CENTER);
gtk_window_set_wmclass(GTK_WINDOW(URLDialog), "Network", MPlayer);
gtk_widget_realize(URLDialog);
gtkAddIcon(URLDialog);
vbox1 = gtkAddVBox(gtkAddDialogFrame(URLDialog), 0);
hbox1 = gtkAddHBox(vbox1, 1);
gtkAddLabel("URL: ", hbox1);
urlCombo = gtkAddCombo(hbox1);
/*
* gtk_combo_new();
* gtk_widget_show( urlCombo );
* gtk_box_pack_start( GTK_BOX( hbox1 ),urlCombo,TRUE,TRUE,0 );
*/
urlEntry = GTK_COMBO(urlCombo)->entry;
gtk_widget_show(urlEntry);
gtkAddHSeparator(vbox1);
hbuttonbox1 = gtkAddHButtonBox(vbox1);
gtk_button_box_set_layout(GTK_BUTTON_BOX(hbuttonbox1), GTK_BUTTONBOX_END);
gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbuttonbox1), 10);
Ok = gtkAddButton(MSGTR_Ok, hbuttonbox1);
Cancel = gtkAddButton(MSGTR_Cancel, hbuttonbox1);
geometry.max_width = gdk_screen_get_width(gtk_widget_get_screen(URLDialog));
geometry.max_height = -1;
gtk_window_set_geometry_hints(GTK_WINDOW(URLDialog), NULL, &geometry, GDK_HINT_MAX_SIZE);
gtk_widget_add_accelerator(Ok, "clicked", accel_group, GDK_Return, 0, GTK_ACCEL_VISIBLE);
gtk_widget_add_accelerator(Cancel, "clicked", accel_group, GDK_Escape, 0, GTK_ACCEL_VISIBLE);
gtk_signal_connect(GTK_OBJECT(URLDialog), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &URLDialog);
gtk_signal_connect(GTK_OBJECT(Ok), "clicked", GTK_SIGNAL_FUNC(button_clicked), Ok);
gtk_signal_connect(GTK_OBJECT(Cancel), "clicked", GTK_SIGNAL_FUNC(button_clicked), NULL);
gtk_widget_grab_focus(urlEntry);
gtk_window_add_accel_group(GTK_WINDOW(URLDialog), accel_group);
return URLDialog;
}
void SetDialogStrict(Gtk::Dialog& dlg, int min_wdh, int min_hgt, bool set_resizable)
{
dlg.set_resizable(set_resizable); // чтоб при закрытии экспандера диалог уменьшался
// размер окна пошире
GdkGeometry geom;
geom.min_width = min_wdh;
geom.min_height = min_hgt;
gtk_window_set_geometry_hints(static_cast<Gtk::Window&>(dlg).gobj(), 0, &geom, GDK_HINT_MIN_SIZE);
}
void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
int maxW, int maxH,
int incW, int incH )
{
base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
m_incWidth = incW;
m_incHeight = incH;
const wxSize minSize = GetMinSize();
const wxSize maxSize = GetMaxSize();
GdkGeometry hints;
// always set both min and max hints, otherwise GTK will
// make assumptions we don't want about the unset values
int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
hints.min_width = 1;
hints.min_height = 1;
hints.max_width = INT_MAX;
hints.max_height = INT_MAX;
int decorSize_x;
int decorSize_y;
#ifdef HAS_CLIENT_DECOR
if (HasClientDecor(m_widget))
{
decorSize_x = 0;
decorSize_y = 0;
}
else
#endif
{
decorSize_x = m_decorSize.left + m_decorSize.right;
decorSize_y = m_decorSize.top + m_decorSize.bottom;
}
if (minSize.x > decorSize_x)
hints.min_width = minSize.x - decorSize_x;
if (minSize.y > decorSize_y)
hints.min_height = minSize.y - decorSize_y;
if (maxSize.x > 0)
{
hints.max_width = maxSize.x - decorSize_x;
if (hints.max_width < hints.min_width)
hints.max_width = hints.min_width;
}
if (maxSize.y > 0)
{
hints.max_height = maxSize.y - decorSize_y;
if (hints.max_height < hints.min_height)
hints.max_height = hints.min_height;
}
if (incW > 0 || incH > 0)
{
hints_mask |= GDK_HINT_RESIZE_INC;
hints.width_inc = incW > 0 ? incW : 1;
hints.height_inc = incH > 0 ? incH : 1;
}
gtk_window_set_geometry_hints(
(GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
}
// set the window hints information
void window_resizable(GtkWidget *window, GtkWidget *vte, gint set_hints_inc)
{
#ifdef DEFENSIVE
if ((window==NULL) || (vte==NULL)) return;
#endif
#ifdef DETAIL
g_debug("! Launch window_resizable() with window = %p, vte = %p, set_hints_inc = %d",
window, vte, set_hints_inc);
#endif
// DIRTY HACK: don't run window_resizable too much times before window is shown!
if ((set_hints_inc != 1) && (gtk_widget_get_mapped(window) == FALSE)) return;
// vte=NULL when creating a new root window with drag & drop.
// if (vte==NULL) return;
GdkGeometry hints = {0};
// g_debug("Trying to get padding...");
vte_terminal_get_padding (VTE_TERMINAL(vte), &(hints.base_width), &(hints.base_height));
// g_debug("hints.base_width = %d, hints.base_height = %d", hints.base_width, hints.base_height);
switch (set_hints_inc)
{
case 1:
hints.width_inc = vte_terminal_get_char_width(VTE_TERMINAL(vte));
hints.height_inc = vte_terminal_get_char_height(VTE_TERMINAL(vte));
break;
case 2:
hints.width_inc = 1;
hints.height_inc = 1;
break;
}
// g_debug("hints.width_inc = %d, hints.height_inc = %d",
// hints.width_inc, hints.height_inc);
// // minsize = -1: the size of vte can NOT be changed.
// if (minsize == -1)
// {
// hints.min_width = minsize;
// hints.min_height = minsize;
// }
// else
// {
hints.min_width = hints.base_width + hints.width_inc;
hints.min_height = hints.base_height + hints.height_inc;
// }
// g_debug("Tring to set geometry on %p, and set_hints_inc = %d", vte, set_hints_inc);
gtk_window_set_geometry_hints (GTK_WINDOW (window), GTK_WIDGET (vte), &hints,
GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE);
//g_debug("current the size of vte %p whith hinting = %ld x %ld",
// vte,
// vte_terminal_get_column_count(VTE_TERMINAL(vte)),
// vte_terminal_get_row_count(VTE_TERMINAL(vte)));
}
static IncProgressDialog *inc_progress_dialog_create(gboolean autocheck)
{
IncProgressDialog *dialog;
ProgressDialog *progress;
static GdkGeometry geometry;
dialog = g_new0(IncProgressDialog, 1);
progress = progress_dialog_create();
gtk_window_set_title(GTK_WINDOW(progress->window),
_("Retrieving new messages"));
g_signal_connect(G_OBJECT(progress->showlog_btn), "clicked",
G_CALLBACK(inc_showlog_cb), dialog);
g_signal_connect(G_OBJECT(progress->cancel_btn), "clicked",
G_CALLBACK(inc_cancel_cb), dialog);
g_signal_connect(G_OBJECT(progress->window), "delete_event",
G_CALLBACK(inc_dialog_delete_cb), dialog);
g_signal_connect(G_OBJECT(progress->window), "size_allocate",
G_CALLBACK(inc_progress_dialog_size_allocate_cb), NULL);
/* manage_window_set_transient(GTK_WINDOW(progress->window)); */
progress_dialog_get_fraction(progress);
stock_pixbuf_gdk(progress->treeview, STOCK_PIXMAP_COMPLETE,
&okpix);
stock_pixbuf_gdk(progress->treeview, STOCK_PIXMAP_CONTINUE,
¤tpix);
stock_pixbuf_gdk(progress->treeview, STOCK_PIXMAP_ERROR,
&errorpix);
if (!geometry.min_height) {
geometry.min_width = 460;
geometry.min_height = 250;
}
gtk_window_set_geometry_hints(GTK_WINDOW(progress->window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
gtk_widget_set_size_request(progress->window, prefs_common.receivewin_width,
prefs_common.receivewin_height);
if (prefs_common.recv_dialog_mode == RECV_DIALOG_ALWAYS ||
(prefs_common.recv_dialog_mode == RECV_DIALOG_MANUAL &&
!autocheck)) {
dialog->show_dialog = TRUE;
gtk_widget_show_now(progress->window);
}
dialog->dialog = progress;
g_get_current_time(&dialog->progress_tv);
g_get_current_time(&dialog->folder_tv);
dialog->queue_list = NULL;
dialog->cur_row = 0;
inc_dialog_list = g_list_append(inc_dialog_list, dialog);
return dialog;
}
void
gtk_utils_make_window_only_horizontally_resizable (GtkWindow *window)
{
GdkGeometry geometry;
g_return_if_fail (GTK_IS_WINDOW (window));
geometry.max_width = G_MAXINT;
geometry.max_height = -1;
gtk_window_set_geometry_hints (window, NULL, &geometry, GDK_HINT_MAX_SIZE);
}
void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
int maxW, int maxH,
int incW, int incH )
{
wxTopLevelWindowBase::DoSetSizeHints( minW, minH, maxW, maxH, incW, incH );
if (m_widget)
{
int minWidth = GetMinWidth(),
minHeight = GetMinHeight(),
maxWidth = GetMaxWidth(),
maxHeight = GetMaxHeight();
// set size hints
gint flag = 0; // GDK_HINT_POS;
GdkGeometry geom;
if ((minWidth != -1) || (minHeight != -1)) flag |= GDK_HINT_MIN_SIZE;
if ((maxWidth != -1) || (maxHeight != -1)) flag |= GDK_HINT_MAX_SIZE;
geom.min_width = minWidth;
geom.min_height = minHeight;
// Because of the way we set GDK_HINT_MAX_SIZE above, if either of
// maxHeight or maxWidth is set, we must set them both, else the
// remaining -1 will be taken literally.
// I'm certain this also happens elsewhere, and is the probable
// cause of other such things as:
// Gtk-WARNING **: gtk_widget_size_allocate():
// attempt to allocate widget with width 65535 and height 600
// but I don't have time to track them all now..
//
// Really we need to encapulate all this height/width business and
// stop any old method from ripping at the members directly and
// scattering -1's without regard for who might resolve them later.
geom.max_width = ( maxHeight == -1 ) ? maxWidth
: ( maxWidth == -1 ) ? wxGetDisplaySize().GetWidth()
: maxWidth ;
geom.max_height = ( maxWidth == -1 ) ? maxHeight // ( == -1 here )
: ( maxHeight == -1 ) ? wxGetDisplaySize().GetHeight()
: maxHeight ;
gtk_window_set_geometry_hints( GTK_WINDOW(m_widget),
(GtkWidget*) NULL,
&geom,
(GdkWindowHints) flag );
}
}
static void
hippo_window_gtk_set_resizable(HippoWindow *window,
HippoOrientation orientation,
gboolean value)
{
HippoWindowGtk *window_gtk = HIPPO_WINDOW_GTK(window);
value = value != FALSE;
if (orientation == HIPPO_ORIENTATION_VERTICAL) {
if (window_gtk->vresizable == value)
return;
window_gtk->vresizable = value;
} else {
if (window_gtk->hresizable == value)
return;
window_gtk->hresizable = value;
}
if (window_gtk->hresizable || window_gtk->vresizable) {
GdkGeometry geometry;
gtk_window_set_resizable(GTK_WINDOW(window_gtk), TRUE);
/* -1 = size request */
geometry.min_width = -1;
geometry.min_height = -1;
geometry.max_width = window_gtk->hresizable ? G_MAXSHORT : -1;
geometry.max_height = window_gtk->vresizable ? G_MAXSHORT : -1;
gtk_window_set_geometry_hints(GTK_WINDOW (window), NULL,
&geometry,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
} else {
gtk_window_set_resizable(GTK_WINDOW(window_gtk), FALSE);
gtk_window_set_geometry_hints(GTK_WINDOW(window_gtk), NULL, NULL, 0);
}
}
/* used for Profile and Connection details */
GtkTextBuffer *gtkui_details_window(char *title)
{
GtkWidget *dwindow, *dscrolled, *dtextview;
GtkWidget *vbox, *hbox, *button;
GdkGeometry hints;
DEBUG_MSG("gtkui_details_window");
dwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW (dwindow), title);
hints.max_width = 640;
hints.max_height = 480;
gtk_window_set_geometry_hints(GTK_WINDOW (dwindow), dwindow, &hints, GDK_HINT_MAX_SIZE);
gtk_window_set_default_size(GTK_WINDOW (dwindow), 300, 300);
gtk_container_set_border_width(GTK_CONTAINER (dwindow), 5);
gtk_window_set_position(GTK_WINDOW (dwindow), GTK_WIN_POS_CENTER);
g_signal_connect (G_OBJECT (dwindow), "delete_event", G_CALLBACK (gtk_widget_destroy), NULL);
vbox = gtk_vbox_new(FALSE, 5);
gtk_container_add(GTK_CONTAINER (dwindow), vbox);
gtk_widget_show(vbox);
dscrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (dscrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW (dscrolled), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(vbox), dscrolled, TRUE, TRUE, 0);
gtk_widget_show(dscrolled);
dtextview = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW (dtextview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW (dtextview), FALSE);
gtk_container_add(GTK_CONTAINER (dscrolled), dtextview);
gtk_widget_show(dtextview);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
g_signal_connect_swapped(G_OBJECT(button), "clicked", G_CALLBACK(gtk_widget_destroy), dwindow);
gtk_box_pack_end(GTK_BOX(hbox), button, FALSE, FALSE, 0);
gtk_widget_show(button);
gtk_widget_show(dwindow);
return(gtk_text_view_get_buffer(GTK_TEXT_VIEW (dtextview)));
}
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 gint reset_size(gpointer data)
{
GdkGeometry geom;
geom.min_width = GTK_TVPLUG(tv)->width_best/16;
geom.min_height = GTK_TVPLUG(tv)->height_best/16;
geom.width_inc = GTK_TVPLUG(tv)->width_best/16;
geom.height_inc = GTK_TVPLUG(tv)->height_best/16;
geom.max_width = GTK_TVPLUG(tv)->width_best;
geom.max_height = GTK_TVPLUG(tv)->height_best;
geom.min_aspect = geom.max_aspect = GTK_TVPLUG(tv)->height_best / GTK_TVPLUG(tv)->width_best;
gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &geom,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE | GDK_HINT_ASPECT | GDK_HINT_RESIZE_INC);
return FALSE;
}
CAMLprim value ml_gtk_window_set_geometry_hints (
value win, value pos, value min_size, value max_size, value base_size,
value aspect, value resize_inc, value win_gravity, value user_pos,
value user_size, value wid )
{
GdkWindowHints hints = 0;
GdkGeometry geom;
if (pos != Val_unit && Field(pos,0) != Val_unit) hints |= GDK_HINT_POS;
if (min_size != Val_unit) {
hints |= GDK_HINT_MIN_SIZE;
geom.min_width = Int_val (Field(Field(min_size,0),0));
geom.min_height = Int_val (Field(Field(min_size,0),1));
}
if (max_size != Val_unit) {
hints |= GDK_HINT_MAX_SIZE;
geom.max_width = Int_val (Field(Field(max_size,0),0));
geom.max_height = Int_val (Field(Field(max_size,0),1));
}
if (base_size != Val_unit) {
hints |= GDK_HINT_BASE_SIZE;
geom.base_width = Int_val (Field(Field(base_size,0),0));
geom.base_height = Int_val (Field(Field(base_size,0),1));
}
if (aspect != Val_unit) {
hints |= GDK_HINT_ASPECT;
geom.min_aspect = Double_val (Field(Field(aspect,0),0));
geom.max_aspect = Double_val (Field(Field(aspect,0),1));
}
if (resize_inc != Val_unit) {
hints |= GDK_HINT_RESIZE_INC;
geom.width_inc = Int_val (Field(Field(resize_inc,0),0));
geom.height_inc = Int_val (Field(Field(resize_inc,0),1));
}
if (win_gravity != Val_unit) {
hints |= GDK_HINT_WIN_GRAVITY;
geom.win_gravity = Gravity_val (Field(win_gravity,0));
}
if (user_pos != Val_unit && Field(user_pos,0) != Val_unit)
hints |= GDK_HINT_USER_POS;
if (user_size != Val_unit && Field(user_size,0) != Val_unit)
hints |= GDK_HINT_USER_SIZE;
gtk_window_set_geometry_hints (GtkWindow_val(win), GtkWidget_val(wid),
&geom, hints);
return Val_unit;
}
/* Constrain size of the window the window should not shrink beyond
the requisition, and should not grow vertically. */
static void
constrain_size (GtkWidget *win, GtkRequisition *req, gpointer data)
{
static gint width, height;
GdkGeometry geo;
if (req->width == width && req->height == height)
return;
width = req->width;
height = req->height;
geo.min_width = width;
/* This limit is arbitrary, but INT_MAX breaks other things */
geo.max_width = 10000;
geo.min_height = geo.max_height = height;
gtk_window_set_geometry_hints (GTK_WINDOW (win), NULL, &geo,
GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE);
}
bool VideoOverlay::resize( const Size &size ) {
GdkGeometry hints;
hints.min_width = size.w;
hints.min_height = size.h;
hints.width_inc = size.w;
hints.height_inc = size.h;
GdkWindowHints mask = (GdkWindowHints) (GDK_HINT_RESIZE_INC | GDK_HINT_MIN_SIZE );
gtk_window_set_geometry_hints (GTK_WINDOW (_window),
_window,
&hints,
mask);
_rect = size;
return true;
}
void XttGeGtk::set_size( int width, int height)
{
int default_width;
int default_height;
GdkGeometry geometry;
default_width = width + 20;
default_height = height + 20;
gtk_window_resize( GTK_WINDOW(toplevel), default_width, default_height);
// This condition is due to a bug in Reflection X 11.0.5...
if ( !((XNav *)parent_ctx)->gbl.no_graph_ratio) {
geometry.min_aspect = geometry.max_aspect = gdouble(default_width)/default_height;
gtk_window_set_geometry_hints( GTK_WINDOW(toplevel), GTK_WIDGET(toplevel),
&geometry, GDK_HINT_ASPECT);
}
}
void WGeGtk::set_size( int width, int height)
{
int default_width;
int default_height;
GdkGeometry geometry;
default_width = width + 20;
default_height = height + 20;
gtk_window_resize( GTK_WINDOW(toplevel), default_width, default_height);
geometry.min_aspect = geometry.max_aspect = gdouble(default_width)/default_height;
gtk_window_set_geometry_hints( GTK_WINDOW(toplevel), GTK_WIDGET(toplevel),
&geometry, GDK_HINT_ASPECT);
//if ( !scrollbar && !navigator)
// graph->set_default_layout();
}
void winopen(void)
{
GdkGeometry geom;
int defw;
int defh;
geom.min_width = gli_wmarginx * 2 + gli_cellw * 0;
geom.min_height = gli_wmarginy * 2 + gli_cellh * 0;
geom.max_width = gli_wmarginx * 2 + gli_cellw * 255;
geom.max_height = gli_wmarginy * 2 + gli_cellh * 250;
geom.width_inc = gli_cellw;
geom.height_inc = gli_cellh;
defw = gli_wmarginx * 2 + gli_cellw * gli_cols;
defh = gli_wmarginy * 2 + gli_cellh * gli_rows;
frame = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GTK_WIDGET_SET_FLAGS(frame, GTK_CAN_FOCUS);
gtk_widget_set_events(frame, GDK_BUTTON_PRESS_MASK);
gtk_signal_connect(GTK_OBJECT(frame), "button_press_event", onbutton, NULL);
gtk_signal_connect(GTK_OBJECT(frame), "key_press_event", onkeypress, NULL);
gtk_signal_connect(GTK_OBJECT(frame), "destroy", onquit, "WM destroy");
canvas = gtk_drawing_area_new();
gtk_signal_connect(GTK_OBJECT(canvas), "size_allocate", onresize, NULL);
gtk_signal_connect(GTK_OBJECT(canvas), "expose_event", onexpose, NULL);
gtk_container_add(GTK_CONTAINER(frame), canvas);
wintitle();
gtk_window_set_geometry_hints(GTK_WINDOW(frame),
GTK_WIDGET(frame), &geom,
GDK_HINT_MIN_SIZE
| GDK_HINT_MAX_SIZE
/* | GDK_HINT_RESIZE_INC */
);
gtk_window_set_default_size(GTK_WINDOW(frame), defw, defh);
gtk_widget_show(canvas);
gtk_widget_show(frame);
gtk_widget_grab_focus(frame);
}
void wxTopLevelWindowGTK::DoSetSizeHints( int minW, int minH,
int maxW, int maxH,
int incW, int incH )
{
base_type::DoSetSizeHints(minW, minH, maxW, maxH, incW, incH);
m_incWidth = incW;
m_incHeight = incH;
const wxSize minSize = GetMinSize();
const wxSize maxSize = GetMaxSize();
GdkGeometry hints;
// always set both min and max hints, otherwise GTK will
// make assumptions we don't want about the unset values
int hints_mask = GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE;
hints.min_width = 1;
hints.min_height = 1;
hints.max_width = INT_MAX;
hints.max_height = INT_MAX;
if (minSize.x > m_decorSize.x)
hints.min_width = minSize.x - m_decorSize.x;
if (minSize.y > m_decorSize.y)
hints.min_height = minSize.y - m_decorSize.y;
if (maxSize.x > 0)
{
hints.max_width = maxSize.x - m_decorSize.x;
if (hints.max_width < hints.min_width)
hints.max_width = hints.min_width;
}
if (maxSize.y > 0)
{
hints.max_height = maxSize.y - m_decorSize.y;
if (hints.max_height < hints.min_height)
hints.max_height = hints.min_height;
}
if (incW > 0 || incH > 0)
{
hints_mask |= GDK_HINT_RESIZE_INC;
hints.width_inc = incW > 0 ? incW : 1;
hints.height_inc = incH > 0 ? incH : 1;
}
gtk_window_set_geometry_hints(
(GtkWindow*)m_widget, NULL, &hints, (GdkWindowHints)hints_mask);
}
