ui/gtk/container.c

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright 2017 Olaf Wintermann. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *   1. Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *   2. Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>

#include "container.h"
#include "toolkit.h"
#include "headerbar.h"

#include "../common/context.h"
#include "../common/object.h"

#include "../ui/properties.h"


void ui_container_begin_close(UiObject *obj) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->close = 1;
}

int ui_container_finish(UiObject *obj) {
    UiContainer *ct = uic_get_current_container(obj);
    if(ct->close) {
        ui_end(obj);
        return 0;
    }
    return 1;
}

GtkWidget* ui_gtk_vbox_new(int spacing) {
#if GTK_MAJOR_VERSION >= 3
    return gtk_box_new(GTK_ORIENTATION_VERTICAL, spacing);
#else
    return gtk_vbox_new(FALSE, spacing);
#endif
}

GtkWidget* ui_gtk_hbox_new(int spacing) {
#if GTK_MAJOR_VERSION >= 3
    return gtk_box_new(GTK_ORIENTATION_HORIZONTAL, spacing);
#else
    return gtk_hbox_new(FALSE, spacing);
#endif
}

GtkWidget* ui_subcontainer_create(
        UiSubContainerType type,
        UiObject *newobj,
        int spacing,
        int columnspacing,
        int rowspacing,
        int margin)
{
    GtkWidget *sub = NULL;
    GtkWidget *add = NULL;
    switch(type) {
        default: {
            sub = ui_gtk_vbox_new(spacing);
            add = ui_box_set_margin(sub, margin);
            newobj->container = ui_box_container(newobj, sub, type);
            newobj->widget = sub;
            break;
        }
        case UI_CONTAINER_HBOX: {
            sub = ui_gtk_hbox_new(spacing);
            add = ui_box_set_margin(sub, margin);
            newobj->container = ui_box_container(newobj, sub, type);
            newobj->widget = sub;
            break;
        }
        case UI_CONTAINER_GRID: {
            sub = ui_create_grid_widget(columnspacing, rowspacing);
            add = ui_box_set_margin(sub, margin);
            newobj->container = ui_grid_container(newobj, sub, FALSE, FALSE, FALSE, FALSE);
            newobj->widget = sub;
            break;
        }
        case UI_CONTAINER_NO_SUB: {
            break;
        }
    }
    return add;
}


/* -------------------- Box Container -------------------- */
UiContainer* ui_box_container(UiObject *obj, GtkWidget *box, UiSubContainerType type) {
    UiBoxContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiBoxContainer));
    ct->container.widget = box;
    ct->container.add = ui_box_container_add;
    ct->type = type;
    return (UiContainer*)ct;
}

void ui_box_container_add(UiContainer *ct, GtkWidget *widget) {
    UiBoxContainer *bc = (UiBoxContainer*)ct;
    UiBool fill = ct->layout.fill;
    if(bc->has_fill && fill) {
        fprintf(stderr, "UiError: container has 2 filled widgets");
        fill = FALSE;
    }
    if(fill) {
        bc->has_fill = TRUE;
    }
    
    UiBool expand = fill;
#if GTK_MAJOR_VERSION >= 4
    gtk_box_append(GTK_BOX(ct->widget), widget);
    GtkAlign align = expand ? GTK_ALIGN_FILL : GTK_ALIGN_START; 
    if(bc->type == UI_CONTAINER_VBOX) {
        gtk_widget_set_valign(widget, align);
        gtk_widget_set_vexpand(widget, expand);
        gtk_widget_set_hexpand(widget, TRUE);
    } else if(bc->type == UI_CONTAINER_HBOX) {
        gtk_widget_set_halign(widget, align);
        gtk_widget_set_hexpand(widget, expand);
        gtk_widget_set_vexpand(widget, TRUE);
    }
    
#else
    gtk_box_pack_start(GTK_BOX(ct->widget), widget, expand, fill, 0);
#endif
    
    ui_reset_layout(ct->layout);
    ct->current = widget;
}

UiContainer* ui_grid_container(
        UiObject *obj,
        GtkWidget *grid,
        UiBool def_hexpand,
        UiBool def_vexpand,
        UiBool def_hfill,
        UiBool def_vfill)
{
    UiGridContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiGridContainer));
    ct->def_hexpand = def_hexpand;
    ct->def_vexpand = def_vexpand;
    ct->def_hfill = def_hfill;
    ct->def_vfill = def_vfill;
    ct->container.widget = grid;
    ct->container.add = ui_grid_container_add;
    UI_GTK_V2(ct->width = 0);
    UI_GTK_V2(ct->height = 1);
    return (UiContainer*)ct;
}

