Final cleanup, first part: renamed uiTableData to uiTableValue.

common/CMakeLists.txt

@@ -7,12 +7,10 @@ list(APPEND _LIBUI_SOURCES
 	common/areaevents.c
 	common/control.c
 	common/debug.c
-#	common/drawtext.c
 	common/matrix.c
 	common/opentype.c
 	common/shouldquit.c
-#	common/table.c
+	common/tablevalue.c
-	common/tabledata.c
 	common/userbugs.c
 	common/utf.c
 )

common/tabledata.c

@@ -1,105 +0,0 @@
-// 3 june 2018
-#include "../ui.h"
-#include "uipriv.h"
-
-struct uiTableData {
-	uiTableDataType type;
-	union {
-		char *str;
-		uiImage *img;
-		int i;
-		struct {
-			double r;
-			double g;
-			double b;
-			double a;
-		} color;
-	} u;
-};
-
-static uiTableData *newTableData(uiTableDataType type)
-{
-	uiTableData *d;
-
-	d = uiprivNew(uiTableData);
-	d->type = type;
-	return d;
-}
-
-void uiFreeTableData(uiTableData *d)
-{
-	switch (d->type) {
-	case uiTableDataTypeString:
-		uiprivFree(d->u.str);
-		break;
-	}
-	uiprivFree(d);
-}
-
-uiTableDataType uiTableDataGetType(const uiTableData *d)
-{
-	return d->type;
-}
-
-uiTableData *uiNewTableDataString(const char *str)
-{
-	uiTableData *d;
-
-	d = newTableData(uiTableDataTypeString);
-	d->u.str = (char *) uiprivAlloc((strlen(str) + 1) * sizeof (char), "char[] (uiTableData)");
-	strcpy(d->u.str, str);
-	return d;
-}
-
-const char *uiTableDataString(const uiTableData *d)
-{
-	return d->u.str;
-}
-
-uiTableData *uiNewTableDataImage(uiImage *img)
-{
-	uiTableData *d;
-
-	d = newTableData(uiTableDataTypeImage);
-	d->u.img = img;
-	return d;
-}
-
-uiImage *uiTableDataImage(const uiTableData *d)
-{
-	return d->u.img;
-}
-
-uiTableData *uiNewTableDataInt(int i)
-{
-	uiTableData *d;
-
-	d = newTableData(uiTableDataTypeInt);
-	d->u.i = i;
-	return d;
-}
-
-int uiTableDataInt(const uiTableData *d)
-{
-	return d->u.i;
-}
-
-uiTableData *uiNewTableDataColor(double r, double g, double b, double a)
-{
-	uiTableData *d;
-
-	d = newTableData(uiTableDataTypeColor);
-	d->u.color.r = r;
-	d->u.color.g = g;
-	d->u.color.b = b;
-	d->u.color.a = a;
-	return d;
-}
-
-void uiTableDataColor(const uiTableData *d, double *r, double *g, double *b, double *a)
-{
-	*r = d->u.color.r;
-	*g = d->u.color.g;
-	*b = d->u.color.b;
-	*a = d->u.color.a;
-}

common/tablevalue.c

@@ -0,0 +1,105 @@
+// 3 june 2018
+#include "../ui.h"
+#include "uipriv.h"
+
+struct uiTableValue {
+	uiTableValueType type;
+	union {
+		char *str;
+		uiImage *img;
+		int i;
+		struct {
+			double r;
+			double g;
+			double b;
+			double a;
+		} color;
+	} u;
+};
+
+static uiTableValue *newTableValue(uiTableValueType type)
+{
+	uiTableValue *v;
+
+	v = uiprivNew(uiTableValue);
+	v->type = type;
+	return v;
+}
+
+void uiFreeTableValue(uiTableValue *v)
+{
+	switch (v->type) {
+	case uiTableValueTypeString:
+		uiprivFree(v->u.str);
+		break;
+	}
+	uiprivFree(v);
+}
+
+uiTableValueType uiTableValueGetType(const uiTableValue *v)
+{
+	return v->type;
+}
+
+uiTableValue *uiNewTableValueString(const char *str)
+{
+	uiTableValue *v;
+
+	v = newTableValue(uiTableValueTypeString);
+	v->u.str = (char *) uiprivAlloc((strlen(str) + 1) * sizeof (char), "char[] (uiTableValue)");
+	strcpy(v->u.str, str);
+	return v;
+}
+
+const char *uiTableValueString(const uiTableValue *v)
+{
+	return v->u.str;
+}
+
+uiTableValue *uiNewTableValueImage(uiImage *img)
+{
+	uiTableValue *v;
+
+	v = newTableValue(uiTableValueTypeImage);
+	v->u.img = img;
+	return v;
+}
+
+uiImage *uiTableValueImage(const uiTableValue *v)
+{
+	return v->u.img;
+}
+
+uiTableValue *uiNewTableValueInt(int i)
+{
+	uiTableValue *v;
+
+	v = newTableValue(uiTableValueTypeInt);
+	v->u.i = i;
+	return v;
+}
+
+int uiTableValueInt(const uiTableValue *v)
+{
+	return v->u.i;
+}
+
+uiTableValue *uiNewTableValueColor(double r, double g, double b, double a)
+{
+	uiTableValue *v;
+
+	v = newTableValue(uiTableValueTypeColor);
+	v->u.color.r = r;
+	v->u.color.g = g;
+	v->u.color.b = b;
+	v->u.color.a = a;
+	return v;
+}
+
+void uiTableValueColor(const uiTableValue *v, double *r, double *g, double *b, double *a)
+{
+	*r = v->u.color.r;
+	*g = v->u.color.g;
+	*b = v->u.color.b;
+	*a = v->u.color.a;
+}

