Fsb.c- Fsb.h
- FsbP.h
- Grid.c
- Grid.h
- Makefile
- button.c
- button.h
- container.c
- container.h
- dnd.c
- dnd.h
- entry.c
- entry.h
- graphics.c
- graphics.h
- image.c
- image.h
- label.c
- label.h
- list.c
- list.h
- menu.c
- menu.h
- objs.mk
- pathbar.c
- pathbar.h
- range.c
- range.h
- text.c
- text.h
- toolbar.c
- toolbar.h
- toolkit.c
- toolkit.h
- widget.c
- window.c
- window.h
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright 2024 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.
*/
/*
*
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Grid.h"
#include <X11/Xlib.h>
static XtActionsRec actionslist[] = {
{"getfocus",grid_getfocus},
{"loosefocus",grid_loosefocus},
{"NULL",NULL}
};
//static char defaultTranslations[] = "<BtnDown>: mousedown()\n";
static char defaultTranslations[] = "\
<EnterWindow>: getfocus()\n\
<LeaveWindow>: loosefocus()\n";
static XtResource resources[] =
{
{
gridColumnSpacing,
gridColumnSpacing,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridRec,
grid.columnspacing),
XmRImmediate,
(XtPointer) 0
},
{
gridRowSpacing,
gridRowSpacing,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridRec,
grid.rowspacing),
XmRImmediate,
(XtPointer) 0
},
{
gridPaddingLeft,
gridPaddingLeft,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridRec,
grid.padding_left),
XmRImmediate,
(XtPointer) 0
},
{
gridPaddingRight,
gridPaddingRight,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridRec,
grid.padding_right),
XmRImmediate,
(XtPointer) 0
},
{
gridPaddingTop,
gridPaddingTop,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridRec,
grid.padding_top),
XmRImmediate,
(XtPointer) 0
},
{
gridPaddingBottom,
gridPaddingBottom,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridRec,
grid.padding_bottom),
XmRImmediate,
(XtPointer) 0
}
};
///*
static XtResource constraints[] =
{
{
gridColumn,
gridColumn,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.x),
XmRImmediate,
(XtPointer) 0
},
{
gridRow,
gridRow,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.y),
XmRImmediate,
(XtPointer) 0
},
{
gridColspan,
gridColspan,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.colspan),
XmRImmediate,
(XtPointer) 0
},
{
gridRowspan,
gridRowspan,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.rowspan),
XmRImmediate,
(XtPointer) 0
},
{
gridMarginLeft,
gridMarginLeft,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.margin_left),
XmRImmediate,
(XtPointer) 0
},
{
gridMarginRight,
gridMarginRight,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.margin_right),
XmRImmediate,
(XtPointer) 0
},
{
gridMarginTop,
gridMarginTop,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.margin_top),
XmRImmediate,
(XtPointer) 0
},
{
gridMarginBottom,
gridMarginBottom,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.margin_bottom),
XmRImmediate,
(XtPointer) 0
},
{
gridHExpand,
gridHExpand,
XmRBoolean,
sizeof (Boolean),
XtOffsetOf( GridConstraintRec,
grid.hexpand),
XmRImmediate,
(XtPointer) 0
},
{
gridVExpand,
gridVExpand,
XmRBoolean,
sizeof (Boolean),
XtOffsetOf( GridConstraintRec,
grid.vexpand),
XmRImmediate,
(XtPointer) 0
},
{
gridHFill,
gridHFill,
XmRBoolean,
sizeof (Boolean),
XtOffsetOf( GridConstraintRec,
grid.hfill),
XmRImmediate,
(XtPointer) 0
},
{
gridVFill,
gridVFill,
XmRBoolean,
sizeof (Boolean),
XtOffsetOf( GridConstraintRec,
grid.vfill),
XmRImmediate,
(XtPointer) 0
},
{
gridMinWidth,
gridMinWidth,
XmRDimension,
sizeof (Dimension),
XtOffsetOf( GridConstraintRec,
grid.min_width),
XmRImmediate,
(XtPointer) 0
}
};
//*/
GridClassRec gridClassRec = {
// Core Class
{
//(WidgetClass)&constraintClassRec, // superclass
(WidgetClass)&xmManagerClassRec,
"Grid", // class_name
sizeof(GridRec), // widget_size
grid_class_initialize, // class_initialize
NULL, // class_part_initialize
FALSE, // class_inited
(XtInitProc)grid_initialize, // initialize
NULL, // initialize_hook
grid_realize, // realize
actionslist, // actions
XtNumber(actionslist), // num_actions
resources, // resources
XtNumber(resources), // num_resources
NULLQUARK, // xrm_class
True, // compress_motion
True, // compress_exposure
True, // compress_enterleave
False, // visible_interest
(XtWidgetProc)grid_destroy, // destroy
(XtWidgetProc)grid_resize, // resize
(XtExposeProc)grid_expose, // expose
grid_set_values, // set_values
NULL, // set_values_hook
XtInheritSetValuesAlmost, // set_values_almost
NULL, // get_values_hook
(XtAcceptFocusProc)grid_acceptfocus, // accept_focus
XtVersion, // version
NULL, // callback_offsets
//NULL, // tm_table
defaultTranslations,
XtInheritQueryGeometry, // query_geometry
NULL, // display_accelerator
NULL, // extension
},
// Composite Class
{
GridGeometryManager, /* geometry_manager */
GridChangeManaged, /* change_managed */
XtInheritInsertChild, /* insert_child */
XtInheritDeleteChild, /* delete_child */
NULL, /* extension */
},
// Constraint Class
{
constraints, /* resources */
XtNumber(constraints), /* num_resources */
sizeof(GridConstraintRec), /* constraint_size */
grid_constraint_init, /* initialize */
NULL, /* destroy */
ConstraintSetValues, /* set_values */
NULL, /* extension */
},
// XmManager Class
///*
{
XtInheritTranslations,
NULL,
0,
NULL,
0,
XmInheritParentProcess,
NULL
},
//*/
// MyWidget Class
{
0
}
};
WidgetClass gridClass = (WidgetClass)&gridClassRec;
void grid_class_initialize(void) {
}
void grid_initialize(Widget request, Widget new, ArgList args, Cardinal num_args) {
Grid mn = (Grid)new;
mn->grid.max_col = 0;
mn->grid.max_row = 0;
}
void grid_realize(Widget w,XtValueMask *valueMask,XSetWindowAttributes *attributes) {
Grid grid = (Grid)w;
XtMakeResizeRequest(w, 400, 400, NULL, NULL);
(coreClassRec.core_class.realize)((Widget)w, valueMask, attributes);
grid_place_children(grid);
}
void grid_destroy(Grid widget) {
}
void grid_resize(Grid widget) {
grid_place_children(widget);
}
void grid_expose(Grid widget, XEvent *event, Region region) {
}
Boolean grid_set_values(Widget old, Widget request, Widget neww, ArgList args, Cardinal *num_args) {
return False;
}
Boolean grid_acceptfocus(Widget w, Time *t) {
}
void grid_getfocus(Widget myw, XEvent *event, String *params, Cardinal *nparam) {
}
void grid_loosefocus(Widget myw, XEvent *event, String *params, Cardinal *nparam) {
}
XtGeometryResult GridGeometryManager(Widget widget, XtWidgetGeometry *request, XtWidgetGeometry *reply) {
GridRec *grid = (GridRec*)XtParent(widget);
GridConstraintRec *constraints = widget->core.constraints;
//XtVaSetValues(widget, XmNwidth, request->width, XmNheight, request->height, NULL);
if((request->request_mode & CWWidth) == CWWidth) {
widget->core.width = request->width;
constraints->grid.pref_width = request->width;
}
if((request->request_mode & CWHeight) == CWHeight) {
widget->core.height = request->height;
constraints->grid.pref_height = request->height;
}
grid_place_children((Grid)XtParent(widget));
return XtGeometryYes;
}
void GridChangeManaged(Widget widget) {
grid_place_children((Grid)widget);
}
Boolean ConstraintSetValues(Widget old, Widget request, Widget neww, ArgList args, Cardinal *num_args) {
GridConstraintRec *constraints = neww->core.constraints;
Grid grid = (Grid)XtParent(neww);
if(constraints->grid.x > grid->grid.max_col) {
grid->grid.max_col = constraints->grid.x;
}
if(constraints->grid.y > grid->grid.max_row) {
grid->grid.max_row = constraints->grid.y;
}
}
void grid_constraint_init(
Widget request,
Widget neww,
ArgList args,
Cardinal* num_args
)
{
GridConstraintRec *constraints = neww->core.constraints;
Grid grid = (Grid)XtParent(neww);
if(constraints->grid.x > grid->grid.max_col) {
grid->grid.max_col = constraints->grid.x;
}
if(constraints->grid.y > grid->grid.max_row) {
grid->grid.max_row = constraints->grid.y;
}
constraints->grid.pref_width = neww->core.width;
constraints->grid.pref_height = neww->core.height;
}
void grid_place_children(Grid w) {
if(!XtIsRealized((Widget)w)) {
return;
}
int ncols = w->grid.max_col+1;
int nrows = w->grid.max_row+1;
GridDef *cols = calloc(ncols, sizeof(GridDef));
GridDef *rows = calloc(nrows, sizeof(GridDef));
int num_cols_expanding = 0;
int num_rows_expanding = 0;
int req_width = w->grid.padding_left + w->grid.padding_right;
int req_height = w->grid.padding_top + w->grid.padding_bottom;
int width = w->core.width;
int height = w->core.height;
//printf("container width: %d\n", (int)w->core.width);
// calculate the minimum size requirements for all columns and rows
// we need to run this 2 times: for widgets without colspan/rowspan first
// and then again for colspan/rowspan > 1
int span_max = 1;
for(int r=0;r<2;r++) {
for(int i=0;i<w->composite.num_children;i++) {
Widget child = w->composite.children[i];
GridConstraintRec *constraints = child->core.constraints;
if(constraints->grid.pref_width == 0) {
constraints->grid.pref_width = child->core.width;
}
if(constraints->grid.pref_height == 0) {
constraints->grid.pref_height = child->core.height;
}
if(constraints->grid.pref_width < constraints->grid.min_width) {
constraints->grid.pref_width = constraints->grid.min_width;
}
int elm_width = constraints->grid.pref_width + constraints->grid.margin_left + constraints->grid.margin_right;
int elm_height = constraints->grid.pref_height + constraints->grid.margin_top + constraints->grid.margin_bottom;
if(!XtIsManaged(child)) {
elm_width = 0;
elm_height = 0;
}
if(constraints->grid.colspan > span_max || constraints->grid.rowspan > span_max) {
continue;
}
int x = constraints->grid.x;
int y = constraints->grid.y;
// make sure ncols/nrows is correct
// errors shouldn't happen, unless someone messes up the grid internals
if(x >= ncols) {
fprintf(stderr, "Error: widget x out of bounds\n");
continue;
}
if(y >= nrows) {
fprintf(stderr, "Error: widget y out of bounds\n");
continue;
}
GridDef *col = &cols[x];
GridDef *row = &rows[y];
if(constraints->grid.hexpand) {
if(constraints->grid.colspan > 1) {
// check if any column in the span is expanding
// if not, make the last column expanding
GridDef *last_col = col;
for(int c=x;c<ncols;c++) {
last_col = &cols[c];
if(last_col->expand) {
break;
}
}
last_col->expand = TRUE;
} else {
col->expand = TRUE;
}
}
if(constraints->grid.vexpand) {
if(constraints->grid.rowspan > 1) {
GridDef *last_row = row;
for(int c=x;c<nrows;c++) {
last_row = &rows[c];
if(last_row->expand) {
break;
}
}
last_row->expand = TRUE;
} else {
row->expand = TRUE;
}
}
// column size
if(constraints->grid.colspan > 1) {
// check size of all columns in span
Dimension span_width = col->size;
GridDef *last_col = col;
for(int s=x+1;s<ncols;s++) {
last_col = &cols[s];
span_width = last_col->size;
}
int diff = elm_width - span_width;
if(diff > 0) {
last_col->size += diff;
}
} else if(elm_width > col->size) {
col->size = elm_width;
}
// row size
if(constraints->grid.rowspan > 1) {
Dimension span_height = row->size;
GridDef *last_row = row;
for(int s=x+1;s<nrows;s++) {
last_row = &rows[s];
span_height = last_row->size;
}
int diff = elm_height - span_height;
if(diff > 0) {
last_row->size += diff;
}
} else if(elm_height > row->size) {
row->size = elm_height;
}
}
span_max = 50000; // not sure if this is unreasonable low or high
}
// calc required size
for(int i=0;i<ncols;i++) {
if(cols[i].expand) {
num_cols_expanding++;
}
req_width += cols[i].size;
}
for(int i=0;i<nrows;i++) {
if(rows[i].expand) {
num_rows_expanding++;
}
req_height += rows[i].size;
}
int total_colspacing = 0;
int total_rowspacing = 0;
for(int i=0;i+1<ncols;i++) {
if(cols[i].size > 0) {
total_colspacing += w->grid.columnspacing;
}
}
for(int i=0;i+1<nrows;i++) {
if(rows[i].size > 0) {
total_rowspacing += w->grid.rowspacing;
}
}
if(req_width > 0 && req_height > 0) {
// add col/row spacing
req_width += total_colspacing; //(ncols-1)*w->grid.columnspacing;
req_height += total_rowspacing; //(nrows-1)*w->grid.rowspacing;
Widget parent = w->core.parent;
Dimension rwidth = req_width;
Dimension rheight = req_height;
if(rwidth < w->core.width) {
//rwidth = w->core.width;
}
if(rheight < w->core.height) {
//rheight = w->core.height;
}
if(!w->grid.sizerequest) {
Dimension actual_width, actual_height;
w->grid.sizerequest = TRUE;
//printf("sizerequest: %d x %d\n", (int)req_width, (int)req_height);
//XtWidgetGeometry request;
//request.width = req_width;
//request.request_mode = CWWidth;
//XtWidgetGeometry reply;
//XtGeometryResult result = XtMakeGeometryRequest((Widget)w, &request, &reply);
XtMakeResizeRequest((Widget)w, req_width, req_height, &actual_width, &actual_height);
w->grid.sizerequest = FALSE;
//printf("size request: %d %d\n", (int)actual_width, (int)actual_height);
}
}
// how much space can we add to each expanding col/row
int hexpand = 0;
int width_diff = width - req_width;
int hexpand2 = 0;
if(width_diff > 0 && num_cols_expanding > 0) {
hexpand = width_diff / num_cols_expanding;
hexpand2 = width_diff-hexpand*num_cols_expanding;
}
int x = w->grid.padding_left;
for(int i=0;i<ncols;i++) {
cols[i].pos = x;
if(cols[i].expand) {
cols[i].size += hexpand + hexpand2;
}
if(cols[i].size > 0) {
x += cols[i].size + w->grid.columnspacing;
}
hexpand2 = 0;
}
int vexpand = 0;
int height_diff = height - req_height;
int vexpand2 = 0;
if(height_diff > 0 && num_rows_expanding > 0) {
vexpand = height_diff / num_rows_expanding;
vexpand2 = height_diff-vexpand*num_rows_expanding;
}
int y = w->grid.padding_bottom;
for(int i=0;i<nrows;i++) {
rows[i].pos = y;
if(rows[i].expand) {
rows[i].size += vexpand + vexpand2;
}
if(rows[i].size > 0) {
y += rows[i].size += w->grid.rowspacing;
}
vexpand2 = 0;
}
for(int i=0;i<w->composite.num_children;i++) {
Widget child = w->composite.children[i];
GridConstraintRec *constraints = child->core.constraints;
GridDef c = cols[constraints->grid.x];
GridDef r = rows[constraints->grid.y];
int x = c.pos + constraints->grid.margin_left;
int y = r.pos + constraints->grid.margin_top;
int width = constraints->grid.pref_width;
int height = constraints->grid.pref_height;
if(constraints->grid.hfill) {
if(constraints->grid.colspan > 1) {
Dimension cwidth = 0;
for(int j=0;j<constraints->grid.colspan;j++) {
if(constraints->grid.x+j < ncols) {
cwidth += cols[constraints->grid.x+j].size + (j > 0 ? w->grid.columnspacing : 0);
}
}
width = cwidth;
} else {
width = c.size - w->grid.columnspacing - constraints->grid.margin_left - constraints->grid.margin_right;
}
}
if(constraints->grid.vfill) {
if(constraints->grid.rowspan > 1) {
Dimension cheight = 0;
for(int j=0;j<constraints->grid.rowspan;j++) {
if(constraints->grid.y+j < nrows) {
cheight += rows[constraints->grid.y+j].size + (j > 0 ? w->grid.rowspacing : 0);
}
}
height = cheight;
} else {
height = r.size - w->grid.rowspacing - constraints->grid.margin_top - constraints->grid.margin_bottom;
}
}
if(width > 0 && height > 0) {
XtConfigureWidget(child, x, y, width, height, child->core.border_width);
}
//printf("child %d %d - %d %d\n", (int)child->core.x, (int)child->core.y, (int)child->core.width, (int)child->core.height);
}
free(cols);
free(rows);
}