#if GTK_MAJOR_VERSION >= 3
void ui_grid_container_add(UiContainer *ct, GtkWidget *widget) {
    UiGridContainer *grid = (UiGridContainer*)ct;
    
    if(ct->layout.newline) {
        grid->x = 0;
        grid->y++;
        ct->layout.newline = FALSE;
    }
    
    int hexpand = FALSE;
    int vexpand = FALSE;
    int hfill = FALSE;
    int vfill = FALSE;
    if(!ct->layout.override_defaults) {
        if(grid->def_hexpand) {
            hexpand = TRUE;
        }
        if(grid->def_hfill) {
            hfill = TRUE;
        }
        if(grid->def_vexpand) {
            vexpand = TRUE;
        }
        if(grid->def_vfill) {
            vfill = TRUE;
        }
    }
    
    UiBool fill = ct->layout.fill;
    if(ct->layout.hexpand) {
        hexpand = TRUE;
    }
    if(ct->layout.hfill) {
        hfill = TRUE;
    }
    if(ct->layout.vexpand) {
        vexpand = TRUE;
    }
    if(ct->layout.vfill) {
        vfill = TRUE;
    }
    if(fill) {
        hfill = TRUE;
        vfill = TRUE;
        hexpand = TRUE;
        vexpand = TRUE;
    }
    
    if(!hfill) {
        gtk_widget_set_halign(widget, GTK_ALIGN_START);
    }
    if(!vfill) {
        gtk_widget_set_valign(widget, GTK_ALIGN_START);
    }
    
    gtk_widget_set_hexpand(widget, hexpand);
    gtk_widget_set_vexpand(widget, vexpand);
    
    int colspan = ct->layout.colspan > 0 ? ct->layout.colspan : 1;
    int rowspan = ct->layout.rowspan > 0 ? ct->layout.rowspan : 1;
    
    gtk_grid_attach(GTK_GRID(ct->widget), widget, grid->x, grid->y, colspan, rowspan);
    grid->x += colspan;
    
    ui_reset_layout(ct->layout);
    ct->current = widget;
}
#endif
#ifdef UI_GTK2
void ui_grid_container_add(UiContainer *ct, GtkWidget *widget) {
    UiGridContainer *grid = (UiGridContainer*)ct;
    
    if(ct->layout.newline) {
        grid->x = 0;
        grid->y++;
        ct->layout.newline = FALSE;
    }
    
    int hexpand = FALSE;
    int vexpand = FALSE;
    int hfill = FALSE;
    int vfill = FALSE;
    if(!ct->layout.override_defaults) {
        if(grid->def_hexpand) {
            hexpand = TRUE;
            hfill = TRUE;
        } else if(grid->def_hfill) {
            hfill = TRUE;
        }
        if(grid->def_vexpand) {
            vexpand = TRUE;
            vfill = TRUE;
        } else if(grid->def_vfill) {
            vfill = TRUE;
        }
    }
    
    UiBool fill = ct->layout.fill;
    if(ct->layout.hexpand) {
        hexpand = TRUE;
        hfill = TRUE;
    } else if(ct->layout.hfill) {
        hfill = TRUE;
    }
    if(ct->layout.vexpand) {
        vexpand = TRUE;
        vfill = TRUE;
    } else if(ct->layout.vfill) {
        vfill = TRUE;
    }
    if(fill) {
        hfill = TRUE;
        vfill = TRUE;
    }
    
    GtkAttachOptions xoptions = 0;
    GtkAttachOptions yoptions = 0;
    if(hexpand) {
        xoptions = GTK_EXPAND;
    }
    if(hfill) {
        xoptions |= GTK_FILL;
    }
    if(vexpand) {
        yoptions = GTK_EXPAND;
    }
    if(vfill) {
        yoptions |= GTK_FILL;
    }
    
    int colspan = ct->layout.colspan > 0 ? ct->layout.colspan : 1;
    int rowspan = ct->layout.rowspan > 0 ? ct->layout.rowspan : 1;
    // TODO: use colspan/rowspan
    
    gtk_table_attach(GTK_TABLE(ct->widget), widget, grid->x, grid->x+1, grid->y, grid->y+1, xoptions, yoptions, 0, 0);
    grid->x++;
    int nw = grid->x > grid->width ? grid->x : grid->width;
    if(grid->x > grid->width || grid->y > grid->height) {
        grid->width = nw;
        grid->height = grid->y + 1;
        gtk_table_resize(GTK_TABLE(ct->widget), grid->width, grid->height);
    }
    
    ui_reset_layout(ct->layout);
    ct->current = widget;
}
#endif

UiContainer* ui_frame_container(UiObject *obj, GtkWidget *frame) {
    UiContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiContainer));
    ct->widget = frame;
    ct->add = ui_frame_container_add;
    return ct;
}

void ui_frame_container_add(UiContainer *ct, GtkWidget *widget) {
    FRAME_SET_CHILD(ct->widget, widget);
}

UiContainer* ui_expander_container(UiObject *obj, GtkWidget *expander) {
    UiContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiContainer));
    ct->widget = expander;
    ct->add = ui_expander_container_add;
    return ct;
}

void ui_expander_container_add(UiContainer *ct, GtkWidget *widget) {
    EXPANDER_SET_CHILD(ct->widget, widget);
}

void ui_scrolledwindow_container_add(UiContainer *ct, GtkWidget *widget) {
    // TODO: check if the widget implements GtkScrollable
    SCROLLEDWINDOW_SET_CHILD(ct->widget, widget);
    ui_reset_layout(ct->layout);
    ct->current = widget;
}

UiContainer* ui_scrolledwindow_container(UiObject *obj, GtkWidget *scrolledwindow) {
    UiContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiContainer));
    ct->widget = scrolledwindow;
    ct->add = ui_scrolledwindow_container_add;
    return ct;
}

UiContainer* ui_tabview_container(UiObject *obj, GtkWidget *tabview) {
    UiTabViewContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiTabViewContainer));
    ct->container.widget = tabview;
    ct->container.add = ui_tabview_container_add;
    return (UiContainer*)ct;
}

void ui_tabview_container_add(UiContainer *ct, GtkWidget *widget) {
    UiGtkTabView *data = ui_widget_get_tabview_data(ct->widget);
    if(!data) {
        fprintf(stderr, "UI Error: widget is not a tabview");
        return;
    }
    data->add_tab(ct->widget, -1, ct->layout.label, widget);
    
    ui_reset_layout(ct->layout);
    ct->current = widget;
}


GtkWidget* ui_box_set_margin(GtkWidget *box, int margin) {
    GtkWidget *ret = box;
#if GTK_MAJOR_VERSION >= 3
#if GTK_MAJOR_VERSION * 1000 + GTK_MINOR_VERSION >= 3012
    gtk_widget_set_margin_start(box, margin);
    gtk_widget_set_margin_end(box, margin);
#else
    gtk_widget_set_margin_left(box, margin);
    gtk_widget_set_margin_right(box, margin);
#endif
    gtk_widget_set_margin_top(box, margin);
    gtk_widget_set_margin_bottom(box, margin);
#elif defined(UI_GTK2)
    GtkWidget *a = gtk_alignment_new(0.5, 0.5, 1, 1);
    gtk_alignment_set_padding(GTK_ALIGNMENT(a), margin, margin, margin, margin);
    gtk_container_add(GTK_CONTAINER(a), box);
    ret = a;
#endif
    return ret;
}