darwin/table.m

@@ -31,16 +31,16 @@
 // TODO is this correct for overflow scrolling?
 static void setBackgroundColor(uiprivTableView *t, NSTableRowView *rv, NSInteger row)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	NSColor *color;
 	double r, g, b, a;
 
 	if (t->uiprivT->backgroundColumn == -1)
 		return;
-	data = (*(t->uiprivM->mh->CellValue))(t->uiprivM->mh, t->uiprivM, row, t->uiprivT->backgroundColumn);
+	value = (*(t->uiprivM->mh->CellValue))(t->uiprivM->mh, t->uiprivM, row, t->uiprivT->backgroundColumn);
-	if (data != NULL) {
+	if (value != NULL) {
-		uiTableDataColor(data, &r, &g, &b, &a);
+		uiTableValueColor(value, &r, &g, &b, &a);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 		color = [NSColor colorWithSRGBRed:r green:g blue:b alpha:a];
 	} else {
 		NSArray *colors;

darwin/tablecolumn.m

@@ -36,8 +36,8 @@
 
 static BOOL isCellEditable(uiTableModel *m, NSInteger row, int modelColumn)
 {
-	uiTableData *data;
+	uiTableValue *value;
-	int value;
+	int editable;
 
 	switch (modelColumn) {
 	case uiTableModelColumnNeverEditable:
@@ -45,11 +45,10 @@ static BOOL isCellEditable(uiTableModel *m, NSInteger row, int modelColumn)
 	case uiTableModelColumnAlwaysEditable:
 		return YES;
 	}
-	data = (*(m->mh->CellValue))(m->mh, m, row, modelColumn);
+	value = (*(m->mh->CellValue))(m->mh, m, row, modelColumn);
-	value = uiTableDataInt(data);
+	editable = uiTableValueInt(value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
-	return value != 0;
+	return editable != 0;
-	// TODO free data
 }
 
 static uiTableTextColumnOptionalParams defaultTextColumnOptionalParams = {
@@ -266,15 +265,15 @@ struct textColumnCreateParams {
 
 - (void)uiprivUpdate:(NSInteger)row
 {
-	uiTableData *data;
+	uiTableValue *value;
 
 	if (self->tf != nil) {
 		NSString *str;
 		NSColor *color;
 
-		data = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->textModelColumn);
+		value = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->textModelColumn);
-		str = uiprivToNSString(uiTableDataString(data));
+		str = uiprivToNSString(uiTableValueString(value));
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 		[self->tf setStringValue:str];
 
 		[self->tf setEditable:isCellEditable(self->m, row, self->textEditableColumn)];
@@ -283,11 +282,11 @@ struct textColumnCreateParams {
 		if (self->textParams.ColorModelColumn != -1) {
 			double r, g, b, a;
 
-			data = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->textParams.ColorModelColumn);
+			value = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->textParams.ColorModelColumn);
 			// TODO document this is allowed
-			if (data != NULL) {
+			if (value != NULL) {
-				uiTableDataColor(data, &r, &g, &b, &a);
+				uiTableValueColor(value, &r, &g, &b, &a);
-				uiFreeTableData(data);
+				uiFreeTableValue(value);
 				color = [NSColor colorWithSRGBRed:r green:g blue:b alpha:a];
 			}
 		}
@@ -299,18 +298,18 @@ struct textColumnCreateParams {
 	if (self->iv != nil) {
 		uiImage *img;
 
-		data = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->imageModelColumn);
+		value = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->imageModelColumn);
-		img = uiTableDataImage(data);
+		img = uiTableValueImage(value);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 		[self->iv setImage:uiprivImageNSImage(img)];
 	}
 	if (self->cb != nil) {
-		data = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->imageModelColumn);
+		value = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->imageModelColumn);
-		if (uiTableDataInt(data) != 0)
+		if (uiTableValueInt(value) != 0)
 			[self->cb setState:NSOnState];
 		else
 			[self->cb setState:NSOffState];
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 
 		[self->cb setEnabled:isCellEditable(self->m, row, self->checkboxEditableColumn)];
 	}
@@ -319,13 +318,13 @@ struct textColumnCreateParams {
 - (IBAction)uiprivOnTextFieldAction:(id)sender
 {
 	NSInteger row;
-	uiTableData *data;
+	uiTableValue *value;
 
 	row = [self->t->tv rowForView:self->tf];
-	data = uiNewTableDataString([[self->tf stringValue] UTF8String]);
+	value = uiNewTableValueString([[self->tf stringValue] UTF8String]);
 	(*(self->m->mh->SetCellValue))(self->m->mh, self->m,
-		row, self->textModelColumn, data);
+		row, self->textModelColumn, value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	// always refresh the value in case the model rejected it
 	// TODO document that we do this, but not for the whole row (or decide to do both, or do neither...)
 	[self uiprivUpdate:row];
@@ -334,13 +333,13 @@ struct textColumnCreateParams {
 - (IBAction)uiprivOnCheckboxAction:(id)sender
 {
 	NSInteger row;
-	void *data;
+	uiTableValue *value;
 
 	row = [self->t->tv rowForView:self->cb];
-	data = uiNewTableDataInt([self->cb state] != NSOffState);
+	value = uiNewTableValueInt([self->cb state] != NSOffState);
 	(*(self->m->mh->SetCellValue))(self->m->mh, self->m,
-		row, self->checkboxModelColumn, data);
+		row, self->checkboxModelColumn, value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	// always refresh the value in case the model rejected it
 	[self uiprivUpdate:row];
 }
@@ -434,16 +433,16 @@ struct textColumnCreateParams {
 
 - (void)uiprivUpdate:(NSInteger)row
 {
-	uiTableData *data;
+	uiTableValue *value;
-	int value;
+	int progress;
 
-	data = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->modelColumn);
+	value = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->modelColumn);
-	value = uiTableDataInt(data);
+	progress = uiTableValueInt(value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
-	if (value == -1) {
+	if (progress == -1) {
 		[self->p setIndeterminate:YES];
 		[self->p startAnimation:self->p];
-	} else if (value == 100) {
+	} else if (progress == 100) {
 		[self->p setIndeterminate:NO];
 		[self->p setMaxValue:101];
 		[self->p setDoubleValue:101];
@@ -451,8 +450,8 @@ struct textColumnCreateParams {
 		[self->p setMaxValue:100];
 	} else {
 		[self->p setIndeterminate:NO];
-		[self->p setDoubleValue:(value + 1)];
+		[self->p setDoubleValue:(progress + 1)];
-		[self->p setDoubleValue:value];
+		[self->p setDoubleValue:progress];
 	}
 }
 
@@ -557,12 +556,12 @@ struct textColumnCreateParams {
 
 - (void)uiprivUpdate:(NSInteger)row
 {
-	uiTableData *data;
+	uiTableValue *value;
 	NSString *str;
 
-	data = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->modelColumn);
+	value = (*(self->m->mh->CellValue))(self->m->mh, self->m, row, self->modelColumn);
-	str = uiprivToNSString(uiTableDataString(data));
+	str = uiprivToNSString(uiTableValueString(value));
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	[self->b setTitle:str];
 
 	[self->b setEnabled:isCellEditable(self->m, row, self->editableColumn)];

test/page16.c

@@ -8,15 +8,15 @@ static int modelNumColumns(uiTableModelHandler *mh, uiTableModel *m)
 	return 9;
 }
 
-static uiTableDataType modelColumnType(uiTableModelHandler *mh, uiTableModel *m, int column)
+static uiTableValueType modelColumnType(uiTableModelHandler *mh, uiTableModel *m, int column)
 {
 	if (column == 3 || column == 4)
-		return uiTableDataTypeColor;
+		return uiTableValueTypeColor;
 	if (column == 5)
-		return uiTableDataTypeImage;
+		return uiTableValueTypeImage;
 	if (column == 7 || column == 8)
-		return uiTableDataTypeInt;
+		return uiTableValueTypeInt;
-	return uiTableDataTypeString;
+	return uiTableValueTypeString;
 }
 
 static int modelNumRows(uiTableModelHandler *mh, uiTableModel *m)
@@ -29,39 +29,39 @@ static char row9text[1024];
 static int yellowRow = -1;
 static int checkStates[15];
 
-static uiTableData *modelCellValue(uiTableModelHandler *mh, uiTableModel *m, int row, int col)
+static uiTableValue *modelCellValue(uiTableModelHandler *mh, uiTableModel *m, int row, int col)
 {
 	char buf[256];
 
 	if (col == 3) {
 		if (row == yellowRow)
-			return uiNewTableDataColor(1, 1, 0, 1);
+			return uiNewTableValueColor(1, 1, 0, 1);
 		if (row == 3)
-			return uiNewTableDataColor(1, 0, 0, 1);
+			return uiNewTableValueColor(1, 0, 0, 1);
 		if (row == 11)
-			return uiNewTableDataColor(0, 0.5, 1, 0.5);
+			return uiNewTableValueColor(0, 0.5, 1, 0.5);
 		return NULL;
 	}
 	if (col == 4) {
 		if ((row % 2) == 1)
-			return uiNewTableDataColor(0.5, 0, 0.75, 1);
+			return uiNewTableValueColor(0.5, 0, 0.75, 1);
 		return NULL;
 	}
 	if (col == 5) {
 		if (row < 8)
-			return uiNewTableDataImage(img[0]);
+			return uiNewTableValueImage(img[0]);
-		return uiNewTableDataImage(img[1]);
+		return uiNewTableValueImage(img[1]);
 	}
 	if (col == 7)
-		return uiNewTableDataInt(checkStates[row]);
+		return uiNewTableValueInt(checkStates[row]);
 	if (col == 8) {
 		if (row == 0)
-			return uiNewTableDataInt(0);
+			return uiNewTableValueInt(0);
 		if (row == 13)
-			return uiNewTableDataInt(100);
+			return uiNewTableValueInt(100);
 		if (row == 14)
-			return uiNewTableDataInt(-1);
+			return uiNewTableValueInt(-1);
-		return uiNewTableDataInt(50);
+		return uiNewTableValueInt(50);
 	}
 	switch (col) {
 	case 0:
@@ -69,7 +69,7 @@ static uiTableData *modelCellValue(uiTableModelHandler *mh, uiTableModel *m, int
 		break;
 	case 2:
 		if (row == 9)
-			return uiNewTableDataString(row9text);
+			return uiNewTableValueString(row9text);
 		// fall through
 	case 1:
 		strcpy(buf, "Part");
@@ -78,13 +78,13 @@ static uiTableData *modelCellValue(uiTableModelHandler *mh, uiTableModel *m, int
 		strcpy(buf, "Make Yellow");
 		break;
 	}
-	return uiNewTableDataString(buf);
+	return uiNewTableValueString(buf);
 }
 
-static void modelSetCellValue(uiTableModelHandler *mh, uiTableModel *m, int row, int col, const uiTableData *val)
+static void modelSetCellValue(uiTableModelHandler *mh, uiTableModel *m, int row, int col, const uiTableValue *val)
 {
 	if (row == 9 && col == 2)
-		strcpy(row9text, uiTableDataString(val));
+		strcpy(row9text, uiTableValueString(val));
 	if (col == 6) {
 		int prevYellowRow;
 
@@ -95,7 +95,7 @@ static void modelSetCellValue(uiTableModelHandler *mh, uiTableModel *m, int row,
 		uiTableModelRowChanged(m, yellowRow);
 	}
 	if (col == 7)
-		checkStates[row] = uiTableDataInt(val);
+		checkStates[row] = uiTableValueInt(val);
 }
 
 uiBox *makePage16(void)

uitable.h

@@ -8,32 +8,32 @@ _UI_EXTERN uiImage *uiNewImage(double width, double height);
 _UI_EXTERN void uiFreeImage(uiImage *i);
 _UI_EXTERN void uiImageAppend(uiImage *i, void *pixels, int pixelWidth, int pixelHeight, int pixelStride);
 
-typedef struct uiTableData uiTableData;
+typedef struct uiTableValue uiTableValue;
 
-_UI_EXTERN void uiFreeTableData(uiTableData *d);
+_UI_EXTERN void uiFreeTableValue(uiTableValue *v);
 
 // TODO actually validate these
-_UI_ENUM(uiTableDataType) {
+_UI_ENUM(uiTableValueType) {
-	uiTableDataTypeString,
+	uiTableValueTypeString,
-	uiTableDataTypeImage,
+	uiTableValueTypeImage,
-	uiTableDataTypeInt,
+	uiTableValueTypeInt,
-	uiTableDataTypeColor,
+	uiTableValueTypeColor,
 };
 
 // TODO I don't like this name
-_UI_EXTERN uiTableDataType uiTableDataGetType(const uiTableData *d);
+_UI_EXTERN uiTableValueType uiTableValueGetType(const uiTableValue *v);
 
-_UI_EXTERN uiTableData *uiNewTableDataString(const char *str);
+_UI_EXTERN uiTableValue *uiNewTableValueString(const char *str);
-_UI_EXTERN const char *uiTableDataString(const uiTableData *d);
+_UI_EXTERN const char *uiTableValueString(const uiTableValue *v);
 
-_UI_EXTERN uiTableData *uiNewTableDataImage(uiImage *img);
+_UI_EXTERN uiTableValue *uiNewTableValueImage(uiImage *img);
-_UI_EXTERN uiImage *uiTableDataImage(const uiTableData *d);
+_UI_EXTERN uiImage *uiTableValueImage(const uiTableValue *v);
 
-_UI_EXTERN uiTableData *uiNewTableDataInt(int i);
+_UI_EXTERN uiTableValue *uiNewTableValueInt(int i);
-_UI_EXTERN int uiTableDataInt(const uiTableData *d);
+_UI_EXTERN int uiTableValueInt(const uiTableValue *v);
 
-_UI_EXTERN uiTableData *uiNewTableDataColor(double r, double g, double b, double a);
+_UI_EXTERN uiTableValue *uiNewTableValueColor(double r, double g, double b, double a);
-_UI_EXTERN void uiTableDataColor(const uiTableData *d, double *r, double *g, double *b, double *a);
+_UI_EXTERN void uiTableValueColor(const uiTableValue *v, double *r, double *g, double *b, double *a);
 
 typedef struct uiTableModel uiTableModel;
 typedef struct uiTableModelHandler uiTableModelHandler;
@@ -41,10 +41,10 @@ typedef struct uiTableModelHandler uiTableModelHandler;
 // TODO validate ranges; validate types on each getter/setter call (? table columns only?)
 struct uiTableModelHandler {
 	int (*NumColumns)(uiTableModelHandler *, uiTableModel *);
-	uiTableDataType (*ColumnType)(uiTableModelHandler *, uiTableModel *, int);
+	uiTableValueType (*ColumnType)(uiTableModelHandler *, uiTableModel *, int);
 	int (*NumRows)(uiTableModelHandler *, uiTableModel *);
-	uiTableData *(*CellValue)(uiTableModelHandler *, uiTableModel *, int, int);
+	uiTableValue *(*CellValue)(uiTableModelHandler *, uiTableModel *, int, int);
-	void (*SetCellValue)(uiTableModelHandler *, uiTableModel *, int, int, const uiTableData *);
+	void (*SetCellValue)(uiTableModelHandler *, uiTableModel *, int, int, const uiTableValue *);
 };
 
 _UI_EXTERN uiTableModel *uiNewTableModel(uiTableModelHandler *mh);

unix/table.c

@@ -74,7 +74,7 @@ static void applyBackgroundColor(uiTable *t, GtkTreeModel *m, GtkTreeIter *iter,
 			r, "cell-background-rgba", "cell-background-set");
 }
 
-static void onEdited(uiTableModel *m, int column, const char *pathstr, const uiTableData *data, GtkTreeIter *iter)
+static void onEdited(uiTableModel *m, int column, const char *pathstr, const uiTableValue *tvalue, GtkTreeIter *iter)
 {
 	GtkTreePath *path;
 	int row;
@@ -84,7 +84,7 @@ static void onEdited(uiTableModel *m, int column, const char *pathstr, const uiT
 	if (iter != NULL)
 		gtk_tree_model_get_iter(GTK_TREE_MODEL(m), iter, path);
 	gtk_tree_path_free(path);
-	(*(m->mh->SetCellValue))(m->mh, m, row, column, data);
+	(*(m->mh->SetCellValue))(m->mh, m, row, column, tvalue);
 }
 
 // TODO deduplicate this between platforms
@@ -123,12 +123,12 @@ static void textColumnDataFunc(GtkTreeViewColumn *c, GtkCellRenderer *r, GtkTree
 static void textColumnEdited(GtkCellRendererText *r, gchar *path, gchar *newText, gpointer data)
 {
 	struct textColumnParams *p = (struct textColumnParams *) data;
-	uiTableData *tdata;
+	uiTableValue *tvalue;
 	GtkTreeIter iter;
 
-	tdata = uiNewTableDataString(newText);
+	tvalue = uiNewTableValueString(newText);
-	onEdited(p->m, p->modelColumn, path, tdata, &iter);
+	onEdited(p->m, p->modelColumn, path, tvalue, &iter);
-	uiFreeTableData(tdata);
+	uiFreeTableValue(tvalue);
 	// and update the column TODO copy comment here
 	textColumnDataFunc(NULL, GTK_CELL_RENDERER(r), GTK_TREE_MODEL(p->m), &iter, data);
 }
@@ -183,7 +183,7 @@ static void checkboxColumnToggled(GtkCellRendererToggle *r, gchar *pathstr, gpoi
 	struct checkboxColumnParams *p = (struct checkboxColumnParams *) data;
 	GValue value = G_VALUE_INIT;
 	int v;
-	uiTableData *tdata;
+	uiTableValue *tvalue;
 	GtkTreePath *path;
 	GtkTreeIter iter;
 
@@ -193,9 +193,9 @@ static void checkboxColumnToggled(GtkCellRendererToggle *r, gchar *pathstr, gpoi
 	gtk_tree_model_get_value(GTK_TREE_MODEL(p->m), &iter, p->modelColumn, &value);
 	v = g_value_get_int(&value);
 	g_value_unset(&value);
-	tdata = uiNewTableDataInt(!v);
+	tvalue = uiNewTableValueInt(!v);
-	onEdited(p->m, p->modelColumn, pathstr, tdata, NULL);
+	onEdited(p->m, p->modelColumn, pathstr, tvalue, NULL);
-	uiFreeTableData(tdata);
+	uiFreeTableValue(tvalue);
 	// and update the column TODO copy comment here
 	// TODO avoid fetching the model data twice
 	checkboxColumnDataFunc(NULL, GTK_CELL_RENDERER(r), GTK_TREE_MODEL(p->m), &iter, data);

unix/tablemodel.c

@@ -39,13 +39,13 @@ static GType uiTableModel_get_column_type(GtkTreeModel *mm, gint index)
 	uiTableModel *m = uiTableModel(mm);
 
 	switch ((*(m->mh->ColumnType))(m->mh, m, index)) {
-	case uiTableDataTypeString:
+	case uiTableValueTypeString:
 		return G_TYPE_STRING;
-	case uiTableDataTypeImage:
+	case uiTableValueTypeImage:
 		return G_TYPE_POINTER;
-	case uiTableDataTypeInt:
+	case uiTableValueTypeInt:
 		return G_TYPE_INT;
-	case uiTableDataTypeColor:
+	case uiTableValueTypeColor:
 		return GDK_TYPE_RGBA;
 	}
 	// TODO
@@ -91,38 +91,38 @@ static void uiTableModel_get_value(GtkTreeModel *mm, GtkTreeIter *iter, gint col
 {
 	uiTableModel *m = uiTableModel(mm);
 	gint row;
-	uiTableData *data;
+	uiTableValue *tvalue;
 	double r, g, b, a;
 	GdkRGBA rgba;
 
 	if (iter->stamp != STAMP_GOOD)
 		return;
 	row = GPOINTER_TO_INT(iter->user_data);
-	data = (*(m->mh->CellValue))(m->mh, m, row, column);
+	tvalue = (*(m->mh->CellValue))(m->mh, m, row, column);
 	switch ((*(m->mh->ColumnType))(m->mh, m, column)) {
-	case uiTableDataTypeString:
+	case uiTableValueTypeString:
 		g_value_init(value, G_TYPE_STRING);
-		g_value_set_string(value, uiTableDataString(data));
+		g_value_set_string(value, uiTableValueString(tvalue));
-		uiFreeTableData(data);
+		uiFreeTableValue(tvalue);
 		return;
-	case uiTableDataTypeImage:
+	case uiTableValueTypeImage:
 		g_value_init(value, G_TYPE_POINTER);
-		g_value_set_pointer(value, uiTableDataImage(data));
+		g_value_set_pointer(value, uiTableValueImage(tvalue));
-		uiFreeTableData(data);
+		uiFreeTableValue(tvalue);
 		return;
-	case uiTableDataTypeInt:
+	case uiTableValueTypeInt:
 		g_value_init(value, G_TYPE_INT);
-		g_value_set_int(value, uiTableDataInt(data));
+		g_value_set_int(value, uiTableValueInt(tvalue));
-		uiFreeTableData(data);
+		uiFreeTableValue(tvalue);
 		return;
-	case uiTableDataTypeColor:
+	case uiTableValueTypeColor:
 		g_value_init(value, GDK_TYPE_RGBA);
-		if (data == NULL) {
+		if (tvalue == NULL) {
 			g_value_set_boxed(value, NULL);
 			return;
 		}
-		uiTableDataColor(data, &r, &g, &b, &a);
+		uiTableValueColor(tvalue, &r, &g, &b, &a);
-		uiFreeTableData(data);
+		uiFreeTableValue(tvalue);
 		rgba.red = r;
 		rgba.green = g;
 		rgba.blue = b;

windows/table.cpp

@@ -188,16 +188,16 @@ static LRESULT CALLBACK tableSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM
 
 int uiprivTableProgress(uiTable *t, int item, int subitem, int modelColumn, LONG *pos)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	int progress;
 	std::pair<int, int> p;
 	std::map<std::pair<int, int>, LONG>::iterator iter;
 	bool startTimer = false;
 	bool stopTimer = false;
 
-	data = (*(t->model->mh->CellValue))(t->model->mh, t->model, item, modelColumn);
+	value = (*(t->model->mh->CellValue))(t->model->mh, t->model, item, modelColumn);
-	progress = uiTableDataInt(data);
+	progress = uiTableValueInt(value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 
 	p.first = item;
 	p.second = subitem;

windows/tabledispinfo.cpp

@@ -8,7 +8,7 @@
 static HRESULT handleLVIF_TEXT(uiTable *t, NMLVDISPINFOW *nm, uiprivTableColumnParams *p)
 {
 	int strcol;
-	uiTableData *data;
+	uiTableValue *value;
 	WCHAR *wstr;
 	int progress;
 	HRESULT hr;
@@ -22,9 +22,9 @@ static HRESULT handleLVIF_TEXT(uiTable *t, NMLVDISPINFOW *nm, uiprivTableColumnP
 	else if (p->buttonModelColumn != -1)
 		strcol = p->buttonModelColumn;
 	if (strcol != -1) {
-		data = (*(t->model->mh->CellValue))(t->model->mh, t->model, nm->item.iItem, strcol);
+		value = (*(t->model->mh->CellValue))(t->model->mh, t->model, nm->item.iItem, strcol);
-		wstr = toUTF16(uiTableDataString(data));
+		wstr = toUTF16(uiTableValueString(value));
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 		// We *could* just make pszText into a freshly allocated
 		// conversion and avoid the limitation of cchTextMax.
 		// But then, we would have to keep things around for some
@@ -59,7 +59,7 @@ static HRESULT handleLVIF_TEXT(uiTable *t, NMLVDISPINFOW *nm, uiprivTableColumnP
 
 static HRESULT handleLVIF_IMAGE(uiTable *t, NMLVDISPINFOW *nm, uiprivTableColumnParams *p)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	HRESULT hr;
 
 	if (nm->item.iSubItem == 0 && p->imageModelColumn == -1 && p->checkboxModelColumn == -1) {
@@ -75,7 +75,7 @@ static HRESULT handleLVIF_IMAGE(uiTable *t, NMLVDISPINFOW *nm, uiprivTableColumn
 		return S_OK;		// nothing to do here
 
 	// TODO see if the -1 part is correct
-	// TODO see if we should use state instead of images for checkbox data
+	// TODO see if we should use state instead of images for checkbox value
 	nm->item.iImage = -1;
 	if (p->imageModelColumn != -1 || p->checkboxModelColumn != -1)
 		nm->item.iImage = 0;

windows/tabledraw.cpp

@@ -67,7 +67,7 @@ static void centerImageRect(RECT *image, RECT *space)
 
 static HRESULT drawImagePart(HRESULT hr, struct drawState *s)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	IWICBitmap *wb;
 	HBITMAP b;
 	RECT r;
@@ -78,9 +78,9 @@ static HRESULT drawImagePart(HRESULT hr, struct drawState *s)
 	if (s->p->imageModelColumn == -1)
 		return S_OK;
 
-	data = cellValue(s->model, s->iItem, s->p->imageModelColumn);
+	value = cellValue(s->model, s->iItem, s->p->imageModelColumn);
-	wb = uiprivImageAppropriateForDC(uiTableDataImage(data), s->dc);
+	wb = uiprivImageAppropriateForDC(uiTableValueImage(value), s->dc);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 
 	hr = uiprivWICToGDI(wb, s->dc, s->m->cxIcon, s->m->cyIcon, &b);
 	if (hr != S_OK)
@@ -188,7 +188,7 @@ static HRESULT drawThemedCheckbox(struct drawState *s, HTHEME theme, int checked
 
 static HRESULT drawCheckboxPart(HRESULT hr, struct drawState *s)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	int checked, enabled;
 	HTHEME theme;
 
@@ -197,9 +197,9 @@ static HRESULT drawCheckboxPart(HRESULT hr, struct drawState *s)
 	if (s->p->checkboxModelColumn == -1)
 		return S_OK;
 
-	data = cellValue(s->model, s->iItem, s->p->checkboxModelColumn);
+	value = cellValue(s->model, s->iItem, s->p->checkboxModelColumn);
-	checked = uiTableDataInt(data);
+	checked = uiTableValueInt(value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	switch (s->p->checkboxEditableColumn) {
 	case uiTableModelColumnNeverEditable:
 		enabled = 0;
@@ -208,9 +208,9 @@ static HRESULT drawCheckboxPart(HRESULT hr, struct drawState *s)
 		enabled = 1;
 		break;
 	default:
-		data = cellValue(s->model, s->iItem, s->p->checkboxEditableColumn);
+		value = cellValue(s->model, s->iItem, s->p->checkboxEditableColumn);
-		enabled = uiTableDataInt(data);
+		enabled = uiTableValueInt(value);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 	}
 
 	theme = OpenThemeData(s->t->hwnd, L"button");
@@ -236,7 +236,7 @@ static HRESULT drawTextPart(HRESULT hr, struct drawState *s)
 	COLORREF prevText;
 	int prevMode;
 	RECT r;
-	uiTableData *data;
+	uiTableValue *value;
 	WCHAR *wstr;
 
 	if (hr != S_OK)
@@ -258,9 +258,9 @@ static HRESULT drawTextPart(HRESULT hr, struct drawState *s)
 		return E_FAIL;
 	}
 
-	data = cellValue(s->model, s->iItem, s->p->textModelColumn);
+	value = cellValue(s->model, s->iItem, s->p->textModelColumn);
-	wstr = toUTF16(uiTableDataString(data));
+	wstr = toUTF16(uiTableValueString(value));
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	// These flags are a menagerie of flags from various sources:
 	// guessing, the Windows 2000 source leak, various custom
 	// draw examples on the web, etc.
@@ -402,7 +402,7 @@ fail:
 
 static HRESULT drawButtonPart(HRESULT hr, struct drawState *s)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	WCHAR *wstr;
 	bool enabled;
 	HTHEME theme;
@@ -414,9 +414,9 @@ static HRESULT drawButtonPart(HRESULT hr, struct drawState *s)
 	if (s->p->buttonModelColumn == -1)
 		return S_OK;
 
-	data = cellValue(s->model, s->iItem, s->p->buttonModelColumn);
+	value = cellValue(s->model, s->iItem, s->p->buttonModelColumn);
-	wstr = toUTF16(uiTableDataString(data));
+	wstr = toUTF16(uiTableValueString(value));
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	switch (s->p->buttonClickableModelColumn) {
 	case uiTableModelColumnNeverEditable:
 		enabled = 0;
@@ -425,9 +425,9 @@ static HRESULT drawButtonPart(HRESULT hr, struct drawState *s)
 		enabled = 1;
 		break;
 	default:
-		data = cellValue(s->model, s->iItem, s->p->checkboxEditableColumn);
+		value = cellValue(s->model, s->iItem, s->p->checkboxEditableColumn);
-		enabled = uiTableDataInt(data);
+		enabled = uiTableValueInt(value);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 	}
 
 	theme = OpenThemeData(s->t->hwnd, L"button");
@@ -574,16 +574,16 @@ static HRESULT fillDrawState(struct drawState *s, uiTable *t, NMLVCUSTOMDRAW *nm
 		s->textColor = GetSysColor(COLOR_HIGHLIGHTTEXT);
 		s->textBrush = GetSysColorBrush(COLOR_HIGHLIGHTTEXT);
 	} else {
-		uiTableData *data;
+		uiTableValue *value;
 		double r, g, b, a;
 
 		s->bgColor = GetSysColor(COLOR_WINDOW);
 		s->bgBrush = GetSysColorBrush(COLOR_WINDOW);
 		if (t->backgroundColumn != -1) {
-			data = cellValue(s->model, s->iItem, t->backgroundColumn);
+			value = cellValue(s->model, s->iItem, t->backgroundColumn);
-			if (data != NULL) {
+			if (value != NULL) {
-				uiTableDataColor(data, &r, &g, &b, &a);
+				uiTableValueColor(value, &r, &g, &b, &a);
-				uiFreeTableData(data);
+				uiFreeTableValue(value);
 				s->bgColor = blend(s->bgColor, r, g, b, a);
 				s->bgBrush = CreateSolidBrush(s->bgColor);
 				if (s->bgBrush == NULL) {
@@ -597,10 +597,10 @@ static HRESULT fillDrawState(struct drawState *s, uiTable *t, NMLVCUSTOMDRAW *nm
 		s->textColor = GetSysColor(COLOR_WINDOWTEXT);
 		s->textBrush = GetSysColorBrush(COLOR_WINDOWTEXT);
 		if (p->textParams.ColorModelColumn != -1) {
-			data = cellValue(s->model, s->iItem, p->textParams.ColorModelColumn);
+			value = cellValue(s->model, s->iItem, p->textParams.ColorModelColumn);
-			if (data != NULL) {
+			if (value != NULL) {
-				uiTableDataColor(data, &r, &g, &b, &a);
+				uiTableValueColor(value, &r, &g, &b, &a);
-				uiFreeTableData(data);
+				uiFreeTableValue(value);
 				s->textColor = blend(s->bgColor, r, g, b, a);
 				s->textBrush = CreateSolidBrush(s->textColor);
 				if (s->textBrush == NULL) {

windows/tableediting.cpp

@@ -95,7 +95,7 @@ static LRESULT CALLBACK editSubProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM
 
 static HRESULT openEditControl(uiTable *t, int iItem, int iSubItem, uiprivTableColumnParams *p)
 {
-	uiTableData *data;
+	uiTableValue *value;
 	WCHAR *wstr;
 	HRESULT hr;
 
@@ -105,9 +105,9 @@ static HRESULT openEditControl(uiTable *t, int iItem, int iSubItem, uiprivTableC
 		return hr;
 
 	// the real list view creates the edit control with the string
-	data = (*(t->model->mh->CellValue))(t->model->mh, t->model, iItem, p->textModelColumn);
+	value = (*(t->model->mh->CellValue))(t->model->mh, t->model, iItem, p->textModelColumn);
-	wstr = toUTF16(uiTableDataString(data));
+	wstr = toUTF16(uiTableValueString(value));
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	// TODO copy WS_EX_RTLREADING
 	t->edit = CreateWindowExW(0,
 		L"EDIT", wstr,
@@ -157,17 +157,17 @@ HRESULT uiprivTableResizeWhileEditing(uiTable *t)
 HRESULT uiprivTableFinishEditingText(uiTable *t)
 {
 	uiprivTableColumnParams *p;
-	uiTableData *data;
+	uiTableValue *value;
 	char *text;
 
 	if (t->edit == NULL)
 		return S_OK;
 	text = uiWindowsWindowText(t->edit);
-	data = uiNewTableDataString(text);
+	value = uiNewTableValueString(text);
 	uiFreeText(text);
 	p = (*(t->columns))[t->editedSubitem];
-	(*(t->model->mh->SetCellValue))(t->model->mh, t->model, t->editedItem, p->textModelColumn, data);
+	(*(t->model->mh->SetCellValue))(t->model->mh, t->model, t->editedItem, p->textModelColumn, value);
-	uiFreeTableData(data);
+	uiFreeTableValue(value);
 	// always refresh the value in case the model rejected it
 	if (SendMessageW(t->hwnd, LVM_UPDATE, (WPARAM) (t->editedItem), 0) == (LRESULT) (-1)) {
 		logLastError(L"LVM_UPDATE");
@@ -199,7 +199,7 @@ HRESULT uiprivTableHandleNM_CLICK(uiTable *t, NMITEMACTIVATE *nm, LRESULT *lResu
 	uiprivTableColumnParams *p;
 	int modelColumn, editableColumn;
 	bool text, checkbox;
-	uiTableData *data;
+	uiTableValue *value;
 	int checked, editable;
 	HRESULT hr;
 
@@ -238,9 +238,9 @@ HRESULT uiprivTableHandleNM_CLICK(uiTable *t, NMITEMACTIVATE *nm, LRESULT *lResu
 	case uiTableModelColumnAlwaysEditable:
 		break;
 	default:
-		data = (*(t->model->mh->CellValue))(t->model->mh, t->model, ht.iItem, editableColumn);
+		value = (*(t->model->mh->CellValue))(t->model->mh, t->model, ht.iItem, editableColumn);
-		editable = uiTableDataInt(data);
+		editable = uiTableValueInt(value);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 		if (!editable)
 			goto done;
 	}
@@ -252,12 +252,12 @@ HRESULT uiprivTableHandleNM_CLICK(uiTable *t, NMITEMACTIVATE *nm, LRESULT *lResu
 	} else if (checkbox) {
 		if ((ht.flags & LVHT_ONITEMICON) == 0)
 			goto done;
-		data = (*(t->model->mh->CellValue))(t->model->mh, t->model, ht.iItem, modelColumn);
+		value = (*(t->model->mh->CellValue))(t->model->mh, t->model, ht.iItem, modelColumn);
-		checked = uiTableDataInt(data);
+		checked = uiTableValueInt(value);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
-		data = uiNewTableDataInt(!checked);
+		value = uiNewTableValueInt(!checked);
-		(*(t->model->mh->SetCellValue))(t->model->mh, t->model, ht.iItem, modelColumn, data);
+		(*(t->model->mh->SetCellValue))(t->model->mh, t->model, ht.iItem, modelColumn, value);
-		uiFreeTableData(data);
+		uiFreeTableValue(value);
 	} else
 		(*(t->model->mh->SetCellValue))(t->model->mh, t->model, ht.iItem, modelColumn, NULL);
 	// always refresh the value in case the model rejected it