[ICEs.git] / 210125 / gtk.i.8

typedef struct _GList GList;
typedef struct _GdkRectangle GdkRectangle;
struct _GdkRectangle {
	int x;
	int y;
	int width;
	int height;
};
typedef enum { GTK_PACK_END } GtkPathType;
typedef enum {
	GTK_POS_LEFT, GTK_POS_RIGHT, GTK_POS_TOP, GTK_POS_BOTTOM
} GtkPreviewType;
typedef struct _GtkWidget GtkWidget;
struct _GtkWidget {
	GtkWidget *parent;
};
typedef struct _GtkNotebook GtkNotebook;
typedef struct _GtkNotebookPage GtkNotebookPage;
struct _GtkNotebook {
	GtkNotebookPage *cur_page;
	unsigned int homogeneous:1;
};
typedef enum {
	DRAG_OPERATION_NONE, DRAG_OPERATION_REORDER, DRAG_OPERATION_DETACH
} GtkNotebookDragOperation;
struct _GtkNotebookPage {
	GtkWidget *tab_label;
	unsigned int pack:1;
	GdkRectangle requisition, allocation;
};
typedef struct _GtkNotebookPrivate GtkNotebookPrivate;
struct _GtkNotebookPrivate {
	GtkNotebookDragOperation operation;
	int x;
	int y;
	GtkNotebookPage *detached_tab;
};
int gtk_notebook_calculate_tabs_allocation(GtkNotebook * notebook,
					   GList ** children,
					   GList * last_child, int showarrow,
int *remaining_space,
					   int *expanded_tabs, int min, int max)
{
	GtkNotebookPrivate *priv;
	GtkNotebookPage *page;
	int allocate_at_bottom;
	int tab_overlap;
	int tab_pos;
	int tab_extra_space;
	int left_x;
	int right_x;
	int top_y;
	int anchor;
	int xthickness;
	int ythickness;
	int gap_left;
	int packing_changed;
	GdkRectangle child_allocation;
	while (
*children
 && *children != last_child
) {
		if (!
		    (((GtkNotebookPage *) (page))->tab_label->parent
 ==
		     ((GtkWidget *) (notebook)))
)
			continue;
		if (*expanded_tabs && (notebook->homogeneous)) {
			tab_extra_space = *remaining_space / *expanded_tabs;
			*remaining_space -= tab_extra_space;
		}
		switch (tab_pos) {
		case GTK_POS_TOP:
		case GTK_POS_BOTTOM:
			child_allocation.width =
			    page->requisition.width + 
tab_overlap +
			    tab_extra_space;
			if (gap_left && packing_changed) {
				if (allocate_at_bottom) {
						left_x = priv->x =
						    anchor;
						anchor +=
						    notebook->cur_page->
						    allocation.width -
						    tab_overlap;
					if (notebook->cur_page->pack
					     && right_x > anchor) {
						anchor -=
						    notebook->cur_page->
						    allocation.width;
priv->x = anchor;
					}
				}
			} else {
				if (allocate_at_bottom)
					anchor -= child_allocation.width;
				if (priv->operation
 == DRAG_OPERATION_REORDER
				    && page->pack == notebook->cur_page->pack) {
					if (!allocate_at_bottom
					    && left_x >= anchor
					    && left_x <=
					    anchor + child_allocation.width / 2)
						anchor +=
						    notebook->cur_page->
						    allocation.width -
						    tab_overlap;
					else if (allocate_at_bottom
						 && right_x >=
						 anchor +
						 child_allocation.width / 2
						 && right_x <=
						 anchor +
						 child_allocation.width)
						anchor -=
						    notebook->cur_page->
						    allocation.width -
						    tab_overlap;
				}
				child_allocation.x = anchor;
			}
			break;
		case GTK_POS_LEFT:
		case GTK_POS_RIGHT:
			child_allocation.height =
			    page->requisition.height + tab_overlap +
			    tab_extra_space;
			if (packing_changed) {
				priv->x = child_allocation.x;
				priv->y = top_y;
				if (priv->operation == DRAG_OPERATION_REORDER
				    && page->pack == notebook->cur_page->pack) {
					if (!allocate_at_bottom
					    && top_y >= anchor
					    && top_y <=
					    anchor +
					    child_allocation.height / 2)
						anchor +=
						    notebook->cur_page->
						    allocation.height -
						    tab_overlap;
				}
			}
		}
		if ((page == priv->detached_tab
		     && priv->operation == DRAG_OPERATION_DETACH)
		    || (page == notebook->cur_page
			&& priv->operation == DRAG_OPERATION_REORDER)) {
			page->allocation.x = 0;
		}
		if (page != notebook->cur_page) {
			switch (tab_pos) {
			case GTK_POS_TOP:
				page->allocation.y += ythickness;
			case GTK_POS_BOTTOM:
				page->allocation.height =
1 > page->allocation.height -      ythickness ? 1 : page->allocation.
							     height -
							     ythickness;
				break;
			case GTK_POS_LEFT:
				page->allocation.x += xthickness;
			case GTK_POS_RIGHT:
				page->allocation.width =
1 > page->allocation.width - xthickness ? 1 : page->allocation.width - xthickness;
			}
		}
		switch (tab_pos) {
		case GTK_POS_TOP:
		case GTK_POS_BOTTOM:
			if (
priv->operation != DRAG_OPERATION_REORDER || 
priv->operation == DRAG_OPERATION_REORDER
				&& page != notebook->cur_page
)
				if (!allocate_at_bottom)
					anchor +=
					    child_allocation.width -
					    tab_overlap;
		case GTK_POS_LEFT:
		case GTK_POS_RIGHT:
			if (priv->operation != DRAG_OPERATION_REORDER
			    || priv->operation == DRAG_OPERATION_REORDER
				&& page != notebook->cur_page)
				if (priv->operation == DRAG_OPERATION_REORDER)
					if (page->pack ==
					    notebook->cur_page->pack
					    && !allocate_at_bottom
					    && top_y >=
					    anchor + child_allocation.height / 2
					    && top_y <=
					    anchor + child_allocation.height)
						anchor +=
						    notebook->cur_page->
						    allocation.height -
						    tab_overlap;
		}
		if (page->tab_label)
			IA__gtk_widget_set_child_visible(page->tab_label, 1);
	}
}
Commit	Line	Data
45516216	1	typedef struct _GList GList;
	2	typedef struct _GdkRectangle GdkRectangle;
	3	struct _GdkRectangle {
	4	int x;
	5	int y;
	6	int width;
	7	int height;
	8	};
	9	typedef enum { GTK_PACK_END } GtkPathType;
	10	typedef enum {
	11	GTK_POS_LEFT, GTK_POS_RIGHT, GTK_POS_TOP, GTK_POS_BOTTOM
	12	} GtkPreviewType;
	13	typedef struct _GtkWidget GtkWidget;
	14	struct _GtkWidget {
	15	GtkWidget *parent;
	16	};
	17	typedef struct _GtkNotebook GtkNotebook;
	18	typedef struct _GtkNotebookPage GtkNotebookPage;
	19	struct _GtkNotebook {
	20	GtkNotebookPage *cur_page;
	21	unsigned int homogeneous:1;
	22	};
	23	typedef enum {
	24	DRAG_OPERATION_NONE, DRAG_OPERATION_REORDER, DRAG_OPERATION_DETACH
	25	} GtkNotebookDragOperation;
	26	struct _GtkNotebookPage {
	27	GtkWidget *tab_label;
	28	unsigned int pack:1;
	29	GdkRectangle requisition, allocation;
	30	};
	31	typedef struct _GtkNotebookPrivate GtkNotebookPrivate;
	32	struct _GtkNotebookPrivate {
	33	GtkNotebookDragOperation operation;
	34	int x;
	35	int y;
	36	GtkNotebookPage *detached_tab;
	37	};
	38	int gtk_notebook_calculate_tabs_allocation(GtkNotebook * notebook,
	39	GList ** children,
	40	GList * last_child, int showarrow,
	41	int *remaining_space,
	42	int *expanded_tabs, int min, int max)
	43	{
	44	GtkNotebookPrivate *priv;
	45	GtkNotebookPage *page;
	46	int allocate_at_bottom;
	47	int tab_overlap;
	48	int tab_pos;
	49	int tab_extra_space;
	50	int left_x;
	51	int right_x;
	52	int top_y;
	53	int anchor;
	54	int xthickness;
	55	int ythickness;
	56	int gap_left;
	57	int packing_changed;
	58	GdkRectangle child_allocation;
	59	while (
	60	*children
	61	&& *children != last_child
	62	) {
	63	if (!
	64	(((GtkNotebookPage *) (page))->tab_label->parent
65	==
66	((GtkWidget *) (notebook)))
67	)
68	continue;
69	if (*expanded_tabs && (notebook->homogeneous)) {
70	tab_extra_space = remaining_space / expanded_tabs;
71	*remaining_space -= tab_extra_space;
72	}
73	switch (tab_pos) {
74	case GTK_POS_TOP:
75	case GTK_POS_BOTTOM:
76	child_allocation.width =
77	page->requisition.width +
78	tab_overlap +
79	tab_extra_space;
80	if (gap_left && packing_changed) {
81	if (allocate_at_bottom) {
82	left_x = priv->x =
83	anchor;
84	anchor +=
85	notebook->cur_page->
86	allocation.width -
87	tab_overlap;
88	if (notebook->cur_page->pack
89	&& right_x > anchor) {
90	anchor -=
91	notebook->cur_page->
92	allocation.width;
93	priv->x = anchor;
94	}
95	}
96	} else {
97	if (allocate_at_bottom)
98	anchor -= child_allocation.width;
99	if (priv->operation
100	== DRAG_OPERATION_REORDER
101	&& page->pack == notebook->cur_page->pack) {
102	if (!allocate_at_bottom
103	&& left_x >= anchor
104	&& left_x <=
105	anchor + child_allocation.width / 2)
106	anchor +=
107	notebook->cur_page->
108	allocation.width -
109	tab_overlap;
110	else if (allocate_at_bottom
111	&& right_x >=
112	anchor +
113	child_allocation.width / 2
114	&& right_x <=
115	anchor +
116	child_allocation.width)
117	anchor -=
118	notebook->cur_page->
119	allocation.width -
120	tab_overlap;
121	}
122	child_allocation.x = anchor;
123	}
124	break;
125	case GTK_POS_LEFT:
126	case GTK_POS_RIGHT:
127	child_allocation.height =
128	page->requisition.height + tab_overlap +
129	tab_extra_space;
130	if (packing_changed) {
131	priv->x = child_allocation.x;
132	priv->y = top_y;
133	if (priv->operation == DRAG_OPERATION_REORDER
134	&& page->pack == notebook->cur_page->pack) {
135	if (!allocate_at_bottom
136	&& top_y >= anchor
137	&& top_y <=
138	anchor +
139	child_allocation.height / 2)
140	anchor +=
141	notebook->cur_page->
142	allocation.height -
143	tab_overlap;
144	}
145	}
146	}
147	if ((page == priv->detached_tab
148	&& priv->operation == DRAG_OPERATION_DETACH)
149	\|\| (page == notebook->cur_page
150	&& priv->operation == DRAG_OPERATION_REORDER)) {
151	page->allocation.x = 0;
152	}
153	if (page != notebook->cur_page) {
154	switch (tab_pos) {
155	case GTK_POS_TOP:
156	page->allocation.y += ythickness;
157	case GTK_POS_BOTTOM:
158	page->allocation.height =
159	1 > page->allocation.height - ythickness ? 1 : page->allocation.
160	height -
161	ythickness;
162	break;
163	case GTK_POS_LEFT:
164	page->allocation.x += xthickness;
165	case GTK_POS_RIGHT:
166	page->allocation.width =
167	1 > page->allocation.width - xthickness ? 1 : page->allocation.width - xthickness;
168	}
169	}
170	switch (tab_pos) {
171	case GTK_POS_TOP:
172	case GTK_POS_BOTTOM:
173	if (
174	priv->operation != DRAG_OPERATION_REORDER \|\|
175	priv->operation == DRAG_OPERATION_REORDER
176	&& page != notebook->cur_page
177	)
178	if (!allocate_at_bottom)
179	anchor +=
180	child_allocation.width -
181	tab_overlap;
182	case GTK_POS_LEFT:
183	case GTK_POS_RIGHT:
184	if (priv->operation != DRAG_OPERATION_REORDER
185	\|\| priv->operation == DRAG_OPERATION_REORDER
186	&& page != notebook->cur_page)
187	if (priv->operation == DRAG_OPERATION_REORDER)
188	if (page->pack ==
189	notebook->cur_page->pack
190	&& !allocate_at_bottom
191	&& top_y >=
192	anchor + child_allocation.height / 2
193	&& top_y <=
194	anchor + child_allocation.height)
195	anchor +=
196	notebook->cur_page->
197	allocation.height -
198	tab_overlap;
199	}
200	if (page->tab_label)
201	IA__gtk_widget_set_child_visible(page->tab_label, 1);
202	}
203	}