UIWIDGET ui_box_create(UiObject *obj, UiContainerArgs *args, UiSubContainerType type) {
    UiObject *current = uic_current_obj(obj);
    UiContainer *ct = current->container;
    UI_APPLY_LAYOUT2(current, args);
    
    GtkWidget *box = type == UI_CONTAINER_VBOX ? ui_gtk_vbox_new(args->spacing) : ui_gtk_hbox_new(args->spacing);
    ui_set_name_and_style(box, args->name, args->style_class);
    GtkWidget *widget = args->margin > 0 ? ui_box_set_margin(box, args->margin) : box;
    ct->add(ct, widget);
    
    UiObject *newobj = uic_object_new(obj, box);
    newobj->container = ui_box_container(obj, box, type);
    uic_obj_add(obj, newobj);
    
    return widget;
}

UIEXPORT UIWIDGET ui_vbox_create(UiObject *obj, UiContainerArgs *args) {
    return ui_box_create(obj, args, UI_CONTAINER_VBOX);
}

UIEXPORT UIWIDGET ui_hbox_create(UiObject *obj, UiContainerArgs *args) {
    return ui_box_create(obj, args, UI_CONTAINER_HBOX);
}

GtkWidget* ui_create_grid_widget(int colspacing, int rowspacing) {
#if GTK_MAJOR_VERSION >= 3
    GtkWidget *grid = gtk_grid_new();
    gtk_grid_set_column_spacing(GTK_GRID(grid), colspacing);
    gtk_grid_set_row_spacing(GTK_GRID(grid), rowspacing);
#else
    GtkWidget *grid = gtk_table_new(1, 1, FALSE);
    gtk_table_set_col_spacings(GTK_TABLE(grid), colspacing);
    gtk_table_set_row_spacings(GTK_TABLE(grid), rowspacing);
#endif
    return grid;
}

UIWIDGET ui_grid_create(UiObject *obj, UiContainerArgs *args) {
    UiObject* current = uic_current_obj(obj);
    UI_APPLY_LAYOUT2(current, args);
    GtkWidget *widget;
    
    GtkWidget *grid = ui_create_grid_widget(args->columnspacing, args->rowspacing);
    ui_set_name_and_style(grid, args->name, args->style_class);
    widget = ui_box_set_margin(grid, args->margin);
    current->container->add(current->container, widget);
    
    UiObject *newobj = uic_object_new(obj, grid);
    newobj->container = ui_grid_container(obj, grid, args->def_hexpand, args->def_vexpand, args->def_hfill, args->def_vfill);
    uic_obj_add(obj, newobj);
    
    return widget;
}

UIWIDGET ui_frame_create(UiObject *obj, UiFrameArgs *args) {
    UiObject* current = uic_current_obj(obj);
    UI_APPLY_LAYOUT2(current, args);
    
    GtkWidget *frame = gtk_frame_new(args->label);
    UiObject *newobj = uic_object_new(obj, frame);
    GtkWidget *sub = ui_subcontainer_create(args->subcontainer, newobj, args->spacing, args->columnspacing, args->rowspacing, args->margin);
    if(sub) {
        FRAME_SET_CHILD(frame, sub);
    } else {
        newobj->widget = frame;
        newobj->container = ui_frame_container(obj, frame);
    }
    current->container->add(current->container, frame);
    uic_obj_add(obj, newobj);
    
    return frame;
}

UIEXPORT UIWIDGET ui_expander_create(UiObject *obj, UiFrameArgs *args) {
    UiObject* current = uic_current_obj(obj);
    UI_APPLY_LAYOUT2(current, args);
    
    GtkWidget *expander = gtk_expander_new(args->label);
    gtk_expander_set_expanded(GTK_EXPANDER(expander), args->isexpanded);
    UiObject *newobj = uic_object_new(obj, expander);
    GtkWidget *sub = ui_subcontainer_create(args->subcontainer, newobj, args->spacing, args->columnspacing, args->rowspacing, args->margin);
    if(sub) {
        EXPANDER_SET_CHILD(expander, sub);
    } else {
        newobj->widget = expander;
        newobj->container = ui_expander_container(obj, expander);
    }
    current->container->add(current->container, expander);
    uic_obj_add(obj, newobj);
    
    return expander;
}


UIWIDGET ui_scrolledwindow_create(UiObject* obj, UiFrameArgs *args) {
    UiObject* current = uic_current_obj(obj);
    UI_APPLY_LAYOUT2(current, args);
    
    GtkWidget *sw = SCROLLEDWINDOW_NEW();
    ui_set_name_and_style(sw, args->name, args->style_class);
    GtkWidget *widget = ui_box_set_margin(sw, args->margin);
    current->container->add(current->container, widget);
    
    UiObject *newobj = uic_object_new(obj, sw);
    GtkWidget *sub = ui_subcontainer_create(args->subcontainer, newobj, args->spacing, args->columnspacing, args->rowspacing, args->margin);
    if(sub) {
        SCROLLEDWINDOW_SET_CHILD(sw, sub);
    } else {
        newobj->widget = sw;
        newobj->container = ui_scrolledwindow_container(obj, sw);
    }
    
    uic_obj_add(obj, newobj);
    
    return sw;
}


void ui_notebook_tab_select(UIWIDGET tabview, int tab) {
    gtk_notebook_set_current_page(GTK_NOTEBOOK(tabview), tab);
}

void ui_notebook_tab_remove(UIWIDGET tabview, int tab) {
    gtk_notebook_remove_page(GTK_NOTEBOOK(tabview), tab);
}

void ui_notebook_tab_add(UIWIDGET widget, int index, const char *name, UIWIDGET child) {
    gtk_notebook_insert_page(
            GTK_NOTEBOOK(widget),
            child,
            gtk_label_new(name),
            index);
}

