JNIEXPORT jint JNICALL
Java_org_gnome_gtk_GtkMenuBar_gtk_1menu_1bar_1get_1pack_1direction
(
JNIEnv* env,
jclass cls,
jlong _self
)
{
GtkPackDirection result;
jint _result;
GtkMenuBar* self;
// convert parameter self
self = (GtkMenuBar*) _self;
// call function
result = gtk_menu_bar_get_pack_direction(self);
// cleanup parameter self
// translate return value to JNI type
_result = (jint) result;
// and finally
return _result;
}
gboolean matenu_menu_bar_get_overflown (MatenuMenuBar* self) {
gboolean result;
g_return_val_if_fail (self != NULL, FALSE);
switch (gtk_menu_bar_get_pack_direction ((GtkMenuBar*) self)) {
case GTK_PACK_DIRECTION_TTB:
case GTK_PACK_DIRECTION_BTT:
{
result = ((GtkWidget*) self)->allocation.height < ((GtkWidget*) self)->requisition.height;
return result;
}
default:
{
result = ((GtkWidget*) self)->allocation.width < ((GtkWidget*) self)->requisition.width;
return result;
}
}
}
static gboolean matenu_menu_bar_child_need_overflown_arrow (MatenuMenuBar* self, GtkWidget* child) {
gboolean result = FALSE;
gint lhs;
gint rhs;
GtkAllocation a;
GtkAllocation oa;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (child != NULL, FALSE);
lhs = 0;
rhs = 0;
a = child->allocation;
oa = ((GtkWidget*) self->priv->_overflown_arrow)->allocation;
switch (gtk_menu_bar_get_pack_direction ((GtkMenuBar*) self)) {
case GTK_PACK_DIRECTION_LTR:
{
lhs = a.x + a.width;
rhs = ((GtkWidget*) self)->allocation.width - oa.width;
break;
}
case GTK_PACK_DIRECTION_RTL:
{
lhs = 0 + oa.width;
rhs = a.x;
break;
}
case GTK_PACK_DIRECTION_BTT:
{
lhs = 0 + oa.height;
rhs = a.y;
break;
}
case GTK_PACK_DIRECTION_TTB:
{
lhs = a.y + a.height;
rhs = ((GtkWidget*) self)->allocation.height - oa.height;
break;
}
}
result = lhs > rhs;
return result;
}
static void matenu_menu_bar_real_size_allocate (GtkWidget* base, GdkRectangle* a) {
MatenuMenuBar * self;
gboolean need_reset_bg_pixmap;
gint delta_x;
gint delta_y;
gboolean _tmp0_ = FALSE;
gboolean _tmp1_ = FALSE;
gboolean _tmp2_ = FALSE;
GdkRectangle _tmp3_ = {0};
GdkRectangle oa;
GtkRequisition or = {0};
self = (MatenuMenuBar*) base;
need_reset_bg_pixmap = FALSE;
delta_x = (*a).x - ((GtkWidget*) self)->allocation.x;
delta_y = (*a).y - ((GtkWidget*) self)->allocation.y;
if (delta_x != 0) {
_tmp2_ = TRUE;
} else {
_tmp2_ = delta_y != 0;
}
if (_tmp2_) {
_tmp1_ = TRUE;
} else {
_tmp1_ = (*a).width != ((GtkWidget*) self)->allocation.width;
}
if (_tmp1_) {
_tmp0_ = TRUE;
} else {
_tmp0_ = (*a).height != ((GtkWidget*) self)->allocation.height;
}
if (_tmp0_) {
need_reset_bg_pixmap = TRUE;
}
matenu_menu_bar_get_background (self)->offset_x = matenu_menu_bar_get_background (self)->offset_x + delta_x;
matenu_menu_bar_get_background (self)->offset_y = matenu_menu_bar_get_background (self)->offset_y + delta_y;
GTK_WIDGET_CLASS (matenu_menu_bar_parent_class)->size_allocate ((GtkWidget*) GTK_MENU_BAR (self), a);
oa = (_tmp3_.x = 0, _tmp3_.y = 0, _tmp3_.width = 0, _tmp3_.height = 0, _tmp3_);
gtk_widget_get_child_requisition ((GtkWidget*) self->priv->_overflown_arrow, &or);
switch (gtk_menu_bar_get_pack_direction ((GtkMenuBar*) self)) {
case GTK_PACK_DIRECTION_TTB:
{
oa.height = or.height;
oa.width = (*a).width;
oa.x = 0;
oa.y = (*a).height - oa.height;
break;
}
case GTK_PACK_DIRECTION_BTT:
{
oa.height = or.height;
oa.width = (*a).width;
oa.x = 0;
oa.y = 0;
break;
}
case GTK_PACK_DIRECTION_RTL:
{
oa.height = (*a).height;
oa.width = or.width;
oa.x = 0;
oa.y = 0;
break;
}
default:
{
oa.width = or.width;
oa.height = (*a).height;
oa.x = (*a).width - oa.width;
oa.y = 0;
break;
}
}
gtk_widget_size_allocate ((GtkWidget*) self->priv->_overflown_arrow, &oa);
if (matenu_menu_bar_get_overflown (self)) {
gtk_widget_set_child_visible ((GtkWidget*) self->priv->_overflown_arrow, TRUE);
{
gint i;
i = 0;
{
gboolean _tmp4_;
_tmp4_ = TRUE;
while (TRUE) {
MatenuItem* item;
MatenuItem* _tmp5_;
GtkWidget* child;
if (!_tmp4_) {
i++;
}
_tmp4_ = FALSE;
if (!(i < matenu_shell_get_length ((MatenuShell*) self))) {
break;
}
item = matenu_shell_get_item ((MatenuShell*) self, i);
child = _g_object_ref0 ((_tmp5_ = item, GTK_IS_WIDGET (_tmp5_) ? ((GtkWidget*) _tmp5_) : NULL));
gtk_widget_set_child_visible (child, !matenu_menu_bar_child_need_overflown_arrow (self, child));
_g_object_unref0 (child);
_g_object_unref0 (item);
}
}
}
} else {
gtk_widget_set_child_visible ((GtkWidget*) self->priv->_overflown_arrow, FALSE);
{
gint i;
i = 0;
{
gboolean _tmp6_;
_tmp6_ = TRUE;
while (TRUE) {
MatenuItem* item;
MatenuItem* _tmp7_;
GtkWidget* child;
if (!_tmp6_) {
i++;
}
_tmp6_ = FALSE;
if (!(i < matenu_shell_get_length ((MatenuShell*) self))) {
break;
}
item = matenu_shell_get_item ((MatenuShell*) self, i);
child = _g_object_ref0 ((_tmp7_ = item, GTK_IS_WIDGET (_tmp7_) ? ((GtkWidget*) _tmp7_) : NULL));
gtk_widget_set_child_visible (child, TRUE);
_g_object_unref0 (child);
_g_object_unref0 (item);
}
}
}
}
if (need_reset_bg_pixmap) {
matenu_menu_bar_reset_bg_pixmap (self);
}
}
static void
greeter_menu_bar_size_allocate(GtkWidget* widget, GtkAllocation* allocation)
{
GList* item;
GList* shell_children;
GList* expand_nums = NULL;
guint visible_count = 0, expand_count = 0;
g_return_if_fail(allocation != NULL);
g_return_if_fail(GREETER_IS_MENU_BAR(widget));
gtk_widget_set_allocation(widget, allocation);
GtkPackDirection pack_direction = gtk_menu_bar_get_pack_direction(GTK_MENU_BAR(widget));
g_return_if_fail(pack_direction == GTK_PACK_DIRECTION_LTR || pack_direction == GTK_PACK_DIRECTION_RTL);
shell_children = gtk_container_get_children(GTK_CONTAINER(widget));
for(item = shell_children; item; item = g_list_next(item))
if(gtk_widget_get_visible(item->data))
{
if(gtk_widget_compute_expand(item->data, GTK_ORIENTATION_HORIZONTAL))
{
expand_nums = g_list_prepend(expand_nums, GINT_TO_POINTER(visible_count));
expand_count++;
}
visible_count++;
}
if(gtk_widget_get_realized(widget))
gdk_window_move_resize(gtk_widget_get_window(widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
if(visible_count > 0)
{
GtkAllocation remaining_space;
GtkStyleContext* context = gtk_widget_get_style_context(widget);
GtkStateFlags flags = gtk_widget_get_state_flags(widget);
GtkRequestedSize* requested_sizes = g_newa(GtkRequestedSize, visible_count);
guint border_width = gtk_container_get_border_width(GTK_CONTAINER(widget));
GtkShadowType shadow_type = GTK_SHADOW_OUT;
GtkBorder border;
gint toggle_size;
gtk_style_context_get_padding(context, flags, &border);
gtk_widget_style_get(widget, "shadow-type", &shadow_type, NULL);
remaining_space.x = (border_width + border.left);
remaining_space.y = (border_width + border.top);
remaining_space.width = allocation->width -
2 * border_width - border.left - border.right;
remaining_space.height = allocation->height -
2 * border_width - border.top - border.bottom;
if (shadow_type != GTK_SHADOW_NONE)
{
gtk_style_context_get_border(context, flags, &border);
remaining_space.x += border.left;
remaining_space.y += border.top;
remaining_space.width -= border.left + border.right;
remaining_space.height -= border.top + border.bottom;
}
GtkRequestedSize* request = requested_sizes;
int size = remaining_space.width;
gboolean ltr = (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_LTR) == (pack_direction == GTK_PACK_DIRECTION_LTR);
for(item = shell_children; item; item = g_list_next(item))
{
if (!gtk_widget_get_visible(item->data))
continue;
request->data = item->data;
gtk_widget_get_preferred_width_for_height(item->data, remaining_space.height,
&request->minimum_size,
&request->natural_size);
gtk_menu_item_toggle_size_request(GTK_MENU_ITEM(item->data),
&toggle_size);
request->minimum_size += toggle_size;
request->natural_size += toggle_size;
gtk_menu_item_toggle_size_allocate(GTK_MENU_ITEM(item->data), toggle_size);
size -= request->minimum_size;
request++;
}
size = gtk_distribute_natural_allocation(size, visible_count, requested_sizes);
/* Distribution extra space for widgets with expand=True */
if(size > 0 && expand_nums)
{
expand_nums = g_list_sort_with_data(expand_nums, (GCompareDataFunc)sort_minimal_size,
requested_sizes);
GList* first_item = expand_nums;
gint needed_size = -1;
gint max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].natural_size;
gint total_needed_size = 0;
/* Free space that all widgets need to have the same (max_size) width
* [___max_width___][widget ][widget____ ]
* total_needed_size := [] + [ ] + [ ]
* total_needed_size = [ ]
*/
for(item = g_list_next(expand_nums); item; item = g_list_next(item))
total_needed_size += max_size - requested_sizes[GPOINTER_TO_INT(item->data)].natural_size;
while(first_item)
{
if(size >= total_needed_size)
{
/* total_needed_size is enough for all remaining widgets */
needed_size = max_size + (size - total_needed_size)/expand_count;
break;
}
/* Removing current maximal widget from list */
total_needed_size -= max_size - requested_sizes[GPOINTER_TO_INT(item->data)].natural_size;
first_item = g_list_next(first_item);
if(first_item)
max_size = requested_sizes[GPOINTER_TO_INT(first_item->data)].natural_size;
}
for(item = first_item; item; item = g_list_next(item))
{
request = &requested_sizes[GPOINTER_TO_INT(item->data)];
gint dsize = needed_size - request->natural_size;
if(size < dsize)
dsize = size;
size -= dsize;
request->natural_size += dsize;
}
}
gint i;
for(i = 0; i < visible_count; i++)
{
GtkAllocation child_allocation = remaining_space;
request = &requested_sizes[i];
child_allocation.width = request->natural_size;
remaining_space.width -= request->natural_size;
if (ltr)
remaining_space.x += request->natural_size;
else
child_allocation.x += remaining_space.width;
gtk_widget_size_allocate(request->data, &child_allocation);
}
g_list_free(expand_nums);
}
g_list_free(shell_children);
}