int64_t ui_notebook_get(UiInteger *i) {
    GtkNotebook *nb = i->obj;
    i->value = gtk_notebook_get_current_page(nb);
    return i->value;
}

void ui_notebook_set(UiInteger *i, int64_t value) {
    GtkNotebook *nb = i->obj;
    gtk_notebook_set_current_page(nb, value);
    i->value = gtk_notebook_get_current_page(nb);
}


#if GTK_MAJOR_VERSION >= 4
static int stack_set_page(GtkWidget *stack, int index) {
    GtkSelectionModel *pages = gtk_stack_get_pages(GTK_STACK(stack));
    GListModel *list = G_LIST_MODEL(pages);
    GtkStackPage *page = g_list_model_get_item(list, index);
    if(page) {
        gtk_stack_set_visible_child(GTK_STACK(stack), gtk_stack_page_get_child(page));
    } else {
        fprintf(stderr, "UI Error: ui_stack_set value out of bounds\n");
        return -1;
    }
    return index;
}

void ui_stack_tab_select(UIWIDGET tabview, int tab) {
    stack_set_page(tabview, tab);
}

void ui_stack_tab_remove(UIWIDGET tabview, int tab) {
    GtkStack *stack = GTK_STACK(tabview);
    GtkWidget *current = gtk_stack_get_visible_child(stack);
    GtkSelectionModel *pages = gtk_stack_get_pages(stack);
    GListModel *list = G_LIST_MODEL(pages);
    GtkStackPage *page = g_list_model_get_item(list, tab);
    if(page) {
        gtk_stack_remove(stack, gtk_stack_page_get_child(page));
    }
}

void ui_stack_tab_add(UIWIDGET widget, int index, const char *name, UIWIDGET child) {
    (void)gtk_stack_add_titled(GTK_STACK(widget), child, name, name);
}

int64_t ui_stack_get(UiInteger *i) {
    GtkStack *stack = GTK_STACK(i->obj);
    GtkWidget *current = gtk_stack_get_visible_child(stack);
    GtkSelectionModel *pages = gtk_stack_get_pages(stack);
    GListModel *list = G_LIST_MODEL(pages);
    int nitems = g_list_model_get_n_items(list);
    for(int p=0;p<nitems;p++) {
        GtkStackPage *page = g_list_model_get_item(list, p);
        GtkWidget *child = gtk_stack_page_get_child(page);
        if(child == current) {
            i->value = p;
            break;
        }
    }
    return i->value;
}

void ui_stack_set(UiInteger *i, int64_t value) {
    GtkWidget *widget = i->obj;
    if(stack_set_page(widget, value) >= 0) {
        i->value = value;
    }
}
#elif GTK_MAJOR_VERSION >= 3
static GtkWidget* stack_get_child(GtkWidget *stack, int index) {
    GList *children = gtk_container_get_children(GTK_CONTAINER(stack));
    if(children) {
        return g_list_nth_data(children, index);
    }
    return NULL;
}

void ui_stack_tab_select(UIWIDGET tabview, int tab) {
    GtkWidget *child = stack_get_child(tabview, tab);
    if(child) {
        gtk_stack_set_visible_child(GTK_STACK(tabview), child);
    }
}

void ui_stack_tab_remove(UIWIDGET tabview, int tab) {
    GtkWidget *child = stack_get_child(tabview, tab);
    if(child) {
        gtk_container_remove(GTK_CONTAINER(tabview), child);
    }
}

void ui_stack_tab_add(UIWIDGET widget, int index, const char *name, UIWIDGET child) {
    gtk_stack_add_titled(GTK_STACK(widget), child, name, name);
}

int64_t ui_stack_get(UiInteger *i) {
    GtkWidget *visible = gtk_stack_get_visible_child(GTK_STACK(i->obj));
    GList *children = gtk_container_get_children(GTK_CONTAINER(i->obj));
    GList *elm = children;
    int n = 0;
    int64_t v = -1;
    while(elm) {
        GtkWidget *child = elm->data;
        if(child == visible) {
            v = n;
            break;
        }
        
        elm = elm->next;
        n++;
    }
    g_list_free(children);
    i->value = v;
    return v;
}

void ui_stack_set(UiInteger *i, int64_t value) {
    GtkWidget *child = stack_get_child(i->obj, value);
    if(child) {
        gtk_stack_set_visible_child(GTK_STACK(i->obj), child);
        i->value = value;
    }
}

#endif


UiGtkTabView* ui_widget_get_tabview_data(UIWIDGET tabview) {
    return g_object_get_data(G_OBJECT(tabview), "ui_tabview");
}

static void tabview_switch_page(
        GtkNotebook *self,
        GtkWidget *page,
        guint page_num,
        gpointer userdata)
{
    UiGtkTabView *tabview = userdata;
    if(!tabview->onchange) {
        return;
    }
    
    UiEvent event;
    event.obj = tabview->obj;
    event.window = event.obj->window;
    event.document = event.obj->ctx->document;
    event.set = ui_get_setop();
    event.eventdata = NULL;
    event.eventdatatype = 0;
    event.intval = page_num;
    
    tabview->onchange(&event, tabview->onchange);
}

#if GTK_CHECK_VERSION(3, 10, 0)

static void tabview_stack_changed(
        GObject *object,
        GParamSpec *pspec,
        UiGtkTabView *tabview)
{
    if(!tabview->onchange) {
        return;
    }
    
    UiEvent event;
    event.obj = tabview->obj;
    event.window = event.obj->window;
    event.document = event.obj->ctx->document;
    event.set = ui_get_setop();
    event.eventdata = NULL;
    event.eventdatatype = 0;
    event.intval = 0;
    
    tabview->onchange(&event, tabview->onchange);
}

#endif

typedef int64_t(*ui_tabview_get_func)(UiInteger*);
typedef void (*ui_tabview_set_func)(UiInteger*, int64_t);

UIWIDGET ui_tabview_create(UiObject* obj, UiTabViewArgs *args) {
    UiGtkTabView *data = malloc(sizeof(UiGtkTabView));
    memset(data, 0, sizeof(UiGtkTabView));
    data->margin = args->margin;
    data->spacing = args->spacing;
    data->columnspacing = args->columnspacing;
    data->rowspacing = args->rowspacing;
    
    ui_tabview_get_func getfunc = NULL;
    ui_tabview_set_func setfunc = NULL;
    
    GtkWidget *widget = NULL;
    GtkWidget *data_widget = NULL;
    switch(args->tabview) {
        case UI_TABVIEW_DOC: {
            // TODO
            break;
        }
        case UI_TABVIEW_NAVIGATION_SIDE: {
#if GTK_CHECK_VERSION(3, 10, 0)
            widget = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
            GtkWidget *sidebar = gtk_stack_sidebar_new();
            BOX_ADD(widget, sidebar);
            GtkWidget *stack = gtk_stack_new();
            g_signal_connect(stack, "notify::visible-child", G_CALLBACK(tabview_stack_changed), data);
            gtk_stack_set_transition_type (GTK_STACK(stack), GTK_STACK_TRANSITION_TYPE_SLIDE_UP_DOWN);
            gtk_stack_sidebar_set_stack(GTK_STACK_SIDEBAR(sidebar), GTK_STACK(stack));
            BOX_ADD_EXPAND(widget, stack);
            data->select_tab = ui_stack_tab_select;
            data->remove_tab = ui_stack_tab_remove;
            data->add_tab = ui_stack_tab_add;
            getfunc = ui_stack_get;
            setfunc = ui_stack_set;
            data_widget = stack;
#else
            // TODO
#endif
            break;
        }
        case UI_TABVIEW_DEFAULT: /* fall through */
        case UI_TABVIEW_NAVIGATION_TOP: /* fall through */
        case UI_TABVIEW_INVISIBLE: /* fall through */
        case UI_TABVIEW_NAVIGATION_TOP2: {
            widget = gtk_notebook_new();
            g_signal_connect(
                    widget,
                    "switch-page",
                    G_CALLBACK(tabview_switch_page),
                    data);
            data_widget = widget;
            data->select_tab = ui_notebook_tab_select;
            data->remove_tab = ui_notebook_tab_remove;
            data->add_tab = ui_notebook_tab_add;
            getfunc = ui_notebook_get;
            setfunc = ui_notebook_set;
            if(args->tabview == UI_TABVIEW_INVISIBLE) {
                gtk_notebook_set_show_tabs(GTK_NOTEBOOK(widget), FALSE);
                gtk_notebook_set_show_border(GTK_NOTEBOOK(widget), FALSE);
            }
            break;
        }
    }
    
    UiObject* current = uic_current_obj(obj);
    if(args->value || args->varname) {
        UiVar *var = uic_widget_var(obj->ctx, current->ctx, args->value, args->varname, UI_VAR_INTEGER);
        UiInteger *i = var->value;
        i->get = getfunc;
        i->set = setfunc;
        i->obj = data_widget;
    }
    
    g_object_set_data(G_OBJECT(widget), "ui_tabview", data);
    data->widget = data_widget;
    data->subcontainer = args->subcontainer;
    
    UI_APPLY_LAYOUT2(current, args);
    current->container->add(current->container, widget);
    
    UiObject *newobj = uic_object_new(obj, widget);
    newobj->container = ui_tabview_container(obj, widget);
    uic_obj_add(obj, newobj);
    data->obj = newobj;
    
    return widget;
}

void ui_tab_create(UiObject* obj, const char* title) {
    UiObject* current = uic_current_obj(obj);
    UiGtkTabView *data = ui_widget_get_tabview_data(current->widget);
    if(!data) {
        fprintf(stderr, "UI Error: widget is not a tabview\n");
        return;
    }
    
    UiObject *newobj = ui_tabview_add(current->widget, title, -1);
    current->next = newobj;
}


void ui_tabview_select(UIWIDGET tabview, int tab) {
    UiGtkTabView *data = ui_widget_get_tabview_data(tabview);
    if(!data) {
        fprintf(stderr, "UI Error: widget is not a tabview\n");
        return;
    }
    data->select_tab(tabview, tab);
}

void ui_tabview_remove(UIWIDGET tabview, int tab) {
    UiGtkTabView *data = ui_widget_get_tabview_data(tabview);
    if(!data) {
        fprintf(stderr, "UI Error: widget is not a tabview\n");
        return;
    }
    data->remove_tab(tabview, tab);
}

UiObject* ui_tabview_add(UIWIDGET tabview, const char *name, int tab_index) {
    UiGtkTabView *data = ui_widget_get_tabview_data(tabview);
    if(!data) {
        fprintf(stderr, "UI Error: widget is not a tabview\n");
        return NULL;
    }
    
    UiObject *newobj = cxCalloc(data->obj->ctx->allocator, 1, sizeof(UiObject));
    newobj->ctx = data->obj->ctx;
    
    GtkWidget *sub;
    switch(data->subcontainer) {
        default: {
            sub = ui_gtk_vbox_new(data->spacing);
            newobj->container = ui_box_container(newobj, sub, data->subcontainer);
            break;
        }
        case UI_CONTAINER_HBOX: {
            sub = ui_gtk_hbox_new(data->spacing);
            newobj->container = ui_box_container(newobj, sub, data->subcontainer);
            break;
        }
        case UI_CONTAINER_GRID: {
            sub = ui_create_grid_widget(data->columnspacing, data->rowspacing);
            newobj->container = ui_grid_container(newobj, sub, FALSE, FALSE, FALSE, FALSE);
            break;
        }
    }
    newobj->widget = sub;
    GtkWidget *widget = ui_box_set_margin(sub, data->margin);
    
    data->add_tab(data->widget, tab_index, name, widget);
    
    return newobj;
}


/* -------------------- Headerbar -------------------- */

static void hb_set_part(UiObject *obj, int part) {
    UiObject* current = uic_current_obj(obj);
    GtkWidget *headerbar = current->widget;
    
    UiHeaderbarContainer *hb = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiHeaderbarContainer));
    memcpy(hb, current->container, sizeof(UiHeaderbarContainer));
    
    UiObject *newobj = uic_object_new(obj, headerbar);
    newobj->container = (UiContainer*)hb;
    uic_obj_add(obj, newobj);
    
    hb->part = part;
}

void ui_headerbar_start_create(UiObject *obj) {
    hb_set_part(obj, 0);
}

void ui_headerbar_center_create(UiObject *obj) {
    hb_set_part(obj, 2);
}

void ui_headerbar_end_create(UiObject *obj) {
    hb_set_part(obj, 1);
}

UIWIDGET ui_headerbar_fallback_create(UiObject *obj, UiHeaderbarArgs *args) {
    UiObject *current = uic_current_obj(obj);
    UiContainer *ct = current->container;
    UI_APPLY_LAYOUT2(current, args);
    
    GtkWidget *box = ui_gtk_hbox_new(args->alt_spacing);
    ui_set_name_and_style(box, args->name, args->style_class);
    ct->add(ct, box);
    
    UiObject *newobj = uic_object_new(obj, box);
    newobj->container = ui_headerbar_fallback_container(obj, box);
    uic_obj_add(obj, newobj);
    
    return box;
}

static void hb_fallback_set_part(UiObject *obj, int part) {
    UiObject* current = uic_current_obj(obj);
    GtkWidget *headerbar = current->widget;
    
    UiObject *newobj = uic_object_new(obj, headerbar);
    newobj->container = ui_headerbar_container(obj, headerbar);
    uic_obj_add(obj, newobj);
    
    UiHeaderbarContainer *hb = (UiHeaderbarContainer*)newobj->container;
    hb->part = part;
}

UiContainer* ui_headerbar_fallback_container(UiObject *obj, GtkWidget *headerbar) {
    UiHeaderbarContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiHeaderbarContainer));
    ct->container.widget = headerbar;
    ct->container.add = ui_headerbar_fallback_container_add;
    return (UiContainer*)ct;
}

void ui_headerbar_fallback_container_add(UiContainer *ct, GtkWidget *widget) {
    UiHeaderbarContainer *hb = (UiHeaderbarContainer*)ct;
    BOX_ADD(ct->widget, widget);
}

#if GTK_CHECK_VERSION(3, 10, 0)

UIWIDGET ui_headerbar_create(UiObject *obj, UiHeaderbarArgs *args) {
    GtkWidget *headerbar = g_object_get_data(G_OBJECT(obj->widget), "ui_headerbar");
    if(!headerbar) {
        return ui_headerbar_fallback_create(obj, args);
    }
    
    UiObject *newobj = uic_object_new(obj, headerbar);
    newobj->container = ui_headerbar_container(obj, headerbar);
    uic_obj_add(obj, newobj);
    
    return headerbar;    
}

UiContainer* ui_headerbar_container(UiObject *obj, GtkWidget *headerbar) {
    UiHeaderbarContainer *ct = cxCalloc(
            obj->ctx->allocator,
            1,
            sizeof(UiHeaderbarContainer));
    ct->container.widget = headerbar;
    ct->container.add = ui_headerbar_container_add;
    return (UiContainer*)ct;
}

void ui_headerbar_container_add(UiContainer *ct, GtkWidget *widget) {
    UiHeaderbarContainer *hb = (UiHeaderbarContainer*)ct;
    if(hb->part == 0) {
        UI_HEADERBAR_PACK_START(ct->widget, widget);
    } else if(hb->part == 1) {
        UI_HEADERBAR_PACK_END(ct->widget, widget);
    } else if(hb->part == 2) {
        if(!hb->centerbox) {
            GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
            hb->centerbox = box;
            UI_HEADERBAR_SET_TITLE_WIDGET(ct->widget, box);
        }
        BOX_ADD(hb->centerbox, widget);
    }
}

#else

UIWIDGET ui_headerbar_create(UiObject *obj, UiHeaderbarArgs *args) {
    return ui_headerbar_fallback_create(obj, args);  
}

#endif

/* -------------------- Sidebar -------------------- */

#ifdef UI_LIBADWAITA
UIWIDGET ui_sidebar_create(UiObject *obj, UiSidebarArgs *args) {
    GtkWidget *sidebar_toolbar_view = g_object_get_data(G_OBJECT(obj->widget), "ui_sidebar");
    if(!sidebar_toolbar_view) {
        fprintf(stderr, "Error: window is not configured for sidebar\n");
        return NULL;
    }
    
    GtkWidget *box = ui_gtk_vbox_new(args->spacing);
    ui_box_set_margin(box, args->margin);
    adw_toolbar_view_set_content(ADW_TOOLBAR_VIEW(sidebar_toolbar_view), box);
    
    UiObject *newobj = uic_object_new(obj, box);
    newobj->container = ui_box_container(obj, box, UI_CONTAINER_VBOX);
    uic_obj_add(obj, newobj);
    
    return box;
}
#else
UIWIDGET ui_sidebar_create(UiObject *obj, UiSidebarArgs *args) {
    GtkWidget *sidebar_vbox = g_object_get_data(G_OBJECT(obj->widget), "ui_sidebar");
    
    GtkWidget *box = ui_gtk_vbox_new(args->spacing);
    ui_box_set_margin(box, args->margin);
    BOX_ADD_EXPAND(sidebar_vbox, box);
    
    UiObject *newobj = uic_object_new(obj, box);
    newobj->container = ui_box_container(obj, box, UI_CONTAINER_VBOX);
    uic_obj_add(obj, newobj);
    
    return box;
}
#endif

/* ------------------------ Split Window Panels ------------------------ */

static UIWIDGET splitwindow_panel(UiObject *obj, GtkWidget *pbox, UiSidebarArgs *args) {
    if(!pbox) {
        fprintf(stderr, "Error: window is not a splitview window\n");
        return NULL;
    }
    
    GtkWidget *box = ui_gtk_vbox_new(args->spacing);
    ui_set_name_and_style(box, args->name, args->style_class);
    ui_box_set_margin(box, args->margin);
    BOX_ADD_EXPAND(pbox, box);
    
    UiObject *newobj = uic_object_new(obj, box);
    newobj->container = ui_box_container(obj, box, UI_CONTAINER_VBOX);
    uic_obj_add(obj, newobj);
    
    return box;
}

UIWIDGET ui_left_panel_create(UiObject *obj, UiSidebarArgs *args) {
    return splitwindow_panel(obj, g_object_get_data(G_OBJECT(obj->widget), "ui_left_panel"), args);
}

UIWIDGET ui_right_panel_create(UiObject *obj, UiSidebarArgs *args) {
    return splitwindow_panel(obj, g_object_get_data(G_OBJECT(obj->widget), "ui_right_panel"), args);
}


/* -------------------- Splitpane -------------------- */

static GtkWidget* create_paned(UiOrientation orientation) {
#if GTK_MAJOR_VERSION >= 3
    switch(orientation) {
        case UI_HORIZONTAL: return gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
        case UI_VERTICAL: return gtk_paned_new(GTK_ORIENTATION_VERTICAL);
    }
#else
    switch(orientation) {
        case UI_HORIZONTAL: return gtk_hpaned_new();
        case UI_VERTICAL: return gtk_vpaned_new();
    }
#endif
    return NULL;
}

static void save_pane_pos(GtkWidget *widget, char *property_name) {
    int pos = gtk_paned_get_position(GTK_PANED(widget));
    char buf[32];
    snprintf(buf, 32, "%d", pos);
    ui_set_property(property_name, buf);
    free(property_name);
}

static UIWIDGET splitpane_create(UiObject *obj, UiOrientation orientation, UiSplitPaneArgs *args) {
    UiObject* current = uic_current_obj(obj);
    
    GtkWidget *pane0 = create_paned(orientation);
    
    UI_APPLY_LAYOUT2(current, args);
    current->container->add(current->container, pane0);
    
    int max = args->max_panes == 0 ? 2 : args->max_panes;
    
    if(args->position_property) {
        const char *pos_str = ui_get_property(args->position_property);
        if(pos_str) {
            char *end;
            long pos = strtol(pos_str, &end, 10);
            if(*end == '\0') {
                args->initial_position = (int)pos;
            }
        }
        
        g_signal_connect(
                pane0,
                "destroy",
                G_CALLBACK(save_pane_pos),
                strdup(args->position_property));
    }
    
    UiObject *newobj = uic_object_new(obj, pane0);
    newobj->container = ui_splitpane_container(obj, pane0, orientation, max, args->initial_position);
    uic_obj_add(obj, newobj);
    
    g_object_set_data(G_OBJECT(pane0), "ui_splitpane", newobj->container);
    
    UiVar *var = uic_widget_var(obj->ctx, current->ctx, args->value, args->varname, UI_VAR_INTEGER);
    if(var) {
        UiSplitPaneContainer *s = (UiSplitPaneContainer*)newobj->container;
        UiInteger *i = var->value;
        s->initial_position = i->value;
        
        i->obj = s;
        i->get = ui_splitpane_get;
        i->set = ui_splitpane_set;
    }
    
    return pane0;
}

UIWIDGET ui_hsplitpane_create(UiObject *obj, UiSplitPaneArgs *args) {
    return splitpane_create(obj, UI_HORIZONTAL, args);
}

UIWIDGET ui_vsplitpane_create(UiObject *obj, UiSplitPaneArgs *args) {
    return splitpane_create(obj, UI_VERTICAL, args);
}

UiContainer* ui_splitpane_container(UiObject *obj, GtkWidget *pane, UiOrientation orientation, int max, int init) {
    UiSplitPaneContainer *ct = ui_calloc(obj->ctx, 1, sizeof(UiSplitPaneContainer));
    ct->container.widget = pane;
    ct->container.add = ui_splitpane_container_add;
    ct->current_pane = pane;
    ct->orientation = orientation;
    ct->max = max;
    ct->initial_position = init;
    ct->children = cxArrayListCreateSimple(CX_STORE_POINTERS, 4);
    return (UiContainer*)ct;
}

void ui_splitpane_container_add(UiContainer *ct, GtkWidget *widget) {
    UiSplitPaneContainer *s = (UiSplitPaneContainer*)ct;
    
    if(s->nchildren >= s->max) {
        fprintf(stderr, "splitpane: maximum number of children reached\n");
        return;
    }
    
    cxListAdd(s->children, widget);
    
    if(s->pos == 0) {
        PANED_SET_CHILD1(s->current_pane, widget);
        if(s->initial_position > 0) {
            gtk_paned_set_position(GTK_PANED(s->current_pane), s->initial_position);
        }
        s->pos++;
        s->nchildren++;
    } else {
        if(s->nchildren+1 == s->max) {
            PANED_SET_CHILD2(s->current_pane, widget);
        } else {
            GtkWidget *pane = create_paned(s->orientation);
            PANED_SET_CHILD1(pane, widget);
            PANED_SET_CHILD2(s->current_pane, pane);
            s->current_pane = pane;
        }
        
        s->pos = 0;
        s->nchildren++;
    }
}

int64_t ui_splitpane_get(UiInteger *i) {
    UiSplitPaneContainer *s = i->obj;
    i->value = gtk_paned_get_position(GTK_PANED(s->container.widget));
    return i->value;
}

void ui_splitpane_set(UiInteger *i, int64_t value) {
    UiSplitPaneContainer *s = i->obj;
    i->value = value;
    gtk_paned_set_position(GTK_PANED(s->container.widget), (int)value);
}

UIEXPORT void ui_splitpane_set_visible(UIWIDGET splitpane, int child_index, UiBool visible) {
    UiSplitPaneContainer *ct = g_object_get_data(G_OBJECT(splitpane), "ui_splitpane");
    if(!ct) {
        fprintf(stderr, "UI Error: not a splitpane\n");
        return;
    }
    
    GtkWidget *w = cxListAt(ct->children, child_index);
    if(w) {
        gtk_widget_set_visible(w, visible);
    }
}

/* -------------------- ItemList Container -------------------- */

static void remove_item(void *data, void *item) {
    UiGtkItemListContainer *ct = data;
    UiObject *obj = item;
    if(ct->remove_items) {
        BOX_REMOVE(ct->widget, obj->widget);
    }
    uic_object_destroy(obj);
}

static void update_itemlist(UiList *list, int c) {
    UiGtkItemListContainer *ct = list->obj;
    
    CxMap *new_items = cxHashMapCreateSimple(CX_STORE_POINTERS);
    new_items->collection.advanced_destructor = remove_item;
    new_items->collection.destructor_data = ct;
    
    // only create new widgets for new elements, so at first we have
    // to find which elements are new
    // check which elements in the list are already in the container
    void *elm = list->first(list);
    int j = 0;
    while(elm) {
        CxHashKey key = cx_hash_key(&elm, sizeof(void*));
        UiObject *item_obj = NULL;
        cxMapRemoveAndGet(ct->current_items, key, &item_obj);
        if(item_obj) {
            g_object_ref(G_OBJECT(item_obj->widget));
            BOX_REMOVE(ct->widget, item_obj->widget);
            cxMapPut(new_items, key, item_obj);
        }
        elm = list->next(list);
        j++;
    }
    
    // ct->current_items only contains elements, that are not in the list
    cxMapFree(ct->current_items); // calls destructor remove_item
    ct->current_items = new_items;
    
    // add all items
    int index = 0;
    elm = list->first(list);
    while(elm) {
        CxHashKey key = cx_hash_key(&elm, sizeof(void*));
        UiObject *item_obj = cxMapGet(ct->current_items, key);
        if(item_obj) {
            // re-add previously created widget
            ui_box_container_add(ct->container, item_obj->widget);
        } else {
            // create new widget and object for this list element
            CxMempool *mp = cxMempoolCreateSimple(256);
            const CxAllocator *a = mp->allocator;
            UiObject *obj = cxCalloc(a, 1, sizeof(UiObject));
            obj->ctx = uic_context(obj, mp);
            obj->window = NULL;
            obj->widget = ui_subcontainer_create(
                    ct->subcontainer,
                    obj,
                    ct->spacing,
                    ct->columnspacing,
                    ct->rowspacing,
                    ct->margin);
            ui_box_container_add(ct->container, obj->widget);
            if(ct->create_ui) {
                ct->create_ui(obj, index, elm, ct->userdata);
            }
            cxMapPut(new_items, key, obj);
        }
        elm = list->next(list);
        index++;
    }
    
#if GTK_MAJOR_VERSION < 4
    gtk_widget_show_all(ct->widget);
#endif
}

static void destroy_itemlist_container(GtkWidget *w, UiGtkItemListContainer *container) {
    container->remove_items = FALSE;
    cxMapFree(container->current_items);
    free(container);
}

UIWIDGET ui_itemlist_create(UiObject *obj, UiItemListContainerArgs *args) {
    UiObject *current = uic_current_obj(obj);
    UiContainer *ct = current->container;
    UI_APPLY_LAYOUT2(current, args);
    
    GtkWidget *box = args->container == UI_CONTAINER_VBOX ? ui_gtk_vbox_new(args->spacing) : ui_gtk_hbox_new(args->spacing);
    ui_set_name_and_style(box, args->name, args->style_class);
    GtkWidget *widget = args->margin > 0 ? ui_box_set_margin(box, args->margin) : box;
    ct->add(ct, widget);
    
    UiGtkItemListContainer *container = malloc(sizeof(UiGtkItemListContainer));
    container->parent = obj;
    container->widget = box;
    container->container = ui_box_container(current, box, args->container);
    container->create_ui = args->create_ui;
    container->userdata = args->userdata;
    container->subcontainer = args->subcontainer;
    container->current_items = cxHashMapCreateSimple(CX_STORE_POINTERS);
    container->current_items->collection.advanced_destructor = remove_item;
    container->current_items->collection.destructor_data = container;
    container->margin = args->sub_margin;
    container->spacing = args->sub_spacing;
    container->columnspacing = args->sub_columnspacing;
    container->rowspacing = args->sub_rowspacing;
    container->remove_items = TRUE;
    
    UiVar* var = uic_widget_var(obj->ctx, current->ctx, args->value, args->varname, UI_VAR_LIST);
    if(var) {
        UiList *list = var->value;
        list->obj = container;
        list->update = update_itemlist;
        update_itemlist(list, 0);
    }
    g_signal_connect(
                box,
                "destroy",
                G_CALLBACK(destroy_itemlist_container),
                container);
    
    return box;
}


/*
 * -------------------- Layout Functions --------------------
 * 
 * functions for setting layout attributes for the current container
 *
 */

void ui_layout_fill(UiObject *obj, UiBool fill) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.fill = fill;
}

void ui_layout_hexpand(UiObject *obj, UiBool expand) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.hexpand = expand;
}

void ui_layout_vexpand(UiObject *obj, UiBool expand) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.vexpand = expand;
}

void ui_layout_hfill(UiObject *obj, UiBool fill) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.hfill = fill;
}

void ui_layout_vfill(UiObject *obj, UiBool fill) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.vfill = fill;
}

UIEXPORT void ui_layout_override_defaults(UiObject *obj, UiBool d) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.override_defaults = d;
}

void ui_layout_colspan(UiObject* obj, int cols) {
    UiContainer* ct = uic_get_current_container(obj);
    ct->layout.colspan = cols;
}

void ui_layout_rowspan(UiObject* obj, int rows) {
    UiContainer* ct = uic_get_current_container(obj);
    ct->layout.rowspan = rows;
}

void ui_newline(UiObject *obj) {
    UiContainer *ct = uic_get_current_container(obj);
    ct->layout.newline = TRUE;
}