[gnumeric] rename enums



commit b8f3c912e6d601c3b30c03500e344a11d269fe65
Author: Andreas J Guelzow <aguelzow pyrshep ca>
Date:   Tue Nov 22 14:13:42 2011 -0700

    rename enums
    
    2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
    
    	* src/widgets/gnm-validation-combo-view.c: rename enums
    	* src/widgets/widget-font-selector.c: rename enums
    
    2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
    
    	* src/dialogs/dialog-cell-format.c: rename enums
    	* src/dialogs/dialog-scenarios.c: rename enums
    
    2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
    
    	* src/tools/analysis-anova.c: rename enums
    	* src/tools/analysis-chi-squared.c: rename enums
    	* src/tools/analysis-principal-components.c: rename enums
    	* src/tools/analysis-tools.c: rename enums
    
    2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
    
    	* src/cell-draw.c: rename enums
    	* src/cellspan.c: rename enums
    	* src/commands.c: rename enums
    	* src/item-edit.c: rename enums
    	* src/mstyle.c: rename enums
    	* src/rendered-value.c: rename enums
    	* src/style.c: rename enums
    	* src/style.h: rename enums
    	* src/validation.c: rename enums
    	* src/validation.h: rename enums
    	* src/wbc-gtk-actions.c: rename enums
    	* src/wbc-gtk-edit.c: rename enums
    	* src/wbc-gtk.c: rename enums
    	* src/workbook-cmd-format.c: rename enums
    	* src/workbook-view.c: rename enums
    	* src/xml-sax-read.c: rename enums
    	* src/xml-sax-write.c: rename enums

 ChangeLog                                 |   20 +++++
 plugins/applix/applix-read.c              |   14 ++--
 plugins/excel/excel-xml-read.c            |   24 +++---
 plugins/excel/ms-excel-read.c             |   98 ++++++++++++------------
 plugins/excel/ms-excel-write.c            |   72 +++++++++---------
 plugins/excel/xlsx-read.c                 |   74 +++++++++---------
 plugins/excel/xlsx-write.c                |   64 ++++++++--------
 plugins/fn-info/functions.c               |   16 ++--
 plugins/html/html.c                       |   22 +++---
 plugins/html/latex.c                      |   26 +++---
 plugins/html/roff.c                       |    8 +-
 plugins/lotus-123/lotus.c                 |   16 ++--
 plugins/oleo/oleo.c                       |    4 +-
 plugins/openoffice/openoffice-read.c      |   76 ++++++++++----------
 plugins/openoffice/openoffice-write.c     |   96 ++++++++++++------------
 plugins/plan-perfect/pln.c                |   14 ++--
 plugins/qpro/qpro-read.c                  |   16 ++--
 plugins/sc/sc.c                           |    4 +-
 plugins/sylk/sylk.c                       |   10 +-
 src/cell-draw.c                           |   40 +++++-----
 src/cellspan.c                            |   36 +++++-----
 src/commands.c                            |    2 +-
 src/dialogs/ChangeLog                     |    5 +
 src/dialogs/dialog-cell-format.c          |   88 +++++++++++-----------
 src/dialogs/dialog-scenarios.c            |    8 +-
 src/item-edit.c                           |   10 +-
 src/mstyle.c                              |   20 +++---
 src/rendered-value.c                      |   28 ++++----
 src/style.c                               |   44 ++++++------
 src/style.h                               |   26 +++---
 src/tools/ChangeLog                       |    7 ++
 src/tools/analysis-anova.c                |    4 +-
 src/tools/analysis-chi-squared.c          |    2 +-
 src/tools/analysis-principal-components.c |    4 +-
 src/tools/analysis-tools.c                |    4 +-
 src/validation.c                          |  116 ++++++++++++++--------------
 src/validation.h                          |   50 ++++++------
 src/wbc-gtk-actions.c                     |   40 +++++-----
 src/wbc-gtk-edit.c                        |   12 ++--
 src/wbc-gtk.c                             |   40 +++++-----
 src/widgets/ChangeLog                     |    5 +
 src/widgets/gnm-validation-combo-view.c   |    2 +-
 src/widgets/widget-font-selector.c        |    4 +-
 src/workbook-cmd-format.c                 |    4 +-
 src/workbook-view.c                       |    2 +-
 src/xml-sax-read.c                        |    6 +-
 src/xml-sax-write.c                       |   10 +-
 47 files changed, 665 insertions(+), 628 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index e2b0696..245d931 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,5 +1,25 @@
 2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
 
+	* src/cell-draw.c: rename enums
+	* src/cellspan.c: rename enums
+	* src/commands.c: rename enums
+	* src/item-edit.c: rename enums
+	* src/mstyle.c: rename enums
+	* src/rendered-value.c: rename enums
+	* src/style.c: rename enums
+	* src/style.h: rename enums
+	* src/validation.c: rename enums
+	* src/validation.h: rename enums
+	* src/wbc-gtk-actions.c: rename enums
+	* src/wbc-gtk-edit.c: rename enums
+	* src/wbc-gtk.c: rename enums
+	* src/workbook-cmd-format.c: rename enums
+	* src/workbook-view.c: rename enums
+	* src/xml-sax-read.c: rename enums
+	* src/xml-sax-write.c: rename enums
+
+2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
+
 	* src/style.c (gnm_align_h_get_type): new
 	(gnm_align_v_get_type): new
 	* src/style.h (gnm_align_h_get_type): new
diff --git a/plugins/applix/applix-read.c b/plugins/applix/applix-read.c
index b6512bd..aeda6b5 100644
--- a/plugins/applix/applix-read.c
+++ b/plugins/applix/applix-read.c
@@ -518,10 +518,10 @@ applix_parse_style (ApplixReadState *state, unsigned char **buffer)
 			if (g_ascii_isdigit (*sep)) {
 				GnmHAlign a;
 				switch (*sep) {
-				case '1' : a = HALIGN_LEFT; break;
-				case '2' : a = HALIGN_RIGHT; break;
-				case '3' : a = HALIGN_CENTER; break;
-				case '4' : a = HALIGN_FILL; break;
+				case '1' : a = GNM_HALIGN_LEFT; break;
+				case '2' : a = GNM_HALIGN_RIGHT; break;
+				case '3' : a = GNM_HALIGN_CENTER; break;
+				case '4' : a = GNM_HALIGN_FILL; break;
 				default :
 					applix_parse_error (state, "Unknown horizontal alignment '%c'", *sep);
 					return NULL;
@@ -531,9 +531,9 @@ applix_parse_style (ApplixReadState *state, unsigned char **buffer)
 			} else if (*sep == 'V') {
 				GnmVAlign a;
 				switch (sep[1]) {
-				case 'T' : a = VALIGN_TOP; break;
-				case 'C' : a = VALIGN_CENTER; break;
-				case 'B' : a = VALIGN_BOTTOM; break;
+				case 'T' : a = GNM_VALIGN_TOP; break;
+				case 'C' : a = GNM_VALIGN_CENTER; break;
+				case 'B' : a = GNM_VALIGN_BOTTOM; break;
 				default :
 					applix_parse_error (state, "Unknown vertical alignment '%c'", *sep);
 					return NULL;
diff --git a/plugins/excel/excel-xml-read.c b/plugins/excel/excel-xml-read.c
index 87e8dce..71cf71b 100644
--- a/plugins/excel/excel-xml-read.c
+++ b/plugins/excel/excel-xml-read.c
@@ -562,21 +562,21 @@ static void
 xl_xml_alignment (GsfXMLIn *xin, xmlChar const **attrs)
 {
 	static EnumVal const valignments [] = {
-		{ "Bottom", VALIGN_BOTTOM },
-		{ "Center", VALIGN_CENTER },
-		{ "Distributed", VALIGN_DISTRIBUTED },
-		{ "Justify", VALIGN_JUSTIFY },
-		{ "Top", VALIGN_TOP },
+		{ "Bottom", GNM_VALIGN_BOTTOM },
+		{ "Center", GNM_VALIGN_CENTER },
+		{ "Distributed", GNM_VALIGN_DISTRIBUTED },
+		{ "Justify", GNM_VALIGN_JUSTIFY },
+		{ "Top", GNM_VALIGN_TOP },
 		{ NULL, 0 }
 	};
 	static EnumVal const halignments [] = {
-		{ "Center", HALIGN_CENTER },
-		{ "CenterAcrossSelection", HALIGN_CENTER_ACROSS_SELECTION },
-		{ "Distributed", HALIGN_DISTRIBUTED },
-		{ "Fill", HALIGN_FILL },
-		{ "Justify", HALIGN_JUSTIFY },
-		{ "Left", HALIGN_LEFT },
-		{ "Right", HALIGN_RIGHT },
+		{ "Center", GNM_HALIGN_CENTER },
+		{ "CenterAcrossSelection", GNM_HALIGN_CENTER_ACROSS_SELECTION },
+		{ "Distributed", GNM_HALIGN_DISTRIBUTED },
+		{ "Fill", GNM_HALIGN_FILL },
+		{ "Justify", GNM_HALIGN_JUSTIFY },
+		{ "Left", GNM_HALIGN_LEFT },
+		{ "Right", GNM_HALIGN_RIGHT },
 
 		{ NULL, 0 }
 	};
diff --git a/plugins/excel/ms-excel-read.c b/plugins/excel/ms-excel-read.c
index fd170bc..07c9494 100644
--- a/plugins/excel/ms-excel-read.c
+++ b/plugins/excel/ms-excel-read.c
@@ -2406,21 +2406,21 @@ excel_read_XF_OLD (BiffQuery *q, GnmXLImporter *importer)
 	xf->shrink_to_fit = FALSE;
 
 
-        xf->halign = HALIGN_GENERAL;
+        xf->halign = GNM_HALIGN_GENERAL;
 
 	data = (importer->ver >= MS_BIFF_V3) ? q->data[4] : q->data[3];
 	switch (data & 0x07) {
 	default :
-	case 0: xf->halign = HALIGN_GENERAL; break;
-	case 1: xf->halign = HALIGN_LEFT; break;
-	case 2: xf->halign = HALIGN_CENTER; break;
-	case 3: xf->halign = HALIGN_RIGHT; break;
-	case 4: xf->halign = HALIGN_FILL; break;
-	case 5: xf->halign = HALIGN_JUSTIFY; break;
-	case 6: xf->halign = HALIGN_CENTER_ACROSS_SELECTION; break;
+	case 0: xf->halign = GNM_HALIGN_GENERAL; break;
+	case 1: xf->halign = GNM_HALIGN_LEFT; break;
+	case 2: xf->halign = GNM_HALIGN_CENTER; break;
+	case 3: xf->halign = GNM_HALIGN_RIGHT; break;
+	case 4: xf->halign = GNM_HALIGN_FILL; break;
+	case 5: xf->halign = GNM_HALIGN_JUSTIFY; break;
+	case 6: xf->halign = GNM_HALIGN_CENTER_ACROSS_SELECTION; break;
 	}
 
-        xf->valign = VALIGN_BOTTOM;
+        xf->valign = GNM_VALIGN_BOTTOM;
         xf->rotation = 0;
         xf->indent = 0;
         xf->differences = 0;
@@ -2429,10 +2429,10 @@ excel_read_XF_OLD (BiffQuery *q, GnmXLImporter *importer)
         if (importer->ver >= MS_BIFF_V4) {
 		xf->wrap_text = (data & 0x0008) != 0;
 		switch (data & 0x30) {
-		case 0x00: xf->valign = VALIGN_TOP; break;
-		case 0x10: xf->valign = VALIGN_CENTER; break;
+		case 0x00: xf->valign = GNM_VALIGN_TOP; break;
+		case 0x10: xf->valign = GNM_VALIGN_CENTER; break;
 		default :
-		case 0x20: xf->valign = VALIGN_BOTTOM; break;
+		case 0x20: xf->valign = GNM_VALIGN_BOTTOM; break;
 		}
 		switch (data & 0xc0) {
 		case 0x00: xf->rotation = 0; break;
@@ -2443,7 +2443,7 @@ excel_read_XF_OLD (BiffQuery *q, GnmXLImporter *importer)
 	} else if (importer->ver >= MS_BIFF_V3) {
 		xf->wrap_text = (data & 0x0008) != 0;
 		if (xf->wrap_text)
-			xf->valign = VALIGN_TOP;
+			xf->valign = GNM_VALIGN_TOP;
 	}
 
 	if (importer->ver >= MS_BIFF_V3) {
@@ -2534,12 +2534,12 @@ excel_read_XF (BiffQuery *q, GnmXLImporter *importer)
 	data = GSF_LE_GET_GUINT16 (q->data + 6);
 	subdata = data & 0x0007;
 	switch (subdata) {
-	case 0: xf->halign = HALIGN_GENERAL; break;
-	case 1: xf->halign = HALIGN_LEFT; break;
-	case 2: xf->halign = HALIGN_CENTER; break;
-	case 3: xf->halign = HALIGN_RIGHT; break;
-	case 4: xf->halign = HALIGN_FILL; break;
-	case 5: xf->halign = HALIGN_JUSTIFY; break;
+	case 0: xf->halign = GNM_HALIGN_GENERAL; break;
+	case 1: xf->halign = GNM_HALIGN_LEFT; break;
+	case 2: xf->halign = GNM_HALIGN_CENTER; break;
+	case 3: xf->halign = GNM_HALIGN_RIGHT; break;
+	case 4: xf->halign = GNM_HALIGN_FILL; break;
+	case 5: xf->halign = GNM_HALIGN_JUSTIFY; break;
 	case 6:
 		/*
 		 * All adjacent blank cells with this type of alignment
@@ -2547,26 +2547,26 @@ excel_read_XF (BiffQuery *q, GnmXLImporter *importer)
 		 * normally and the span is adjusted if contents are changed.
 		 * Use center for now.
 		 */
-		xf->halign = HALIGN_CENTER_ACROSS_SELECTION;
+		xf->halign = GNM_HALIGN_CENTER_ACROSS_SELECTION;
 		break;
 
 		/* no idea what this does */
-	case 7 : xf->halign = HALIGN_DISTRIBUTED; break;
+	case 7 : xf->halign = GNM_HALIGN_DISTRIBUTED; break;
 
 	default:
-		xf->halign = HALIGN_JUSTIFY;
+		xf->halign = GNM_HALIGN_JUSTIFY;
 		g_printerr ("Unknown halign %d\n", subdata);
 		break;
 	}
 	xf->wrap_text = (data & 0x0008) != 0;
 	subdata = (data & 0x0070) >> 4;
 	switch (subdata) {
-	case 0: xf->valign = VALIGN_TOP; break;
-	case 1: xf->valign = VALIGN_CENTER; break;
-	case 2: xf->valign = VALIGN_BOTTOM; break;
-	case 3: xf->valign = VALIGN_JUSTIFY; break;
+	case 0: xf->valign = GNM_VALIGN_TOP; break;
+	case 1: xf->valign = GNM_VALIGN_CENTER; break;
+	case 2: xf->valign = GNM_VALIGN_BOTTOM; break;
+	case 3: xf->valign = GNM_VALIGN_JUSTIFY; break;
 		/* What does this do ?? */
-	case 4: xf->valign = VALIGN_DISTRIBUTED; break;
+	case 4: xf->valign = GNM_VALIGN_DISTRIBUTED; break;
 	default:
 		g_printerr ("Unknown valign %d\n", subdata);
 		break;
@@ -5563,43 +5563,43 @@ excel_read_DV (BiffQuery *q, ExcelReadSheet *esheet)
 	 * is easier to read.
 	 */
 	switch (options & 0x0f) {
-	case 0 : type = VALIDATION_TYPE_ANY;		break;
-	case 1 : type = VALIDATION_TYPE_AS_INT;		break;
-	case 2 : type = VALIDATION_TYPE_AS_NUMBER;	break;
-	case 3 : type = VALIDATION_TYPE_IN_LIST;	break;
-	case 4 : type = VALIDATION_TYPE_AS_DATE;	break;
-	case 5 : type = VALIDATION_TYPE_AS_TIME;	break;
-	case 6 : type = VALIDATION_TYPE_TEXT_LENGTH;	break;
-	case 7 : type = VALIDATION_TYPE_CUSTOM;		break;
+	case 0 : type = GNM_VALIDATION_TYPE_ANY;		break;
+	case 1 : type = GNM_VALIDATION_TYPE_AS_INT;		break;
+	case 2 : type = GNM_VALIDATION_TYPE_AS_NUMBER;	break;
+	case 3 : type = GNM_VALIDATION_TYPE_IN_LIST;	break;
+	case 4 : type = GNM_VALIDATION_TYPE_AS_DATE;	break;
+	case 5 : type = GNM_VALIDATION_TYPE_AS_TIME;	break;
+	case 6 : type = GNM_VALIDATION_TYPE_TEXT_LENGTH;	break;
+	case 7 : type = GNM_VALIDATION_TYPE_CUSTOM;		break;
 	default :
 		g_warning ("EXCEL : Unknown constraint type %d", options & 0x0f);
 		return;
 	}
 
 	switch ((options >> 4) & 0x07) {
-	case 0 : style = VALIDATION_STYLE_STOP; break;
-	case 1 : style = VALIDATION_STYLE_WARNING; break;
-	case 2 : style = VALIDATION_STYLE_INFO; break;
+	case 0 : style = GNM_VALIDATION_STYLE_STOP; break;
+	case 1 : style = GNM_VALIDATION_STYLE_WARNING; break;
+	case 2 : style = GNM_VALIDATION_STYLE_INFO; break;
 	default :
 		g_warning ("EXCEL : Unknown validation style %d",
 			   (options >> 4) & 0x07);
 		return;
 	}
 	if (!(options & 0x80000))
-		style = VALIDATION_STYLE_NONE;
+		style = GNM_VALIDATION_STYLE_NONE;
 
-	if (type == VALIDATION_TYPE_CUSTOM || type == VALIDATION_TYPE_IN_LIST)
-		op = VALIDATION_OP_NONE;
+	if (type == GNM_VALIDATION_TYPE_CUSTOM || type == GNM_VALIDATION_TYPE_IN_LIST)
+		op = GNM_VALIDATION_OP_NONE;
 	else
 		switch ((options >> 20) & 0x0f) {
-		case 0:	op = VALIDATION_OP_BETWEEN;	break;
-		case 1:	op = VALIDATION_OP_NOT_BETWEEN; break;
-		case 2:	op = VALIDATION_OP_EQUAL;	break;
-		case 3:	op = VALIDATION_OP_NOT_EQUAL;	break;
-		case 4:	op = VALIDATION_OP_GT;		break;
-		case 5:	op = VALIDATION_OP_LT;		break;
-		case 6:	op = VALIDATION_OP_GTE;		break;
-		case 7:	op = VALIDATION_OP_LTE;		break;
+		case 0:	op = GNM_VALIDATION_OP_BETWEEN;	break;
+		case 1:	op = GNM_VALIDATION_OP_NOT_BETWEEN; break;
+		case 2:	op = GNM_VALIDATION_OP_EQUAL;	break;
+		case 3:	op = GNM_VALIDATION_OP_NOT_EQUAL;	break;
+		case 4:	op = GNM_VALIDATION_OP_GT;		break;
+		case 5:	op = GNM_VALIDATION_OP_LT;		break;
+		case 6:	op = GNM_VALIDATION_OP_GTE;		break;
+		case 7:	op = GNM_VALIDATION_OP_LTE;		break;
 		default :
 			g_warning ("EXCEL : Unknown constraint operator %d",
 				   (options >> 20) & 0x0f);
diff --git a/plugins/excel/ms-excel-write.c b/plugins/excel/ms-excel-write.c
index a00e7fc..e209c7b 100644
--- a/plugins/excel/ms-excel-write.c
+++ b/plugins/excel/ms-excel-write.c
@@ -1175,37 +1175,37 @@ excel_write_DV (XLValInputPair const *vip, gpointer dummy, ExcelWriteSheet *eshe
 	options = 0;
 	if (vip->v != NULL) {
 		switch (vip->v->type) {
-		case VALIDATION_TYPE_ANY:		options = 0; break;
-		case VALIDATION_TYPE_AS_INT:		options = 1; break;
-		case VALIDATION_TYPE_AS_NUMBER:		options = 2; break;
-		case VALIDATION_TYPE_IN_LIST:		options = 3; break;
-		case VALIDATION_TYPE_AS_DATE:		options = 4; break;
-		case VALIDATION_TYPE_AS_TIME:		options = 5; break;
-		case VALIDATION_TYPE_TEXT_LENGTH:	options = 6; break;
-		case VALIDATION_TYPE_CUSTOM:		options = 7; break;
+		case GNM_VALIDATION_TYPE_ANY:		options = 0; break;
+		case GNM_VALIDATION_TYPE_AS_INT:		options = 1; break;
+		case GNM_VALIDATION_TYPE_AS_NUMBER:		options = 2; break;
+		case GNM_VALIDATION_TYPE_IN_LIST:		options = 3; break;
+		case GNM_VALIDATION_TYPE_AS_DATE:		options = 4; break;
+		case GNM_VALIDATION_TYPE_AS_TIME:		options = 5; break;
+		case GNM_VALIDATION_TYPE_TEXT_LENGTH:	options = 6; break;
+		case GNM_VALIDATION_TYPE_CUSTOM:		options = 7; break;
 		default : g_warning ("EXCEL : Unknown constraint type %d",
 				     vip->v->type);
 		}
 
 		switch (vip->v->style) {
-		case VALIDATION_STYLE_NONE: break;
-		case VALIDATION_STYLE_STOP:	options |= (0 << 4); break;
-		case VALIDATION_STYLE_WARNING:	options |= (1 << 4); break;
-		case VALIDATION_STYLE_INFO:	options |= (2 << 4); break;
+		case GNM_VALIDATION_STYLE_NONE: break;
+		case GNM_VALIDATION_STYLE_STOP:	options |= (0 << 4); break;
+		case GNM_VALIDATION_STYLE_WARNING:	options |= (1 << 4); break;
+		case GNM_VALIDATION_STYLE_INFO:	options |= (2 << 4); break;
 		default : g_warning ("EXCEL : Unknown validation style %d",
 				     vip->v->style);
 		}
 
 		switch (vip->v->op) {
-		case VALIDATION_OP_NONE:
-		case VALIDATION_OP_BETWEEN:	options |= (0 << 20); break;
-		case VALIDATION_OP_NOT_BETWEEN:	options |= (1 << 20); break;
-		case VALIDATION_OP_EQUAL:	options |= (2 << 20); break;
-		case VALIDATION_OP_NOT_EQUAL:	options |= (3 << 20); break;
-		case VALIDATION_OP_GT:		options |= (4 << 20); break;
-		case VALIDATION_OP_LT:		options |= (5 << 20); break;
-		case VALIDATION_OP_GTE:		options |= (6 << 20); break;
-		case VALIDATION_OP_LTE:		options |= (7 << 20); break;
+		case GNM_VALIDATION_OP_NONE:
+		case GNM_VALIDATION_OP_BETWEEN:	options |= (0 << 20); break;
+		case GNM_VALIDATION_OP_NOT_BETWEEN:	options |= (1 << 20); break;
+		case GNM_VALIDATION_OP_EQUAL:	options |= (2 << 20); break;
+		case GNM_VALIDATION_OP_NOT_EQUAL:	options |= (3 << 20); break;
+		case GNM_VALIDATION_OP_GT:		options |= (4 << 20); break;
+		case GNM_VALIDATION_OP_LT:		options |= (5 << 20); break;
+		case GNM_VALIDATION_OP_GTE:		options |= (6 << 20); break;
+		case GNM_VALIDATION_OP_LTE:		options |= (7 << 20); break;
 		default : g_warning ("EXCEL : Unknown constraint operator %d",
 				     vip->v->op);
 		}
@@ -1214,7 +1214,7 @@ excel_write_DV (XLValInputPair const *vip, gpointer dummy, ExcelWriteSheet *eshe
 		/* XL suppesses the dropdown rather than vice versa */
 		if (!vip->v->use_dropdown)
 			options |= 0x200;
-		if (vip->v->style != VALIDATION_STYLE_NONE)
+		if (vip->v->style != GNM_VALIDATION_STYLE_NONE)
 			options |= 0x80000;
 	}
 
@@ -2608,28 +2608,28 @@ halign_to_excel (GnmHAlign halign)
 	guint ialign;
 
 	switch (halign) {
-	case HALIGN_GENERAL:
+	case GNM_HALIGN_GENERAL:
 		ialign = MS_BIFF_H_A_GENERAL;
 		break;
-	case HALIGN_LEFT:
+	case GNM_HALIGN_LEFT:
 		ialign = MS_BIFF_H_A_LEFT;
 		break;
-	case HALIGN_RIGHT:
+	case GNM_HALIGN_RIGHT:
 		ialign = MS_BIFF_H_A_RIGHT;
 		break;
-	case HALIGN_CENTER:
+	case GNM_HALIGN_CENTER:
 		ialign = MS_BIFF_H_A_CENTER;
 		break;
-	case HALIGN_FILL:
+	case GNM_HALIGN_FILL:
 		ialign = MS_BIFF_H_A_FILL;
 		break;
-	case HALIGN_JUSTIFY:
+	case GNM_HALIGN_JUSTIFY:
 		ialign = MS_BIFF_H_A_JUSTIFTY;
 		break;
-	case HALIGN_CENTER_ACROSS_SELECTION:
+	case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 		ialign = MS_BIFF_H_A_CENTER_ACROSS_SELECTION;
 		break;
-	case HALIGN_DISTRIBUTED:
+	case GNM_HALIGN_DISTRIBUTED:
 		ialign = MS_BIFF_H_A_DISTRIBUTED;
 		break;
 	default:
@@ -2645,19 +2645,19 @@ valign_to_excel (GnmVAlign valign)
 	guint ialign;
 
 	switch (valign) {
-	case VALIGN_TOP:
+	case GNM_VALIGN_TOP:
 		ialign = MS_BIFF_V_A_TOP;
 		break;
-	case VALIGN_BOTTOM:
+	case GNM_VALIGN_BOTTOM:
 		ialign = MS_BIFF_V_A_BOTTOM;
 		break;
-	case VALIGN_CENTER:
+	case GNM_VALIGN_CENTER:
 		ialign = MS_BIFF_V_A_CENTER;
 		break;
-	case VALIGN_JUSTIFY:
+	case GNM_VALIGN_JUSTIFY:
 		ialign = MS_BIFF_V_A_JUSTIFY;
 		break;
-	case VALIGN_DISTRIBUTED:
+	case GNM_VALIGN_DISTRIBUTED:
 		ialign = MS_BIFF_V_A_DISTRIBUTED;
 		break;
 	default:
@@ -2720,7 +2720,7 @@ get_xf_differences (BiffXFData *xfd, GnmStyle const *parentst)
 		xfd->differences |= 1 << MS_BIFF_D_FONT_BIT;
 	/* hmm. documentation doesn't say that alignment bit is
 	   affected by vertical alignment, but it's a reasonable guess */
-	if (xfd->halign != HALIGN_GENERAL || xfd->valign != VALIGN_TOP
+	if (xfd->halign != GNM_HALIGN_GENERAL || xfd->valign != GNM_VALIGN_TOP
 	    || xfd->wrap_text)
 		xfd->differences |= 1 << MS_BIFF_D_ALIGN_BIT;
 	for (i = 0; i < STYLE_ORIENT_MAX; i++) {
diff --git a/plugins/excel/xlsx-read.c b/plugins/excel/xlsx-read.c
index 3ffd09e..4b81577 100644
--- a/plugins/excel/xlsx-read.c
+++ b/plugins/excel/xlsx-read.c
@@ -1638,31 +1638,31 @@ static void
 xlsx_CT_DataValidation_begin (GsfXMLIn *xin, xmlChar const **attrs)
 {
 	static EnumVal const val_styles[] = {
-		{ "stop",	 VALIDATION_STYLE_STOP },
-		{ "warning",	 VALIDATION_STYLE_WARNING },
-		{ "information", VALIDATION_STYLE_INFO },
+		{ "stop",	 GNM_VALIDATION_STYLE_STOP },
+		{ "warning",	 GNM_VALIDATION_STYLE_WARNING },
+		{ "information", GNM_VALIDATION_STYLE_INFO },
 		{ NULL, 0 }
 	};
 	static EnumVal const val_types[] = {
-		{ "none",	VALIDATION_TYPE_ANY },
-		{ "whole",	VALIDATION_TYPE_AS_INT },
-		{ "decimal",	VALIDATION_TYPE_AS_NUMBER },
-		{ "list",	VALIDATION_TYPE_IN_LIST },
-		{ "date",	VALIDATION_TYPE_AS_DATE },
-		{ "time",	VALIDATION_TYPE_AS_TIME },
-		{ "textLength",	VALIDATION_TYPE_TEXT_LENGTH },
-		{ "custom",	VALIDATION_TYPE_CUSTOM },
+		{ "none",	GNM_VALIDATION_TYPE_ANY },
+		{ "whole",	GNM_VALIDATION_TYPE_AS_INT },
+		{ "decimal",	GNM_VALIDATION_TYPE_AS_NUMBER },
+		{ "list",	GNM_VALIDATION_TYPE_IN_LIST },
+		{ "date",	GNM_VALIDATION_TYPE_AS_DATE },
+		{ "time",	GNM_VALIDATION_TYPE_AS_TIME },
+		{ "textLength",	GNM_VALIDATION_TYPE_TEXT_LENGTH },
+		{ "custom",	GNM_VALIDATION_TYPE_CUSTOM },
 		{ NULL, 0 }
 	};
 	static EnumVal const val_ops[] = {
-		{ "between",	VALIDATION_OP_BETWEEN },
-		{ "notBetween",	VALIDATION_OP_NOT_BETWEEN },
-		{ "equal",	VALIDATION_OP_EQUAL },
-		{ "notEqual",	VALIDATION_OP_NOT_EQUAL },
-		{ "lessThan",		VALIDATION_OP_LT },
-		{ "lessThanOrEqual",	VALIDATION_OP_LTE },
-		{ "greaterThan",	VALIDATION_OP_GT },
-		{ "greaterThanOrEqual",	VALIDATION_OP_GTE },
+		{ "between",	GNM_VALIDATION_OP_BETWEEN },
+		{ "notBetween",	GNM_VALIDATION_OP_NOT_BETWEEN },
+		{ "equal",	GNM_VALIDATION_OP_EQUAL },
+		{ "notEqual",	GNM_VALIDATION_OP_NOT_EQUAL },
+		{ "lessThan",		GNM_VALIDATION_OP_LT },
+		{ "lessThanOrEqual",	GNM_VALIDATION_OP_LTE },
+		{ "greaterThan",	GNM_VALIDATION_OP_GT },
+		{ "greaterThanOrEqual",	GNM_VALIDATION_OP_GTE },
 		{ NULL, 0 }
 	};
 #if 0
@@ -1684,9 +1684,9 @@ xlsx_CT_DataValidation_begin (GsfXMLIn *xin, xmlChar const **attrs)
 	XLSXReadState *state = (XLSXReadState *)xin->user_state;
 
 	/* defaults */
-	ValidationStyle	val_style = VALIDATION_STYLE_STOP;
-	ValidationType	val_type  = VALIDATION_TYPE_ANY;
-	ValidationOp	val_op	  = VALIDATION_OP_BETWEEN;
+	ValidationStyle	val_style = GNM_VALIDATION_STYLE_STOP;
+	ValidationType	val_type  = GNM_VALIDATION_TYPE_ANY;
+	ValidationOp	val_op	  = GNM_VALIDATION_OP_BETWEEN;
 	gboolean allowBlank = FALSE;
 	gboolean showDropDown = FALSE;
 	gboolean showInputMessage = FALSE;
@@ -3896,29 +3896,29 @@ static void
 xlsx_xf_align (GsfXMLIn *xin, xmlChar const **attrs)
 {
 	static EnumVal const haligns[] = {
-		{ "general" , HALIGN_GENERAL },
-		{ "left" , HALIGN_LEFT },
-		{ "center" , HALIGN_CENTER },
-		{ "right" , HALIGN_RIGHT },
-		{ "fill" , HALIGN_FILL },
-		{ "justify" , HALIGN_JUSTIFY },
-		{ "centerContinuous" , HALIGN_CENTER_ACROSS_SELECTION },
-		{ "distributed" , HALIGN_DISTRIBUTED },
+		{ "general" , GNM_HALIGN_GENERAL },
+		{ "left" , GNM_HALIGN_LEFT },
+		{ "center" , GNM_HALIGN_CENTER },
+		{ "right" , GNM_HALIGN_RIGHT },
+		{ "fill" , GNM_HALIGN_FILL },
+		{ "justify" , GNM_HALIGN_JUSTIFY },
+		{ "centerContinuous" , GNM_HALIGN_CENTER_ACROSS_SELECTION },
+		{ "distributed" , GNM_HALIGN_DISTRIBUTED },
 		{ NULL, 0 }
 	};
 
 	static EnumVal const valigns[] = {
-		{ "top", VALIGN_TOP },
-		{ "center", VALIGN_CENTER },
-		{ "bottom", VALIGN_BOTTOM },
-		{ "justify", VALIGN_JUSTIFY },
-		{ "distributed", VALIGN_DISTRIBUTED },
+		{ "top", GNM_VALIGN_TOP },
+		{ "center", GNM_VALIGN_CENTER },
+		{ "bottom", GNM_VALIGN_BOTTOM },
+		{ "justify", GNM_VALIGN_JUSTIFY },
+		{ "distributed", GNM_VALIGN_DISTRIBUTED },
 		{ NULL, 0 }
 	};
 
 	XLSXReadState *state = (XLSXReadState *)xin->user_state;
-	int halign = HALIGN_GENERAL;
-	int valign = VALIGN_BOTTOM;
+	int halign = GNM_HALIGN_GENERAL;
+	int valign = GNM_VALIGN_BOTTOM;
 	int rotation = 0, indent = 0;
 	int wrapText = FALSE, justifyLastLine = FALSE, shrinkToFit = FALSE;
 
diff --git a/plugins/excel/xlsx-write.c b/plugins/excel/xlsx-write.c
index 7c894be..1338a16 100644
--- a/plugins/excel/xlsx-write.c
+++ b/plugins/excel/xlsx-write.c
@@ -842,35 +842,35 @@ xlsx_write_style_write_alignment (XLSXWriteState *state, GsfXMLOut *xml,
 	gsf_xml_out_start_element (xml, "alignment");
 	if (gnm_style_is_element_set (style, MSTYLE_ALIGN_H)) {
 		switch (gnm_style_get_align_h (style)) {
-		case HALIGN_LEFT:
+		case GNM_HALIGN_LEFT:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"left");
 			break;
-		case HALIGN_RIGHT:
+		case GNM_HALIGN_RIGHT:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"right");
 			break;
-		case HALIGN_CENTER:
+		case GNM_HALIGN_CENTER:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"center");
 			break;
-		case HALIGN_FILL:
+		case GNM_HALIGN_FILL:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"fill");
 			break;
-		case HALIGN_JUSTIFY:
+		case GNM_HALIGN_JUSTIFY:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"justify");
 			break;
-		case HALIGN_CENTER_ACROSS_SELECTION:
+		case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"centerContinuous");
 			break;
-		case HALIGN_DISTRIBUTED:
+		case GNM_HALIGN_DISTRIBUTED:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"distributed");
 			break;
-		case HALIGN_GENERAL:
+		case GNM_HALIGN_GENERAL:
 		default:
 			gsf_xml_out_add_cstr_unchecked (xml, "horizontal",
 							"general");
@@ -879,24 +879,24 @@ xlsx_write_style_write_alignment (XLSXWriteState *state, GsfXMLOut *xml,
 	}
 	if (gnm_style_is_element_set (style, MSTYLE_ALIGN_V)) {
 		switch (gnm_style_get_align_v (style)) {
-		case VALIGN_TOP:
+		case GNM_VALIGN_TOP:
 			gsf_xml_out_add_cstr_unchecked (xml, "vertical",
 							"top");
 			break;
-		case VALIGN_BOTTOM:
+		case GNM_VALIGN_BOTTOM:
 			gsf_xml_out_add_cstr_unchecked (xml, "vertical",
 							"bottom");
 			break;
-		case VALIGN_CENTER:
+		case GNM_VALIGN_CENTER:
 			gsf_xml_out_add_cstr_unchecked (xml, "vertical",
 							"center");
 			break;
-		case VALIGN_JUSTIFY:
+		case GNM_VALIGN_JUSTIFY:
 			gsf_xml_out_add_cstr_unchecked (xml, "vertical",
 							"justify");
 			break;
 		default:
-		case VALIGN_DISTRIBUTED:
+		case GNM_VALIGN_DISTRIBUTED:
 			gsf_xml_out_add_cstr_unchecked (xml, "vertical",
 							"distributed");
 			break;
@@ -1350,14 +1350,14 @@ xlsx_write_validation (XLValInputPair const *vip, gpointer dummy, XLSXClosure *i
 		tmp = NULL;
 		switch (vip->v->type) {
 		default : /* fall back to the default */
-		case VALIDATION_TYPE_ANY : /* the default "none" */  break;
-		case VALIDATION_TYPE_AS_INT :		tmp = "whole"; break;
-		case VALIDATION_TYPE_AS_NUMBER :	tmp = "decimal"; break;
-		case VALIDATION_TYPE_IN_LIST :		tmp = "list"; break;
-		case VALIDATION_TYPE_AS_DATE :		tmp = "date"; break;
-		case VALIDATION_TYPE_AS_TIME :		tmp = "time"; break;
-		case VALIDATION_TYPE_TEXT_LENGTH :	tmp = "textLength"; break;
-		case VALIDATION_TYPE_CUSTOM :		tmp = "custom"; break;
+		case GNM_VALIDATION_TYPE_ANY : /* the default "none" */  break;
+		case GNM_VALIDATION_TYPE_AS_INT :		tmp = "whole"; break;
+		case GNM_VALIDATION_TYPE_AS_NUMBER :	tmp = "decimal"; break;
+		case GNM_VALIDATION_TYPE_IN_LIST :		tmp = "list"; break;
+		case GNM_VALIDATION_TYPE_AS_DATE :		tmp = "date"; break;
+		case GNM_VALIDATION_TYPE_AS_TIME :		tmp = "time"; break;
+		case GNM_VALIDATION_TYPE_TEXT_LENGTH :	tmp = "textLength"; break;
+		case GNM_VALIDATION_TYPE_CUSTOM :		tmp = "custom"; break;
 		}
 		if (NULL != tmp)
 			gsf_xml_out_add_cstr_unchecked (info->xml, "type", tmp);
@@ -1365,14 +1365,14 @@ xlsx_write_validation (XLValInputPair const *vip, gpointer dummy, XLSXClosure *i
 		tmp = NULL;
 		switch (vip->v->op) {
 		default : /* fall back to the default */
-		case VALIDATION_OP_BETWEEN :	/* the default "between" */ break;
-		case VALIDATION_OP_NOT_BETWEEN: tmp = "notBetween"; break;
-		case VALIDATION_OP_EQUAL :	tmp = "equal"; break;
-		case VALIDATION_OP_NOT_EQUAL :	tmp = "notEqual"; break;
-		case VALIDATION_OP_LT :		tmp = "lessThan"; break;
-		case VALIDATION_OP_GT :		tmp = "greaterThan"; break;
-		case VALIDATION_OP_LTE :	tmp = "lessThanOrEqual"; break;
-		case VALIDATION_OP_GTE :	tmp = "greaterThanOrEqual"; break;
+		case GNM_VALIDATION_OP_BETWEEN :	/* the default "between" */ break;
+		case GNM_VALIDATION_OP_NOT_BETWEEN: tmp = "notBetween"; break;
+		case GNM_VALIDATION_OP_EQUAL :	tmp = "equal"; break;
+		case GNM_VALIDATION_OP_NOT_EQUAL :	tmp = "notEqual"; break;
+		case GNM_VALIDATION_OP_LT :		tmp = "lessThan"; break;
+		case GNM_VALIDATION_OP_GT :		tmp = "greaterThan"; break;
+		case GNM_VALIDATION_OP_LTE :	tmp = "lessThanOrEqual"; break;
+		case GNM_VALIDATION_OP_GTE :	tmp = "greaterThanOrEqual"; break;
 		}
 		if (NULL != tmp)
 			gsf_xml_out_add_cstr_unchecked (info->xml, "operator", tmp);
@@ -1380,9 +1380,9 @@ xlsx_write_validation (XLValInputPair const *vip, gpointer dummy, XLSXClosure *i
 		tmp = NULL;
 		switch (vip->v->style) {
 		default : /* fall back to the default */
-		case VALIDATION_STYLE_STOP : /* "stop" the default */ break;
-		case VALIDATION_STYLE_WARNING : tmp = "warning"; break;
-		case VALIDATION_STYLE_INFO : tmp = "information"; break;
+		case GNM_VALIDATION_STYLE_STOP : /* "stop" the default */ break;
+		case GNM_VALIDATION_STYLE_WARNING : tmp = "warning"; break;
+		case GNM_VALIDATION_STYLE_INFO : tmp = "information"; break;
 		}
 		if (NULL != tmp)
 			gsf_xml_out_add_cstr_unchecked (info->xml, "errorStyle", tmp);
diff --git a/plugins/fn-info/functions.c b/plugins/fn-info/functions.c
index 5539ba1..c52637d 100644
--- a/plugins/fn-info/functions.c
+++ b/plugins/fn-info/functions.c
@@ -283,15 +283,15 @@ gnumeric_cell (GnmFuncEvalInfo *ei, GnmValue const * const *argv)
 
 		if (cell && cell->value && VALUE_IS_STRING (cell->value)) {
 			switch (gnm_style_get_align_h (mstyle)) {
-			case HALIGN_GENERAL:
-			case HALIGN_LEFT:
-			case HALIGN_JUSTIFY:
-			case HALIGN_DISTRIBUTED:
+			case GNM_HALIGN_GENERAL:
+			case GNM_HALIGN_LEFT:
+			case GNM_HALIGN_JUSTIFY:
+			case GNM_HALIGN_DISTRIBUTED:
 						return value_new_string ("'");
-			case HALIGN_RIGHT:	return value_new_string ("\"");
-			case HALIGN_CENTER_ACROSS_SELECTION:
-			case HALIGN_CENTER:	return value_new_string ("^");
-			case HALIGN_FILL:	return value_new_string ("\\");
+			case GNM_HALIGN_RIGHT:	return value_new_string ("\"");
+			case GNM_HALIGN_CENTER_ACROSS_SELECTION:
+			case GNM_HALIGN_CENTER:	return value_new_string ("^");
+			case GNM_HALIGN_FILL:	return value_new_string ("\\");
 			default :		return value_new_string ("");
 			}
 		}
diff --git a/plugins/html/html.c b/plugins/html/html.c
index e765564..0210cc0 100644
--- a/plugins/html/html.c
+++ b/plugins/html/html.c
@@ -493,35 +493,35 @@ write_cell (GsfOutput *output, Sheet *sheet, gint row, gint col, html_version_t
 	if (cell != NULL) {
 
 		switch (gnm_style_get_align_v (style)) {
-		case VALIGN_TOP:
+		case GNM_VALIGN_TOP:
 			gsf_output_puts (output, " valign=\"top\" ");
 			break;
-		case VALIGN_BOTTOM:
+		case GNM_VALIGN_BOTTOM:
 			gsf_output_puts (output, " valign=\"bottom\" ");
 			break;
-		case VALIGN_DISTRIBUTED:
-		case VALIGN_CENTER:
+		case GNM_VALIGN_DISTRIBUTED:
+		case GNM_VALIGN_CENTER:
 			gsf_output_puts (output, " valign=\"center\" ");
 			break;
-		case VALIGN_JUSTIFY:
+		case GNM_VALIGN_JUSTIFY:
 			gsf_output_puts (output, " valign=\"baseline\" ");
 			break;
 		default:
 			break;
 		}
 		switch (gnm_style_default_halign (style, cell)) {
-		case HALIGN_RIGHT:
+		case GNM_HALIGN_RIGHT:
 			gsf_output_puts (output, " align=\"right\" ");
 			break;
-		case HALIGN_DISTRIBUTED:
-		case HALIGN_CENTER:
-		case HALIGN_CENTER_ACROSS_SELECTION:
+		case GNM_HALIGN_DISTRIBUTED:
+		case GNM_HALIGN_CENTER:
+		case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 			gsf_output_puts (output, " align=\"center\" ");
 			break;
-		case HALIGN_LEFT:
+		case GNM_HALIGN_LEFT:
 			gsf_output_puts (output, " align=\"left\" ");
 			break;
-		case HALIGN_JUSTIFY:
+		case GNM_HALIGN_JUSTIFY:
 			gsf_output_puts (output, " align=\"justify\" ");
 			break;
 		default:
diff --git a/plugins/html/latex.c b/plugins/html/latex.c
index c55879b..2065f4e 100644
--- a/plugins/html/latex.c
+++ b/plugins/html/latex.c
@@ -930,20 +930,20 @@ latex2e_write_multicolumn_cell (GsfOutput *output, GnmCell *cell, int start_col,
 
 
 	/* Send the alignment of the cell through a routine to deal with
-	 * HALIGN_GENERAL and then deal with the three cases. */
+	 * GNM_HALIGN_GENERAL and then deal with the three cases. */
 	switch (gnm_style_default_halign (style, cell)) {
-	case HALIGN_RIGHT:
+	case GNM_HALIGN_RIGHT:
 		gsf_output_printf (output, "\\gnumericPB{\\raggedleft}");
 		break;
-	case HALIGN_DISTRIBUTED:
-	case HALIGN_CENTER:
-	case HALIGN_CENTER_ACROSS_SELECTION:
+	case GNM_HALIGN_DISTRIBUTED:
+	case GNM_HALIGN_CENTER:
+	case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 		gsf_output_printf (output, "\\gnumericPB{\\centering}");
 		break;
-	case HALIGN_LEFT:
+	case GNM_HALIGN_LEFT:
 		gsf_output_printf (output, "\\gnumericPB{\\raggedright}");
 		break;
-	case HALIGN_JUSTIFY:
+	case GNM_HALIGN_JUSTIFY:
 		break;
 	default:
 		break;
@@ -956,18 +956,18 @@ latex2e_write_multicolumn_cell (GsfOutput *output, GnmCell *cell, int start_col,
 	/* it to the second line of the parbox */
 	if (!wrap)
 		switch (gnm_style_default_halign (style, cell)) {
-		case HALIGN_RIGHT:
+		case GNM_HALIGN_RIGHT:
 			gsf_output_printf (output, "\\gnumbox[r]{");
 			break;
-		case HALIGN_DISTRIBUTED:
-		case HALIGN_CENTER:
-		case HALIGN_CENTER_ACROSS_SELECTION:
+		case GNM_HALIGN_DISTRIBUTED:
+		case GNM_HALIGN_CENTER:
+		case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 			gsf_output_printf (output, "\\gnumbox{");
 			break;
-		case HALIGN_LEFT:
+		case GNM_HALIGN_LEFT:
 			gsf_output_printf (output, "\\gnumbox[l]{");
 			break;
-		case HALIGN_JUSTIFY:
+		case GNM_HALIGN_JUSTIFY:
 			gsf_output_printf (output, "\\gnumbox[s]{");
 			break;
 		default:
diff --git a/plugins/html/roff.c b/plugins/html/roff.c
index db65a5d..6da970a 100644
--- a/plugins/html/roff.c
+++ b/plugins/html/roff.c
@@ -124,12 +124,12 @@ roff_file_save (GOFileSaver const *fs, GOIOContext *io_context,
 					GnmStyle const *style = gnm_cell_get_style (cell);
 					if (!style)
 						break;
-					if (gnm_style_get_align_h (style) & HALIGN_RIGHT)
+					if (gnm_style_get_align_h (style) & GNM_HALIGN_RIGHT)
 						gsf_output_printf (output, "r");
-					else if (gnm_style_get_align_h (style) == HALIGN_CENTER ||
+					else if (gnm_style_get_align_h (style) == GNM_HALIGN_CENTER ||
 						 /* FIXME : center across selection is different */
-						 gnm_style_get_align_h (style) == HALIGN_CENTER_ACROSS_SELECTION ||
-						 gnm_style_get_align_h (style) == HALIGN_DISTRIBUTED)
+						 gnm_style_get_align_h (style) == GNM_HALIGN_CENTER_ACROSS_SELECTION ||
+						 gnm_style_get_align_h (style) == GNM_HALIGN_DISTRIBUTED)
 						gsf_output_printf (output, "c");
 					else
 						gsf_output_printf (output, "l");
diff --git a/plugins/lotus-123/lotus.c b/plugins/lotus-123/lotus.c
index fb5d58c..53e4435 100644
--- a/plugins/lotus-123/lotus.c
+++ b/plugins/lotus-123/lotus.c
@@ -2858,32 +2858,32 @@ lotus_read_works (LotusState *state, record_t *r)
 			tmp = (align >> 2) & 7;
 			switch (tmp) {
 				case 1:
-					tmp = HALIGN_LEFT;
+					tmp = GNM_HALIGN_LEFT;
 					break;
 				case 2:
-					tmp = HALIGN_CENTER;
+					tmp = GNM_HALIGN_CENTER;
 					break;
 				case 3:
-					tmp = HALIGN_RIGHT;
+					tmp = GNM_HALIGN_RIGHT;
 					break;
 				case 4:
-					tmp = HALIGN_FILL;
+					tmp = GNM_HALIGN_FILL;
 					break;
 				default:
-					tmp = HALIGN_GENERAL;
+					tmp = GNM_HALIGN_GENERAL;
 			}
 			gnm_style_set_align_h(style, tmp);
 
 			tmp = (align >> 6) & 3;
 			switch (tmp) {
 				case 0:
-					tmp = VALIGN_BOTTOM;
+					tmp = GNM_VALIGN_BOTTOM;
 					break;
 				case 1:
-					tmp = VALIGN_CENTER;
+					tmp = GNM_VALIGN_CENTER;
 					break;
 				case 2:
-					tmp = VALIGN_TOP;
+					tmp = GNM_VALIGN_TOP;
 					break;
 			}
 			gnm_style_set_align_v(style, tmp);
diff --git a/plugins/oleo/oleo.c b/plugins/oleo/oleo.c
index d3a0875..6e2d0ee 100644
--- a/plugins/oleo/oleo.c
+++ b/plugins/oleo/oleo.c
@@ -209,10 +209,10 @@ oleo_parse_style (OleoReader *state, guint8 *str, GnmStyle **res)
 			}
 			break;
 		case 'L':
-			gnm_style_set_align_h (style, HALIGN_LEFT);
+			gnm_style_set_align_h (style, GNM_HALIGN_LEFT);
 			break;
 		case 'R':
-			gnm_style_set_align_h (style, HALIGN_RIGHT);
+			gnm_style_set_align_h (style, GNM_HALIGN_RIGHT);
 		}
 	}
 	if (fmt_string->len)
diff --git a/plugins/openoffice/openoffice-read.c b/plugins/openoffice/openoffice-read.c
index 91ebebc..c959c22 100644
--- a/plugins/openoffice/openoffice-read.c
+++ b/plugins/openoffice/openoffice-read.c
@@ -2016,9 +2016,9 @@ odf_validation_new_list (GsfXMLIn *xin, odf_validation_t *val, guint offset)
 				   val->f_type);
 
 	if (texpr != NULL)
-		validation = validation_new (VALIDATION_STYLE_WARNING,
-					     VALIDATION_TYPE_IN_LIST,
-					     VALIDATION_OP_NONE,
+		validation = validation_new (GNM_VALIDATION_STYLE_WARNING,
+					     GNM_VALIDATION_TYPE_IN_LIST,
+					     GNM_VALIDATION_OP_NONE,
 					     NULL, NULL,
 					     texpr,
 					     NULL,
@@ -2063,7 +2063,7 @@ odf_validation_new_single_expr (GsfXMLIn *xin, odf_validation_t *val,
 				   val->f_type);
 
 	if (texpr != NULL)
-		return validation_new (VALIDATION_STYLE_WARNING,
+		return validation_new (GNM_VALIDATION_STYLE_WARNING,
 				       val_type,
 				       val_op,
 				       NULL, NULL,
@@ -2135,7 +2135,7 @@ odf_validation_new_pair_expr (GsfXMLIn *xin, odf_validation_t *val,
 		 val->f_type);
 
 	if (texpr_b != NULL)
-		return validation_new (VALIDATION_STYLE_WARNING,
+		return validation_new (GNM_VALIDATION_STYLE_WARNING,
 				       val_type,
 				       val_op,
 				       NULL, NULL,
@@ -2158,39 +2158,39 @@ odf_validation_new_between (GsfXMLIn *xin, odf_validation_t *val, guint offset,
 		start++;
 
 	return odf_validation_new_pair_expr
-		(xin, val, start, vtype, no_not ? VALIDATION_OP_BETWEEN : VALIDATION_OP_NOT_BETWEEN);
+		(xin, val, start, vtype, no_not ? GNM_VALIDATION_OP_BETWEEN : GNM_VALIDATION_OP_NOT_BETWEEN);
 }
 
 static GnmValidation *
 odf_validation_new_op (GsfXMLIn *xin, odf_validation_t *val, guint offset, ValidationType vtype)
 {
 	char *start = val->condition + offset;
-	ValidationOp val_op = VALIDATION_OP_NONE;
+	ValidationOp val_op = GNM_VALIDATION_OP_NONE;
 
 	while (*start == ' ')
 		start++;
 
 	if (g_str_has_prefix (start, ">=")) {
-		val_op = VALIDATION_OP_GTE;
+		val_op = GNM_VALIDATION_OP_GTE;
 		start += 2;
 	} else if (g_str_has_prefix (start, "<=")) {
-		val_op = VALIDATION_OP_LTE;
+		val_op = GNM_VALIDATION_OP_LTE;
 		start += 2;
 	} else if (g_str_has_prefix (start, "!=")) {
-		val_op = VALIDATION_OP_NOT_EQUAL;
+		val_op = GNM_VALIDATION_OP_NOT_EQUAL;
 		start += 2;
 	} else if (g_str_has_prefix (start, "=")) {
-		val_op = VALIDATION_OP_EQUAL;
+		val_op = GNM_VALIDATION_OP_EQUAL;
 		start += 1;
 	} else if (g_str_has_prefix (start, ">")) {
-		val_op = VALIDATION_OP_GT;
+		val_op = GNM_VALIDATION_OP_GT;
 		start += 1;
 	} else if (g_str_has_prefix (start, "<")) {
-		val_op = VALIDATION_OP_LT;
+		val_op = GNM_VALIDATION_OP_LT;
 		start += 1;
 	}
 
-	if (val_op == VALIDATION_OP_NONE)
+	if (val_op == GNM_VALIDATION_OP_NONE)
 		return NULL;
 
 	while (*start == ' ')
@@ -2214,41 +2214,41 @@ odf_validations_analyze (GsfXMLIn *xin, odf_validation_t *val, guint offset, Val
 	else if (g_str_has_prefix (str, "cell-content-text-length()"))
 		return odf_validation_new_op
 			(xin, val, str - val->condition + strlen ("cell-content-text-length()"),
-			 VALIDATION_TYPE_TEXT_LENGTH);
+			 GNM_VALIDATION_TYPE_TEXT_LENGTH);
 	else if (g_str_has_prefix (str, "cell-content-text-length-is-between"))
 		return odf_validation_new_between
 			(xin, val, str - val->condition + strlen ("cell-content-text-length-is-between"),
-			 VALIDATION_TYPE_TEXT_LENGTH, TRUE);
+			 GNM_VALIDATION_TYPE_TEXT_LENGTH, TRUE);
 	else if (g_str_has_prefix (str, "cell-content-text-length-is-not-between"))
 		return odf_validation_new_between
 			(xin, val, str - val->condition + strlen ("cell-content-text-length-is-not-between"),
-			 VALIDATION_TYPE_TEXT_LENGTH, FALSE);
+			 GNM_VALIDATION_TYPE_TEXT_LENGTH, FALSE);
 	else if (g_str_has_prefix (str, "cell-content-is-decimal-number() and"))
 		return odf_validations_analyze
 			(xin, val, str - val->condition + strlen ("cell-content-is-decimal-number() and"),
-			 VALIDATION_TYPE_AS_NUMBER);
+			 GNM_VALIDATION_TYPE_AS_NUMBER);
 	else if (g_str_has_prefix (str, "cell-content-is-whole-number() and"))
 		return odf_validations_analyze
 			(xin, val, str - val->condition + strlen ("cell-content-is-whole-number() and"),
-			 VALIDATION_TYPE_AS_INT);
+			 GNM_VALIDATION_TYPE_AS_INT);
 	else if (g_str_has_prefix (str, "cell-content-is-date() and"))
 		return odf_validations_analyze
 			(xin, val, str - val->condition + strlen ("cell-content-is-date() and"),
-			 VALIDATION_TYPE_AS_DATE);
+			 GNM_VALIDATION_TYPE_AS_DATE);
 	else if (g_str_has_prefix (str, "cell-content-is-time() and"))
 		return odf_validations_analyze
 			(xin, val, str - val->condition + strlen ("cell-content-is-time() and"),
-			 VALIDATION_TYPE_AS_TIME);
+			 GNM_VALIDATION_TYPE_AS_TIME);
 	else if (g_str_has_prefix (str, "is-true-formula")) {
-		if (vtype != VALIDATION_TYPE_ANY) {
+		if (vtype != GNM_VALIDATION_TYPE_ANY) {
 			oo_warning
 			(xin, _("Validation condition '%s' is not supported. "
 				"It has been changed to '%s'."),
 			 val->condition, str);
 		}
 		return odf_validation_new_single_expr
-			(xin, val, str + strlen ("is-true-formula"), VALIDATION_TYPE_CUSTOM,
-			 VALIDATION_OP_NONE);
+			(xin, val, str + strlen ("is-true-formula"), GNM_VALIDATION_TYPE_CUSTOM,
+			 GNM_VALIDATION_OP_NONE);
 	} else if (g_str_has_prefix (str, "cell-content()"))
 		return odf_validation_new_op
 			(xin, val, str - val->condition + strlen ("cell-content()"),
@@ -2281,7 +2281,7 @@ odf_validations_translate (GsfXMLIn *xin, char const *name)
 
 	if (val->condition != NULL && val->f_type != FORMULA_NOT_SUPPORTED) {
 		GnmValidation *validation = odf_validations_analyze
-			(xin, val, 0, VALIDATION_TYPE_ANY);
+			(xin, val, 0, GNM_VALIDATION_TYPE_ANY);
 		if (validation != NULL) {
 			GError   *err;
 			if (NULL == (err = validation_is_ok (validation)))
@@ -5279,10 +5279,10 @@ static void
 odf_style_set_align_h (GnmStyle *style, gboolean h_align_is_valid, gboolean repeat_content,
 		       int text_align, int gnm_halign)
 {
-	int alignment = HALIGN_GENERAL;
+	int alignment = GNM_HALIGN_GENERAL;
 	if (h_align_is_valid)
-		alignment = repeat_content ? HALIGN_FILL
-			: ((text_align < 0) ? ((gnm_halign > -1) ? gnm_halign : HALIGN_LEFT)
+		alignment = repeat_content ? GNM_HALIGN_FILL
+			: ((text_align < 0) ? ((gnm_halign > -1) ? gnm_halign : GNM_HALIGN_LEFT)
 			   : text_align);
 
 	gnm_style_set_align_h (style, alignment);
@@ -5310,18 +5310,18 @@ oo_style_prop_cell (GsfXMLIn *xin, xmlChar const **attrs)
 	};
 	static OOEnum const h_alignments [] = {
 		{ "start",	-1 },            /* see below, we may have a gnm:GnmHAlign attribute */
-		{ "left",	HALIGN_LEFT },
-		{ "center",	HALIGN_CENTER },
-		{ "end",	HALIGN_RIGHT },   /* This really depends on the text direction */
-		{ "right",	HALIGN_RIGHT },
-		{ "justify",	HALIGN_JUSTIFY },
-		{ "automatic",	HALIGN_GENERAL },
+		{ "left",	GNM_HALIGN_LEFT },
+		{ "center",	GNM_HALIGN_CENTER },
+		{ "end",	GNM_HALIGN_RIGHT },   /* This really depends on the text direction */
+		{ "right",	GNM_HALIGN_RIGHT },
+		{ "justify",	GNM_HALIGN_JUSTIFY },
+		{ "automatic",	GNM_HALIGN_GENERAL },
 		{ NULL,	0 },
 	};
 	static OOEnum const v_alignments [] = {
-		{ "bottom",	VALIGN_BOTTOM },
-		{ "top",	VALIGN_TOP },
-		{ "middle",	VALIGN_CENTER },
+		{ "bottom",	GNM_VALIGN_BOTTOM },
+		{ "top",	GNM_VALIGN_TOP },
+		{ "middle",	GNM_VALIGN_CENTER },
 		{ "automatic",	-1 },            /* see below, we may have a gnm:GnmVAlign attribute */
 		{ NULL,	0 },
 	};
@@ -5383,7 +5383,7 @@ oo_style_prop_cell (GsfXMLIn *xin, xmlChar const **attrs)
 				v_alignment_is_fixed = TRUE;
 			} else if (!v_alignment_is_fixed)
                                 /* This should depend on the rotation */
-				gnm_style_set_align_v (style, VALIGN_BOTTOM);
+				gnm_style_set_align_v (style, GNM_VALIGN_BOTTOM);
 		} else if (oo_attr_int (xin,attrs, OO_GNUM_NS_EXT, "GnmVAlign", &tmp)) {
 			if (!v_alignment_is_fixed) {
 				gnm_style_set_align_v (style, tmp);
diff --git a/plugins/openoffice/openoffice-write.c b/plugins/openoffice/openoffice-write.c
index 6894fd8..266df37 100644
--- a/plugins/openoffice/openoffice-write.c
+++ b/plugins/openoffice/openoffice-write.c
@@ -1124,17 +1124,17 @@ odf_write_style_cell_properties (GnmOOExport *state, GnmStyle const *style)
 		char const *alignment = NULL;
 		gboolean gnum_specs = FALSE;
 		switch (align) {
-		case VALIGN_TOP:
+		case GNM_VALIGN_TOP:
 			alignment = "top";
 			break;
-		case VALIGN_BOTTOM:
+		case GNM_VALIGN_BOTTOM:
 			alignment= "bottom";
 			break;
-		case VALIGN_CENTER:
+		case GNM_VALIGN_CENTER:
 			alignment = "middle";
 			break;
-		case VALIGN_JUSTIFY:
-		case VALIGN_DISTRIBUTED:
+		case GNM_VALIGN_JUSTIFY:
+		case GNM_VALIGN_DISTRIBUTED:
 		default:
 			alignment = "automatic";
 			gnum_specs = TRUE;
@@ -1225,17 +1225,17 @@ odf_write_style_cell_properties (GnmOOExport *state, GnmStyle const *style)
 		GnmHAlign align = gnm_style_get_align_h (style);
 		char const *source = NULL;
 		switch (align) {
-		case HALIGN_LEFT:
-		case HALIGN_RIGHT:
-		case HALIGN_CENTER:
-		case HALIGN_JUSTIFY:
+		case GNM_HALIGN_LEFT:
+		case GNM_HALIGN_RIGHT:
+		case GNM_HALIGN_CENTER:
+		case GNM_HALIGN_JUSTIFY:
 		        source = "fix";
 			break;
-		case HALIGN_FILL:
+		case GNM_HALIGN_FILL:
 			rep_content = TRUE;
-		case HALIGN_GENERAL:
-		case HALIGN_CENTER_ACROSS_SELECTION:
-		case HALIGN_DISTRIBUTED:
+		case GNM_HALIGN_GENERAL:
+		case GNM_HALIGN_CENTER_ACROSS_SELECTION:
+		case GNM_HALIGN_DISTRIBUTED:
 		default:
 			/* Note that since source is value-type, alignment should be ignored */
                         /*(but isn't by OOo) */
@@ -1268,23 +1268,23 @@ odf_write_style_paragraph_properties (GnmOOExport *state, GnmStyle const *style)
 		char const *alignment = NULL;
 		gboolean gnum_specs = FALSE;
 		switch (align) {
-		case HALIGN_LEFT:
+		case GNM_HALIGN_LEFT:
 			alignment = "left";
 			break;
-		case HALIGN_RIGHT:
+		case GNM_HALIGN_RIGHT:
 			alignment= "right";
 			break;
-		case HALIGN_CENTER:
+		case GNM_HALIGN_CENTER:
 			alignment = "center";
 			break;
-		case HALIGN_JUSTIFY:
+		case GNM_HALIGN_JUSTIFY:
 			alignment = "justify";
 			break;
-		case HALIGN_FILL:
+		case GNM_HALIGN_FILL:
 			break;
-		case HALIGN_GENERAL:
-		case HALIGN_CENTER_ACROSS_SELECTION:
-		case HALIGN_DISTRIBUTED:
+		case GNM_HALIGN_GENERAL:
+		case GNM_HALIGN_CENTER_ACROSS_SELECTION:
+		case GNM_HALIGN_DISTRIBUTED:
 		default:
 			/* Note that since source is value-type, alignment should be ignored */
                         /*(but isn't by OOo) */
@@ -1292,7 +1292,7 @@ odf_write_style_paragraph_properties (GnmOOExport *state, GnmStyle const *style)
 			gnum_specs = TRUE;
 			break;
 		}
-		if (align != HALIGN_GENERAL && align != HALIGN_FILL)
+		if (align != GNM_HALIGN_GENERAL && align != GNM_HALIGN_FILL)
 			gsf_xml_out_add_cstr (state->xml, FOSTYLE "text-align", alignment);
 		if (gnum_specs && state->with_extension)
 			gsf_xml_out_add_int (state->xml, GNMSTYLE "GnmHAlign", align);
@@ -4063,38 +4063,38 @@ odf_validation_general (GnmOOExport *state, GnmValidation const *val,
 	str = g_string_append (str, prefix);
 
 	switch (val->op) {
-	case VALIDATION_OP_NONE:
+	case GNM_VALIDATION_OP_NONE:
 		str = g_string_append (str, "is-true-formula(1)");
 		break;
-	case VALIDATION_OP_BETWEEN:
+	case GNM_VALIDATION_OP_BETWEEN:
 		str = g_string_append (str, "cell-content-is-between");
 		odf_validation_append_expression_pair (state, str, val, pp);
 		break;
-	case VALIDATION_OP_NOT_BETWEEN:
+	case GNM_VALIDATION_OP_NOT_BETWEEN:
 		str = g_string_append (str, "cell-content-is-not-between");
 		odf_validation_append_expression_pair (state, str, val, pp);
 		break;
-	case VALIDATION_OP_EQUAL:
+	case GNM_VALIDATION_OP_EQUAL:
 		str = g_string_append (str, "cell-content() = ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_NOT_EQUAL:
+	case GNM_VALIDATION_OP_NOT_EQUAL:
 		str = g_string_append (str, "cell-content() != ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_GT:
+	case GNM_VALIDATION_OP_GT:
 		str = g_string_append (str, "cell-content() > ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_LT:
+	case GNM_VALIDATION_OP_LT:
 		str = g_string_append (str, "cell-content() < ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_GTE:
+	case GNM_VALIDATION_OP_GTE:
 		str = g_string_append (str, "cell-content() >= ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_LTE:
+	case GNM_VALIDATION_OP_LTE:
 		str = g_string_append (str, "cell-content() <= ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
@@ -4112,38 +4112,38 @@ odf_validation_length (GnmOOExport *state, GnmValidation const *val,
 	GString *str = g_string_new ("of:");
 
 	switch (val->op) {
-	case VALIDATION_OP_NONE:
+	case GNM_VALIDATION_OP_NONE:
 		str = g_string_append (str, "is-true-formula(1)");
 		break;
-	case VALIDATION_OP_BETWEEN:
+	case GNM_VALIDATION_OP_BETWEEN:
 		str = g_string_append (str, "cell-content-text-length-is-between");
 		odf_validation_append_expression_pair (state, str, val, pp);
 		break;
-	case VALIDATION_OP_NOT_BETWEEN:
+	case GNM_VALIDATION_OP_NOT_BETWEEN:
 		str = g_string_append (str, "cell-content-text-length-is-not-between");
 		odf_validation_append_expression_pair (state, str, val, pp);
 		break;
-	case VALIDATION_OP_EQUAL:
+	case GNM_VALIDATION_OP_EQUAL:
 		str = g_string_append (str, "cell-content-text-length() = ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_NOT_EQUAL:
+	case GNM_VALIDATION_OP_NOT_EQUAL:
 		str = g_string_append (str, "cell-content-text-length() != ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_GT:
+	case GNM_VALIDATION_OP_GT:
 		str = g_string_append (str, "cell-content-text-length() > ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_LT:
+	case GNM_VALIDATION_OP_LT:
 		str = g_string_append (str, "cell-content-text-length() < ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_GTE:
+	case GNM_VALIDATION_OP_GTE:
 		str = g_string_append (str, "of:cell-content-text-length() >= ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
-	case VALIDATION_OP_LTE:
+	case GNM_VALIDATION_OP_LTE:
 		str = g_string_append (str, "cell-content-text-length() <= ");
 		odf_validation_append_expression (state, str, val->texpr[0], pp);
 		break;
@@ -4210,32 +4210,32 @@ odf_print_spreadsheet_content_validations (GnmOOExport *state)
 			odf_validation_general_attributes (state, val);
 			odf_validation_base_cell_address (state, sheet, sr, &pp);
 			switch (val->type) {
-			case VALIDATION_TYPE_ANY:
+			case GNM_VALIDATION_TYPE_ANY:
 				odf_validation_general (state, val, sheet, sr, "", &pp);
 				break;
-			case VALIDATION_TYPE_AS_INT:
+			case GNM_VALIDATION_TYPE_AS_INT:
 				odf_validation_general (state, val, sheet, sr,
 							"cell-content-is-whole-number() and ", &pp);
 				break;
-			case VALIDATION_TYPE_AS_NUMBER:
+			case GNM_VALIDATION_TYPE_AS_NUMBER:
 				odf_validation_general (state, val, sheet, sr,
 							"cell-content-is-decimal-number() and ", &pp);
 				break;
-			case VALIDATION_TYPE_AS_DATE:
+			case GNM_VALIDATION_TYPE_AS_DATE:
 				odf_validation_general (state, val, sheet, sr,
 							"ell-content-is-date() and ", &pp);
 				break;
-			case VALIDATION_TYPE_AS_TIME:
+			case GNM_VALIDATION_TYPE_AS_TIME:
 				odf_validation_general (state, val, sheet, sr,
 							"ell-content-is-time() and ", &pp);
 				break;
-			case VALIDATION_TYPE_IN_LIST:
+			case GNM_VALIDATION_TYPE_IN_LIST:
 				odf_validation_in_list (state, val, sheet, sr, &pp);
 				break;
-			case VALIDATION_TYPE_TEXT_LENGTH:
+			case GNM_VALIDATION_TYPE_TEXT_LENGTH:
 				odf_validation_length (state, val, sheet, sr, &pp);
 				break;
-			case VALIDATION_TYPE_CUSTOM:
+			case GNM_VALIDATION_TYPE_CUSTOM:
 				odf_validation_custom (state, val, sheet, sr, &pp);
 				break;
 			}
diff --git a/plugins/plan-perfect/pln.c b/plugins/plan-perfect/pln.c
index 293402f..c7f8eed 100644
--- a/plugins/plan-perfect/pln.c
+++ b/plugins/plan-perfect/pln.c
@@ -210,12 +210,12 @@ pln_get_style (PlanPerfectImport *state, guint8 const* data, gboolean is_cell)
 			attr &= 0xf8ff;
 			switch (gnm_style_get_align_h (def)) {
 			default :
-			case HALIGN_GENERAL:break;
-			case HALIGN_LEFT:	attr |= 0x0100; break;
-			case HALIGN_RIGHT:	attr |= 0x0200; break;
-			case HALIGN_DISTRIBUTED:
-			case HALIGN_CENTER_ACROSS_SELECTION :
-			case HALIGN_CENTER:	attr |= 0x0300; break;
+			case GNM_HALIGN_GENERAL:break;
+			case GNM_HALIGN_LEFT:	attr |= 0x0100; break;
+			case GNM_HALIGN_RIGHT:	attr |= 0x0200; break;
+			case GNM_HALIGN_DISTRIBUTED:
+			case GNM_HALIGN_CENTER_ACROSS_SELECTION :
+			case GNM_HALIGN_CENTER:	attr |= 0x0300; break;
 			}
 		}
 		if ((attr & 0x8000)) {
@@ -233,7 +233,7 @@ pln_get_style (PlanPerfectImport *state, guint8 const* data, gboolean is_cell)
 	res = g_hash_table_lookup (state->styles, GINT_TO_POINTER (key));
 	if (res == NULL) {
 		static GnmHAlign const haligns[] = {
-			HALIGN_GENERAL, HALIGN_LEFT, HALIGN_RIGHT, HALIGN_CENTER
+			GNM_HALIGN_GENERAL, GNM_HALIGN_LEFT, GNM_HALIGN_RIGHT, GNM_HALIGN_CENTER
 		};
 		res = gnm_style_new_default ();
 		gnm_style_set_font_italic (res, (attr & 0x0010) ? TRUE : FALSE);
diff --git a/plugins/qpro/qpro-read.c b/plugins/qpro/qpro-read.c
index cfa536a..fb325a6 100644
--- a/plugins/qpro/qpro-read.c
+++ b/plugins/qpro/qpro-read.c
@@ -753,26 +753,26 @@ qpro_read_sheet (QProReadState *state)
 			if (validate (QPRO_LABEL_CELL, -1)) {
 				int col = data[0];
 				int row = GSF_LE_GET_GUINT16 (data + 2);
-				GnmHAlign align = HALIGN_GENERAL;
+				GnmHAlign align = GNM_HALIGN_GENERAL;
 				GnmStyle *as = qpro_get_style (state, data + 4);
 				GnmHAlign asa = gnm_style_is_element_set (as, MSTYLE_ALIGN_H)
 					? gnm_style_get_align_h (as)
-					: HALIGN_GENERAL;
-				if (asa == HALIGN_GENERAL)
-					asa = HALIGN_LEFT;
+					: GNM_HALIGN_GENERAL;
+				if (asa == GNM_HALIGN_GENERAL)
+					asa = GNM_HALIGN_LEFT;
 
 				sheet_style_set_pos (sheet, col, row, as);
 				switch (data[6]) {
-				case '\'': align = HALIGN_LEFT; break;
-				case '^':  align = HALIGN_CENTER; break;
-				case '"':  align = HALIGN_RIGHT; break;
+				case '\'': align = GNM_HALIGN_LEFT; break;
+				case '^':  align = GNM_HALIGN_CENTER; break;
+				case '"':  align = GNM_HALIGN_RIGHT; break;
 				case '\\': break; /* Repeat */
 				case '|':  break; /* Page break */
 				case 0:    break; /* Nothing */
 				default:
 					g_printerr ("Ignoring unknown alignment\n");
 				}
-				if (align != HALIGN_GENERAL && align != asa) {
+				if (align != GNM_HALIGN_GENERAL && align != asa) {
 					GnmStyle *s = gnm_style_new ();
 					gnm_style_set_align_h (s, align);
 					sheet_style_apply_pos (sheet, col, row,
diff --git a/plugins/sc/sc.c b/plugins/sc/sc.c
index 64b01cd..852b469 100644
--- a/plugins/sc/sc.c
+++ b/plugins/sc/sc.c
@@ -609,9 +609,9 @@ sc_parse_label (ScParseState *state, char const *cmd, char const *str,
 	gnm_cell_set_text (cell, s);
 
 	if (strcmp (cmd, "leftstring") == 0)
-		set_h_align (state->sheet, pos, HALIGN_LEFT);
+		set_h_align (state->sheet, pos, GNM_HALIGN_LEFT);
 	else if (strcmp (cmd, "rightstring") == 0)
-		set_h_align (state->sheet, pos, HALIGN_RIGHT);
+		set_h_align (state->sheet, pos, GNM_HALIGN_RIGHT);
 #if 0
 	else
 		cmdtype = LABEL;
diff --git a/plugins/sylk/sylk.c b/plugins/sylk/sylk.c
index 75602dd..558f3e1 100644
--- a/plugins/sylk/sylk.c
+++ b/plugins/sylk/sylk.c
@@ -513,11 +513,11 @@ sylk_rtd_f_parse (SylkReader *state, char *str)
 				int a = -1;
 				switch (alignment) {
 				case 'S' : /* standard ? how does this differ from default */
-				case 'D' : a = HALIGN_GENERAL; break;
-				case 'L' : a = HALIGN_LEFT; break;
-				case 'R' : a = HALIGN_RIGHT; break;
-				case 'C' : a = HALIGN_CENTER; break;
-				case 'X' : a = HALIGN_FILL; break;
+				case 'D' : a = GNM_HALIGN_GENERAL; break;
+				case 'L' : a = GNM_HALIGN_LEFT; break;
+				case 'R' : a = GNM_HALIGN_RIGHT; break;
+				case 'C' : a = GNM_HALIGN_CENTER; break;
+				case 'X' : a = GNM_HALIGN_FILL; break;
 				default :
 					   break;
 				}
diff --git a/src/cell-draw.c b/src/cell-draw.c
index e200d5e..a4670a2 100644
--- a/src/cell-draw.c
+++ b/src/cell-draw.c
@@ -112,7 +112,7 @@ cell_calc_layout (G_GNUC_UNUSED GnmCell const *cell, GnmRenderedValue *rv, int y
 			hoffset += (width - indent) - rv->layout_natural_width;
 		}
 	} else if (!rv->rotation && rv->wrap_text
-		   && (rv->effective_halign != HALIGN_FILL)) {
+		   && (rv->effective_halign != GNM_HALIGN_FILL)) {
 		int wanted_width = MAX (0, width - indent);
 		if (wanted_width != pango_layout_get_width (layout)) {
 			pango_layout_set_wrap (layout, PANGO_WRAP_WORD_CHAR);
@@ -121,19 +121,19 @@ cell_calc_layout (G_GNUC_UNUSED GnmCell const *cell, GnmRenderedValue *rv, int y
 		}
 	} else {
 		switch (rv->effective_halign) {
-		case HALIGN_RIGHT:
+		case GNM_HALIGN_RIGHT:
 			hoffset += (width - indent) - rv->layout_natural_width;
 			break;
-		case HALIGN_DISTRIBUTED:
-		case HALIGN_CENTER:
+		case GNM_HALIGN_DISTRIBUTED:
+		case GNM_HALIGN_CENTER:
 			if (h_center == -1)
 				h_center = width / 2;
 			hoffset += h_center + (-indent - rv->layout_natural_width) / 2;
 			break;
-		case HALIGN_CENTER_ACROSS_SELECTION:
+		case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 			hoffset += ((width - indent) - rv->layout_natural_width) / 2;
 			break;
-		case HALIGN_FILL: {
+		case GNM_HALIGN_FILL: {
 			PangoDirection dir = PANGO_DIRECTION_LTR;
 			if (!rv->hfilled &&
 			    rv->layout_natural_width > 0 &&
@@ -182,9 +182,9 @@ cell_calc_layout (G_GNUC_UNUSED GnmCell const *cell, GnmRenderedValue *rv, int y
 #ifndef DEBUG_SWITCH_ENUM
 		default:
 #endif
-		case HALIGN_GENERAL:
+		case GNM_HALIGN_GENERAL:
 			g_warning ("Unhandled horizontal alignment.");
-		case HALIGN_LEFT:
+		case GNM_HALIGN_LEFT:
 			break;
 		}
 	}
@@ -199,11 +199,11 @@ cell_calc_layout (G_GNUC_UNUSED GnmCell const *cell, GnmRenderedValue *rv, int y
 		g_warning ("Unhandled vertical alignment.");
 		/* Fall through.  */
 #endif
-	case VALIGN_TOP:
+	case GNM_VALIGN_TOP:
 		text_base = rect_y;
 		break;
 
-	case VALIGN_BOTTOM: {
+	case GNM_VALIGN_BOTTOM: {
 		int dh = height - rv->layout_natural_height;
 		if (rv->rotation == 0 && dh < 0)
 			dh = 0;
@@ -211,8 +211,8 @@ cell_calc_layout (G_GNUC_UNUSED GnmCell const *cell, GnmRenderedValue *rv, int y
 		break;
 	}
 
-	case VALIGN_DISTRIBUTED: /* dunno what this does yet */
-	case VALIGN_CENTER: {
+	case GNM_VALIGN_DISTRIBUTED: /* dunno what this does yet */
+	case GNM_VALIGN_CENTER: {
 		int dh = (height - rv->layout_natural_height) / 2;
 		if (rv->rotation == 0 && dh < 0)
                         dh = 0;
@@ -220,7 +220,7 @@ cell_calc_layout (G_GNUC_UNUSED GnmCell const *cell, GnmRenderedValue *rv, int y
 		break;
 	}
 
-	case VALIGN_JUSTIFY:
+	case GNM_VALIGN_JUSTIFY:
 		text_base = rect_y;
 		if (!rv->vfilled && height > rv->layout_natural_height) {
 			int line_count = pango_layout_get_line_count (layout);
@@ -339,20 +339,20 @@ cell_draw_h_extension_markers (cairo_t *cr, GnmRenderedValue *rv,
 			       int width, int height)
 {
 	switch (rv->effective_halign) {
-	case HALIGN_GENERAL:
-	case HALIGN_LEFT:
+	case GNM_HALIGN_GENERAL:
+	case GNM_HALIGN_LEFT:
 		cell_draw_extension_mark_right (cr, x1, y1, width, height);
 		break;
-	case HALIGN_RIGHT:
+	case GNM_HALIGN_RIGHT:
 		cell_draw_extension_mark_left (cr, x1, y1, height);
 		break;
-	case HALIGN_DISTRIBUTED:
-	case HALIGN_CENTER:
-	case HALIGN_CENTER_ACROSS_SELECTION:
+	case GNM_HALIGN_DISTRIBUTED:
+	case GNM_HALIGN_CENTER:
+	case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 		cell_draw_extension_mark_right (cr, x1, y1, width, height);
 		cell_draw_extension_mark_left (cr, x1, y1, height);
 		break;
-	case HALIGN_FILL:
+	case GNM_HALIGN_FILL:
 	default:
 		break;
 	}
diff --git a/src/cellspan.c b/src/cellspan.c
index a36c614..ecb7b80 100644
--- a/src/cellspan.c
+++ b/src/cellspan.c
@@ -223,7 +223,7 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 	 *	- The alignment mode are set to "justify"
 	 */
 	if (sheet != NULL &&
-	    h_align != HALIGN_CENTER_ACROSS_SELECTION &&
+	    h_align != GNM_HALIGN_CENTER_ACROSS_SELECTION &&
 	    (gnm_cell_is_merged (cell) ||
 	     (!sheet->display_formulas && gnm_cell_is_number (cell)))) {
 		*col1 = *col2 = cell->pos.col;
@@ -233,28 +233,28 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 	v_align = gnm_style_get_align_v (style);
 	row   = cell->pos.row;
 	indented_w = cell_width_pixel = gnm_cell_rendered_width (cell);
-	if (h_align == HALIGN_LEFT || h_align == HALIGN_RIGHT) {
+	if (h_align == GNM_HALIGN_LEFT || h_align == GNM_HALIGN_RIGHT) {
 		GnmRenderedValue *rv = gnm_cell_get_rendered_value (cell);
 		char const *text = (rv)? pango_layout_get_text (rv->layout): NULL;
 		PangoDirection dir = (text && *text)? pango_find_base_dir (text, -1): PANGO_DIRECTION_LTR;
-		if (gnm_style_get_align_h (style) == HALIGN_GENERAL && dir == PANGO_DIRECTION_RTL)
-			h_align = HALIGN_RIGHT;
+		if (gnm_style_get_align_h (style) == GNM_HALIGN_GENERAL && dir == PANGO_DIRECTION_RTL)
+			h_align = GNM_HALIGN_RIGHT;
 		indented_w += gnm_cell_rendered_offset (cell);
 		if (sheet->text_is_rtl)
-			h_align = (h_align == HALIGN_LEFT) ? HALIGN_RIGHT : HALIGN_LEFT;
+			h_align = (h_align == GNM_HALIGN_LEFT) ? GNM_HALIGN_RIGHT : GNM_HALIGN_LEFT;
 	}
 
 	ci = sheet_col_get_info	(sheet, cell->pos.col);
 	if (gnm_cell_is_empty (cell) ||
 	    !ci->visible ||
-	    (h_align != HALIGN_CENTER_ACROSS_SELECTION &&
+	    (h_align != GNM_HALIGN_CENTER_ACROSS_SELECTION &&
 		 (gnm_style_get_wrap_text (style) ||
 		  indented_w <= COL_INTERNAL_WIDTH (ci))) ||
-	    h_align == HALIGN_JUSTIFY ||
-	    h_align == HALIGN_FILL ||
-	    h_align == HALIGN_DISTRIBUTED ||
-	    v_align == VALIGN_JUSTIFY ||
-	    v_align == VALIGN_DISTRIBUTED) {
+	    h_align == GNM_HALIGN_JUSTIFY ||
+	    h_align == GNM_HALIGN_FILL ||
+	    h_align == GNM_HALIGN_DISTRIBUTED ||
+	    v_align == GNM_VALIGN_JUSTIFY ||
+	    v_align == GNM_VALIGN_DISTRIBUTED) {
 		*col1 = *col2 = cell->pos.col;
 		return;
 	}
@@ -265,7 +265,7 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 
 	*col1 = *col2 = cell->pos.col;
 	switch (h_align) {
-	case HALIGN_LEFT:
+	case GNM_HALIGN_LEFT:
 		pos = cell->pos.col + 1;
 		left = indented_w - COL_INTERNAL_WIDTH (ci);
 
@@ -286,7 +286,7 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 		}
 		return;
 
-	case HALIGN_RIGHT:
+	case GNM_HALIGN_RIGHT:
 		pos = cell->pos.col - 1;
 		left = indented_w - COL_INTERNAL_WIDTH (ci);
 
@@ -307,7 +307,7 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 		}
 		return;
 
-	case HALIGN_CENTER: {
+	case GNM_HALIGN_CENTER: {
 		int remain_left, remain_right;
 		int pos_l, pos_r;
 
@@ -345,9 +345,9 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 			} else
 				remain_right = 0;
 		break;
-	} /* case HALIGN_CENTER */
+	} /* case GNM_HALIGN_CENTER */
 
-	case HALIGN_CENTER_ACROSS_SELECTION: {
+	case GNM_HALIGN_CENTER_ACROSS_SELECTION: {
 		int const row = cell->pos.row;
 		int pos_l, pos_r;
 
@@ -359,7 +359,7 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 					GnmStyle const * const style =
 						sheet_style_get (cell->base.sheet, pos_l, row);
 
-					if (gnm_style_get_align_h (style) != HALIGN_CENTER_ACROSS_SELECTION)
+					if (gnm_style_get_align_h (style) != GNM_HALIGN_CENTER_ACROSS_SELECTION)
 						break;
 					*col1 = pos_l;
 				} else
@@ -373,7 +373,7 @@ cell_calc_span (GnmCell const *cell, int *col1, int *col2)
 					GnmStyle const * const style =
 						sheet_style_get (cell->base.sheet, pos_r, row);
 
-					if (gnm_style_get_align_h (style) != HALIGN_CENTER_ACROSS_SELECTION)
+					if (gnm_style_get_align_h (style) != GNM_HALIGN_CENTER_ACROSS_SELECTION)
 						break;
 					*col2 = pos_r;
 				} else
diff --git a/src/commands.c b/src/commands.c
index 609e078..1834618 100644
--- a/src/commands.c
+++ b/src/commands.c
@@ -3949,7 +3949,7 @@ cmd_merge_cells_redo (GnmCommand *cmd, WorkbookControl *wbc)
 
 	if (me->center) {
 		align_center = gnm_style_new ();
-		gnm_style_set_align_h (align_center, HALIGN_CENTER);
+		gnm_style_set_align_h (align_center, GNM_HALIGN_CENTER);
 	}
 	sheet = me->cmd.sheet;
 	for (i = 0 ; i < me->ranges->len ; ++i) {
diff --git a/src/dialogs/ChangeLog b/src/dialogs/ChangeLog
index 7c60523..a98aa1b 100644
--- a/src/dialogs/ChangeLog
+++ b/src/dialogs/ChangeLog
@@ -1,3 +1,8 @@
+2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
+
+	* src/dialogs/dialog-cell-format.c: rename enums
+	* src/dialogs/dialog-scenarios.c: rename enums
+
 2011-11-21 Andreas J. Guelzow <aguelzow pyrshep ca>
 
 	* dialog-analysis-tool-kaplan-meier.c: remove unused variables
diff --git a/src/dialogs/dialog-cell-format.c b/src/dialogs/dialog-cell-format.c
index fd196dd..a18ef4d 100644
--- a/src/dialogs/dialog-cell-format.c
+++ b/src/dialogs/dialog-cell-format.c
@@ -526,7 +526,7 @@ cb_align_h_toggle (GtkToggleButton *button, FormatState *state)
 			GPOINTER_TO_INT (g_object_get_data (
 						 G_OBJECT (button), "align"));
 		gboolean const supports_indent =
-			(new_h == HALIGN_LEFT || new_h == HALIGN_RIGHT);
+			(new_h == GNM_HALIGN_LEFT || new_h == GNM_HALIGN_RIGHT);
 		gnm_style_set_align_h (state->result, new_h);
 		gtk_widget_set_sensitive (GTK_WIDGET (state->align.indent_button),
 					  supports_indent);
@@ -596,32 +596,32 @@ fmt_dialog_init_align_page (FormatState *state)
 		char const *const	name;
 		GnmHAlign	align;
 	} const h_buttons[] = {
-		{ "halign_left",	HALIGN_LEFT },
-		{ "halign_center",	HALIGN_CENTER },
-		{ "halign_right",	HALIGN_RIGHT },
-		{ "halign_general",	HALIGN_GENERAL },
-		{ "halign_justify",	HALIGN_JUSTIFY },
-		{ "halign_fill",	HALIGN_FILL },
-		{ "halign_center_across_selection",	HALIGN_CENTER_ACROSS_SELECTION },
-		{ "halign_distributed",			HALIGN_DISTRIBUTED },
+		{ "halign_left",	GNM_HALIGN_LEFT },
+		{ "halign_center",	GNM_HALIGN_CENTER },
+		{ "halign_right",	GNM_HALIGN_RIGHT },
+		{ "halign_general",	GNM_HALIGN_GENERAL },
+		{ "halign_justify",	GNM_HALIGN_JUSTIFY },
+		{ "halign_fill",	GNM_HALIGN_FILL },
+		{ "halign_center_across_selection",	GNM_HALIGN_CENTER_ACROSS_SELECTION },
+		{ "halign_distributed",			GNM_HALIGN_DISTRIBUTED },
 		{ NULL }
 	};
 	static struct {
 		char const *const	name;
 		GnmVAlign	align;
 	} const v_buttons[] = {
-		{ "valign_top", VALIGN_TOP },
-		{ "valign_center", VALIGN_CENTER },
-		{ "valign_bottom", VALIGN_BOTTOM },
-		{ "valign_justify", VALIGN_JUSTIFY },
-		{ "valign_distributed", VALIGN_DISTRIBUTED },
+		{ "valign_top", GNM_VALIGN_TOP },
+		{ "valign_center", GNM_VALIGN_CENTER },
+		{ "valign_bottom", GNM_VALIGN_BOTTOM },
+		{ "valign_justify", GNM_VALIGN_JUSTIFY },
+		{ "valign_distributed", GNM_VALIGN_DISTRIBUTED },
 		{ NULL }
 	};
 
 	GtkWidget *w;
 	gboolean wrap = FALSE;
-	GnmHAlign    h = HALIGN_GENERAL;
-	GnmVAlign    v = VALIGN_CENTER;
+	GnmHAlign    h = GNM_HALIGN_GENERAL;
+	GnmVAlign    v = GNM_VALIGN_CENTER;
 	char const *name;
 	int i, r;
 
@@ -654,7 +654,7 @@ fmt_dialog_init_align_page (FormatState *state)
 			  G_CALLBACK (cb_align_wrap_toggle), state);
 
 	if (0 == (state->conflicts & (1 << MSTYLE_INDENT)) ||
-	    (h != HALIGN_LEFT && h != HALIGN_RIGHT))
+	    (h != GNM_HALIGN_LEFT && h != GNM_HALIGN_RIGHT))
 		state->align.indent = 0;
 	else
 		state->align.indent = gnm_style_get_indent (state->style);
@@ -665,9 +665,9 @@ fmt_dialog_init_align_page (FormatState *state)
 	state->align.indent_button = GTK_SPIN_BUTTON (w);
 	gtk_spin_button_set_value (state->align.indent_button, state->align.indent);
 	gtk_widget_set_sensitive (GTK_WIDGET (state->align.indent_button),
-				  (h == HALIGN_LEFT || h == HALIGN_RIGHT));
+				  (h == GNM_HALIGN_LEFT || h == GNM_HALIGN_RIGHT));
 	gtk_widget_set_sensitive (GTK_WIDGET (state->align.indent_label),
-				  (h == HALIGN_LEFT || h == HALIGN_RIGHT));
+				  (h == GNM_HALIGN_LEFT || h == GNM_HALIGN_RIGHT));
 
 	/* Catch changes to the spin box */
 	g_signal_connect (G_OBJECT (w),
@@ -1563,7 +1563,7 @@ validation_rebuild_validation (FormatState *state)
 	type = gtk_combo_box_get_active (
 		state->validation.constraint_type);
 
-	if (type != VALIDATION_TYPE_ANY) {
+	if (type != GNM_VALIDATION_TYPE_ANY) {
 		ValidationStyle style = gtk_combo_box_get_active (state->validation.error.action);
 		ValidationOp    op    = gtk_combo_box_get_active (state->validation.op);
 		char *title = gtk_editable_get_chars (GTK_EDITABLE (state->validation.error.title), 0, -1);
@@ -1574,10 +1574,10 @@ validation_rebuild_validation (FormatState *state)
 		GnmExprTop const *texpr1 = NULL;
 
 		if (texpr0 != NULL) {
-			if (type == VALIDATION_TYPE_CUSTOM || type == VALIDATION_TYPE_IN_LIST) {
+			if (type == GNM_VALIDATION_TYPE_CUSTOM || type == GNM_VALIDATION_TYPE_IN_LIST) {
 				state->validation.valid = 1;
-				op = VALIDATION_OP_NONE;
-			} else if (op == VALIDATION_OP_BETWEEN || op == VALIDATION_OP_NOT_BETWEEN) {
+				op = GNM_VALIDATION_OP_NONE;
+			} else if (op == GNM_VALIDATION_OP_BETWEEN || op == GNM_VALIDATION_OP_NOT_BETWEEN) {
 				texpr1 = validation_entry_to_expr (state->sheet,
 								   state->validation.expr1.entry);
 				if (texpr1 != NULL)
@@ -1657,35 +1657,35 @@ cb_validation_sensitivity (G_GNUC_UNUSED GtkMenuShell *ignored,
 		state->validation.constraint_type);
 
 	switch (type) {
-	case VALIDATION_TYPE_IN_LIST:		msg0 = _("Source"); break;
-	case VALIDATION_TYPE_CUSTOM:		msg0 = _("Criteria"); break;
-
-	case VALIDATION_TYPE_AS_INT:
-	case VALIDATION_TYPE_AS_NUMBER:
-	case VALIDATION_TYPE_AS_DATE:
-	case VALIDATION_TYPE_AS_TIME:
-	case VALIDATION_TYPE_TEXT_LENGTH: {
+	case GNM_VALIDATION_TYPE_IN_LIST:		msg0 = _("Source"); break;
+	case GNM_VALIDATION_TYPE_CUSTOM:		msg0 = _("Criteria"); break;
+
+	case GNM_VALIDATION_TYPE_AS_INT:
+	case GNM_VALIDATION_TYPE_AS_NUMBER:
+	case GNM_VALIDATION_TYPE_AS_DATE:
+	case GNM_VALIDATION_TYPE_AS_TIME:
+	case GNM_VALIDATION_TYPE_TEXT_LENGTH: {
 		ValidationOp const op = gtk_combo_box_get_active (
 			state->validation.op);
 		has_operators = TRUE;
 		switch (op) {
-		case VALIDATION_OP_NONE:
+		case GNM_VALIDATION_OP_NONE:
 			break;
-		case VALIDATION_OP_BETWEEN:
-		case VALIDATION_OP_NOT_BETWEEN:
+		case GNM_VALIDATION_OP_BETWEEN:
+		case GNM_VALIDATION_OP_NOT_BETWEEN:
 			msg0 = _("Min:");
 			msg1 = _("Max:");
 			break;
-		case VALIDATION_OP_EQUAL:
-		case VALIDATION_OP_NOT_EQUAL:
+		case GNM_VALIDATION_OP_EQUAL:
+		case GNM_VALIDATION_OP_NOT_EQUAL:
 			msg0 = _("Value:");
 			break;
-		case VALIDATION_OP_GT:
-		case VALIDATION_OP_GTE:
+		case GNM_VALIDATION_OP_GT:
+		case GNM_VALIDATION_OP_GTE:
 			msg0 =_("Min:");
 			break;
-		case VALIDATION_OP_LT:
-		case VALIDATION_OP_LTE:
+		case GNM_VALIDATION_OP_LT:
+		case GNM_VALIDATION_OP_LTE:
 			msg0 = _("Max:");
 			break;
 		default:
@@ -1711,13 +1711,13 @@ cb_validation_sensitivity (G_GNUC_UNUSED GtkMenuShell *ignored,
 				  has_operators);
 
 	gtk_widget_set_sensitive (GTK_WIDGET (state->validation.error.action_label),
-				  type != VALIDATION_TYPE_ANY);
+				  type != GNM_VALIDATION_TYPE_ANY);
 	gtk_widget_set_sensitive (GTK_WIDGET (state->validation.error.action),
-				  type != VALIDATION_TYPE_ANY);
+				  type != GNM_VALIDATION_TYPE_ANY);
 	gtk_widget_set_sensitive (GTK_WIDGET (state->validation.allow_blank),
-				  type != VALIDATION_TYPE_ANY);
+				  type != GNM_VALIDATION_TYPE_ANY);
 	gtk_widget_set_sensitive (GTK_WIDGET (state->validation.use_dropdown),
-				  type == VALIDATION_TYPE_IN_LIST);
+				  type == GNM_VALIDATION_TYPE_IN_LIST);
 
 	validation_rebuild_validation (state);
 }
diff --git a/src/dialogs/dialog-scenarios.c b/src/dialogs/dialog-scenarios.c
index 4fab74a..c5dbff0 100644
--- a/src/dialogs/dialog-scenarios.c
+++ b/src/dialogs/dialog-scenarios.c
@@ -210,8 +210,8 @@ scenario_summary (WorkbookControl *wbc,
 	}
 
 	/* Set the alignment of names of the changing cells to be right. */
-	dao_set_align (&cb.dao, 0, 3, 0, 2 + cb.row, HALIGN_RIGHT,
-		       VALIGN_BOTTOM);
+	dao_set_align (&cb.dao, 0, 3, 0, 2 + cb.row, GNM_HALIGN_RIGHT,
+		       GNM_VALIGN_BOTTOM);
 
 	/* Result cells. */
 	if (results != NULL)
@@ -233,8 +233,8 @@ scenario_summary (WorkbookControl *wbc,
 			style_color_new_go (GO_COLOR_BLACK),
 			style_color_new_gdk (&gs_light_gray));
 
-	dao_set_align (&cb.dao, 1, 1, cb.col + 1, 1, HALIGN_RIGHT,
-		       VALIGN_BOTTOM);
+	dao_set_align (&cb.dao, 1, 1, cb.col + 1, 1, GNM_HALIGN_RIGHT,
+		       GNM_VALIGN_BOTTOM);
 
 	*new_sheet = cb.dao.sheet;
 }
diff --git a/src/item-edit.c b/src/item-edit.c
index dccaad4..787b228 100644
--- a/src/item-edit.c
+++ b/src/item-edit.c
@@ -81,11 +81,11 @@ get_top_left (ItemEdit const *ie, int *top, int *left, PangoDirection dir)
 
 	goc_canvas_c2w (canvas, l, item->y0, left, top);
 
-	if (align == VALIGN_CENTER || align == VALIGN_DISTRIBUTED ||
-	    align == VALIGN_BOTTOM) {
+	if (align == GNM_VALIGN_CENTER || align == GNM_VALIGN_DISTRIBUTED ||
+	    align == GNM_VALIGN_BOTTOM) {
 		int text_height, height = (int)(ie->item.y1 - ie->item.y0) * canvas->pixels_per_unit;
 		pango_layout_get_pixel_size (ie->layout, NULL, &text_height);
-		*top += (align != VALIGN_BOTTOM)
+		*top += (align != GNM_VALIGN_BOTTOM)
 			? (height - text_height)/2
 			: (height - text_height);
 	}
@@ -586,8 +586,8 @@ item_edit_realize (GocItem *item)
 		 gtk_widget_get_pango_context (GTK_WIDGET (pane)));
 	gnm_font_ref (ie->gfont);
 
-	if (gnm_style_get_align_h (ie->style) == HALIGN_GENERAL)
-		gnm_style_set_align_h (ie->style, HALIGN_LEFT);
+	if (gnm_style_get_align_h (ie->style) == GNM_HALIGN_GENERAL)
+		gnm_style_set_align_h (ie->style, GNM_HALIGN_LEFT);
 
 	/* move inwards 1 pixel from the grid line */
 	item->y0 = (1 + pane->first_offset.y +
diff --git a/src/mstyle.c b/src/mstyle.c
index 7497ac7..16085ca 100644
--- a/src/mstyle.c
+++ b/src/mstyle.c
@@ -546,8 +546,8 @@ gnm_style_new_default (void)
 	gnm_style_set_font_italic (new_style, gnm_conf_get_core_defaultfont_italic ());
 
 	gnm_style_set_format      (new_style, go_format_general ());
-	gnm_style_set_align_v     (new_style, VALIGN_BOTTOM);
-	gnm_style_set_align_h     (new_style, HALIGN_GENERAL);
+	gnm_style_set_align_v     (new_style, GNM_VALIGN_BOTTOM);
+	gnm_style_set_align_h     (new_style, GNM_HALIGN_GENERAL);
 	gnm_style_set_indent      (new_style, 0);
 	gnm_style_set_rotation    (new_style, 0);
 	gnm_style_set_text_dir    (new_style, GNM_TEXT_DIR_CONTEXT);
@@ -1356,8 +1356,8 @@ gnm_style_set_align_h (GnmStyle *style, GnmHAlign a)
 GnmHAlign
 gnm_style_get_align_h (GnmStyle const *style)
 {
-	g_return_val_if_fail (style != NULL, HALIGN_LEFT);
-	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_H), HALIGN_LEFT);
+	g_return_val_if_fail (style != NULL, GNM_HALIGN_LEFT);
+	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_H), GNM_HALIGN_LEFT);
 
 	return style->h_align;
 }
@@ -1375,8 +1375,8 @@ gnm_style_set_align_v (GnmStyle *style, GnmVAlign a)
 GnmVAlign
 gnm_style_get_align_v (GnmStyle const *style)
 {
-	g_return_val_if_fail (style != NULL, VALIGN_TOP);
-	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_V), VALIGN_TOP);
+	g_return_val_if_fail (style != NULL, GNM_VALIGN_TOP);
+	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_V), GNM_VALIGN_TOP);
 
 	return style->v_align;
 }
@@ -1468,11 +1468,11 @@ gnm_style_get_effective_wrap_text (GnmStyle const *style)
 	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_V), FALSE);
 	g_return_val_if_fail (elem_is_set (style, MSTYLE_ALIGN_H), FALSE);
 
-	/* Note: HALIGN_GENERAL never expands to HALIGN_JUSTIFY.  */
+	/* Note: GNM_HALIGN_GENERAL never expands to GNM_HALIGN_JUSTIFY.  */
 	return (style->wrap_text ||
-		style->v_align == VALIGN_JUSTIFY ||
-		style->v_align == VALIGN_DISTRIBUTED ||
-		style->h_align == HALIGN_JUSTIFY);
+		style->v_align == GNM_VALIGN_JUSTIFY ||
+		style->v_align == GNM_VALIGN_DISTRIBUTED ||
+		style->h_align == GNM_HALIGN_JUSTIFY);
 }
 
 void
diff --git a/src/rendered-value.c b/src/rendered-value.c
index b35b41d..973b35b 100644
--- a/src/rendered-value.c
+++ b/src/rendered-value.c
@@ -374,7 +374,7 @@ gnm_rendered_value_new (GnmCell const *cell,
 	res->effective_halign = gnm_style_default_halign (mstyle, cell);
 	res->indent_left = res->indent_right = 0;
 
-	if (res->effective_halign == HALIGN_FILL) {
+	if (res->effective_halign == GNM_HALIGN_FILL) {
 		pango_layout_set_single_paragraph_mode (layout, TRUE);
 		res->variable_width = TRUE;
 	}
@@ -454,7 +454,7 @@ gnm_rendered_value_new (GnmCell const *cell,
 			pango_layout_set_text (layout, "", -1);
 			pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
 			res->numeric_overflow = TRUE;
-			res->effective_halign = HALIGN_LEFT;
+			res->effective_halign = GNM_HALIGN_LEFT;
 			break;
 		default:
 			break;
@@ -465,38 +465,38 @@ gnm_rendered_value_new (GnmCell const *cell,
 
 	text = pango_layout_get_text (layout);
 	dir = (text && *text)? pango_find_base_dir (text, -1): PANGO_DIRECTION_LTR;
-	if (gnm_style_get_align_h (mstyle) == HALIGN_GENERAL && dir == PANGO_DIRECTION_RTL) {
+	if (gnm_style_get_align_h (mstyle) == GNM_HALIGN_GENERAL && dir == PANGO_DIRECTION_RTL) {
 		switch (res->effective_halign) {
-		case HALIGN_LEFT:
-			res->effective_halign = HALIGN_RIGHT;
+		case GNM_HALIGN_LEFT:
+			res->effective_halign = GNM_HALIGN_RIGHT;
 			break;
-		case HALIGN_RIGHT:
-			res->effective_halign = HALIGN_LEFT;
+		case GNM_HALIGN_RIGHT:
+			res->effective_halign = GNM_HALIGN_LEFT;
 			break;
 		}
 	}
 	switch (res->effective_halign) {
-	case HALIGN_LEFT:
+	case GNM_HALIGN_LEFT:
 		res->indent_left = calc_indent (context, mstyle);
 		pango_layout_set_alignment (layout, (dir == PANGO_DIRECTION_RTL)? PANGO_ALIGN_RIGHT: PANGO_ALIGN_LEFT);
 		break;
 
-	case HALIGN_JUSTIFY:
+	case GNM_HALIGN_JUSTIFY:
 		pango_layout_set_justify (layout, TRUE);
 		pango_layout_set_alignment (layout, PANGO_ALIGN_LEFT);
 		break;
 
-	case HALIGN_FILL:
+	case GNM_HALIGN_FILL:
 		break;
 
-	case HALIGN_RIGHT:
+	case GNM_HALIGN_RIGHT:
 		res->indent_right = calc_indent (context, mstyle);
 		pango_layout_set_alignment (layout, (dir == PANGO_DIRECTION_RTL)? PANGO_ALIGN_LEFT: PANGO_ALIGN_RIGHT);
 		break;
 
-	case HALIGN_DISTRIBUTED:
-	case HALIGN_CENTER:
-	case HALIGN_CENTER_ACROSS_SELECTION:
+	case GNM_HALIGN_DISTRIBUTED:
+	case GNM_HALIGN_CENTER:
+	case GNM_HALIGN_CENTER_ACROSS_SELECTION:
 		pango_layout_set_alignment (layout, PANGO_ALIGN_CENTER);
 		break;
 
diff --git a/src/style.c b/src/style.c
index 4f8cd9f..3466f72 100644
--- a/src/style.c
+++ b/src/style.c
@@ -329,16 +329,16 @@ gnm_align_h_get_type (void)
 	static GType etype = 0;
 	if (etype == 0) {
 		static GEnumValue const values[] = {
-			{HALIGN_GENERAL, "GNM_HALIGN_GENERAL", "general"},
-			{HALIGN_LEFT, "GNM_HALIGN_LEFT", "left"},
-			{HALIGN_RIGHT, "GNM_HALIGN_RIGHT", "right"},
-			{HALIGN_CENTER, "GNM_HALIGN_CENTER", "center"},
-			{HALIGN_FILL, "GNM_HALIGN_FILL", "fill"},
-			{HALIGN_JUSTIFY, "GNM_HALIGN_JUSTIFY", "justify"},
-			{HALIGN_CENTER_ACROSS_SELECTION, 
+			{GNM_HALIGN_GENERAL, "GNM_HALIGN_GENERAL", "general"},
+			{GNM_HALIGN_LEFT, "GNM_HALIGN_LEFT", "left"},
+			{GNM_HALIGN_RIGHT, "GNM_HALIGN_RIGHT", "right"},
+			{GNM_HALIGN_CENTER, "GNM_HALIGN_CENTER", "center"},
+			{GNM_HALIGN_FILL, "GNM_HALIGN_FILL", "fill"},
+			{GNM_HALIGN_JUSTIFY, "GNM_HALIGN_JUSTIFY", "justify"},
+			{GNM_HALIGN_CENTER_ACROSS_SELECTION, 
 			 "GNM_HALIGN_CENTER_ACROSS_SELECTION",
 			 "across-selection"},
-			{HALIGN_DISTRIBUTED,
+			{GNM_HALIGN_DISTRIBUTED,
 			 "GNM_HALIGN_DISTRIBUTED", "distributed"},
 			{ 0, NULL, NULL }
 		};
@@ -354,11 +354,11 @@ gnm_align_v_get_type (void)
 	static GType etype = 0;
 	if (etype == 0) {
 		static GEnumValue const values[] = {
-			{VALIGN_TOP, "GNM_VALIGN_TOP", "top"},
-			{VALIGN_BOTTOM, "GNM_VALIGN_BOTTOM", "bottom"},
-			{VALIGN_CENTER, "GNM_VALIGN_CENTER", "center"},
-			{VALIGN_JUSTIFY, "GNM_VALIGN_JUSTIFY", "justify"},
-			{VALIGN_DISTRIBUTED, 
+			{GNM_VALIGN_TOP, "GNM_VALIGN_TOP", "top"},
+			{GNM_VALIGN_BOTTOM, "GNM_VALIGN_BOTTOM", "bottom"},
+			{GNM_VALIGN_CENTER, "GNM_VALIGN_CENTER", "center"},
+			{GNM_VALIGN_JUSTIFY, "GNM_VALIGN_JUSTIFY", "justify"},
+			{GNM_VALIGN_DISTRIBUTED, 
 			 "GNM_VALIGN_DISTRIBUTED", "distributed"},
 			{ 0, NULL, NULL }
 		};
@@ -569,25 +569,25 @@ gnm_style_default_halign (GnmStyle const *mstyle, GnmCell const *c)
 	GnmHAlign align = gnm_style_get_align_h (mstyle);
 	GnmValue *v;
 
-	if (align != HALIGN_GENERAL)
+	if (align != GNM_HALIGN_GENERAL)
 		return align;
-	g_return_val_if_fail (c != NULL, HALIGN_RIGHT);
+	g_return_val_if_fail (c != NULL, GNM_HALIGN_RIGHT);
 
 	if (c->base.sheet && c->base.sheet->display_formulas &&
 	    gnm_cell_has_expr (c))
-		return HALIGN_LEFT;
+		return GNM_HALIGN_LEFT;
 
 	for (v = c->value; v != NULL ; )
 		switch (v->type) {
 		case VALUE_BOOLEAN:
 		case VALUE_ERROR:
-			return HALIGN_CENTER;
+			return GNM_HALIGN_CENTER;
 
 		case VALUE_FLOAT: {
 			double a = gnm_style_get_rotation (mstyle);
 			if (a > 0 && a < 180)
-				return HALIGN_LEFT;
-			return HALIGN_RIGHT;
+				return GNM_HALIGN_LEFT;
+			return GNM_HALIGN_RIGHT;
 		}
 
 		case VALUE_ARRAY:
@@ -599,10 +599,10 @@ gnm_style_default_halign (GnmStyle const *mstyle, GnmCell const *c)
 
 		default:
 			if (gnm_style_get_rotation (mstyle) > 180)
-				return HALIGN_RIGHT;
-			return HALIGN_LEFT;
+				return GNM_HALIGN_RIGHT;
+			return GNM_HALIGN_LEFT;
 		}
-	return HALIGN_RIGHT;
+	return GNM_HALIGN_RIGHT;
 }
 
 PangoUnderline
diff --git a/src/style.h b/src/style.h
index afdc54c..85a309b 100644
--- a/src/style.h
+++ b/src/style.h
@@ -14,22 +14,22 @@ G_BEGIN_DECLS
 /* Alignment definitions */
 /* Do not change these flags they are used as keys in the 1.0.x xml format.  */
 typedef enum {
-	HALIGN_GENERAL =  0x01,
-	HALIGN_LEFT    =  0x02,
-	HALIGN_RIGHT   =  0x04,
-	HALIGN_CENTER  =  0x08,
-	HALIGN_FILL    =  0x10,
-	HALIGN_JUSTIFY =  0x20,
-	HALIGN_CENTER_ACROSS_SELECTION =  0x40,
-	HALIGN_DISTRIBUTED = 0x80
+	GNM_HALIGN_GENERAL =  0x01,
+	GNM_HALIGN_LEFT    =  0x02,
+	GNM_HALIGN_RIGHT   =  0x04,
+	GNM_HALIGN_CENTER  =  0x08,
+	GNM_HALIGN_FILL    =  0x10,
+	GNM_HALIGN_JUSTIFY =  0x20,
+	GNM_HALIGN_CENTER_ACROSS_SELECTION =  0x40,
+	GNM_HALIGN_DISTRIBUTED = 0x80
 } GnmHAlign;
 
 typedef enum {
-	VALIGN_TOP     = 1,
-	VALIGN_BOTTOM  = 2,
-	VALIGN_CENTER  = 4,
-	VALIGN_JUSTIFY = 8,
-	VALIGN_DISTRIBUTED = 16
+	GNM_VALIGN_TOP     = 1,
+	GNM_VALIGN_BOTTOM  = 2,
+	GNM_VALIGN_CENTER  = 4,
+	GNM_VALIGN_JUSTIFY = 8,
+	GNM_VALIGN_DISTRIBUTED = 16
 } GnmVAlign;
 
 typedef enum {
diff --git a/src/tools/ChangeLog b/src/tools/ChangeLog
index c6abc47..adc1d9b 100644
--- a/src/tools/ChangeLog
+++ b/src/tools/ChangeLog
@@ -1,3 +1,10 @@
+2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
+
+	* src/tools/analysis-anova.c: rename enums
+	* src/tools/analysis-chi-squared.c: rename enums
+	* src/tools/analysis-principal-components.c: rename enums
+	* src/tools/analysis-tools.c: rename enums
+
 2011-09-01 Andreas J. Guelzow <aguelzow pyrshep ca>
 
 	* analysis-wilcoxon-mann-whitney.c: add argument to tools engine
diff --git a/src/tools/analysis-anova.c b/src/tools/analysis-anova.c
index e9bccde..6d288de 100644
--- a/src/tools/analysis-anova.c
+++ b/src/tools/analysis-anova.c
@@ -233,7 +233,7 @@ analysis_tool_anova_two_factor_no_rep_engine_run (data_analysis_output_t *dao,
 	dao_set_cell_expr (dao, 0, r, expr_check);
 	dao_set_format (dao, 0, r, 0, r,
 			_("\"ANOVA\";[Red]\"Invalid ANOVA: Missing Observations\""));
-	dao_set_align (dao, 0, r, 0, r, HALIGN_LEFT, VALIGN_BOTTOM);
+	dao_set_align (dao, 0, r, 0, r, GNM_HALIGN_LEFT, GNM_VALIGN_BOTTOM);
 
 	r++;
 	dao_set_italic (dao, 0, r, 0, r + 4);
@@ -591,7 +591,7 @@ analysis_tool_anova_two_factor_engine_run (data_analysis_output_t *dao,
 	dao_set_cell_expr (dao, 0, r, expr_check);
 	dao_set_format (dao, 0, r, 0, r,
 			_("\"ANOVA\";[Red]\"Invalid ANOVA: Missing Observations\""));
-	dao_set_align (dao, 0, r, 0, r, HALIGN_LEFT, VALIGN_BOTTOM);
+	dao_set_align (dao, 0, r, 0, r, GNM_HALIGN_LEFT, GNM_VALIGN_BOTTOM);
 
 	r++;
 	dao_set_italic (dao, 0, r, 0, r + 5);
diff --git a/src/tools/analysis-chi-squared.c b/src/tools/analysis-chi-squared.c
index da8d4c4..480767f 100644
--- a/src/tools/analysis-chi-squared.c
+++ b/src/tools/analysis-chi-squared.c
@@ -113,7 +113,7 @@ analysis_tool_chi_squared_engine_run (data_analysis_output_t *dao,
 	dao_set_italic (dao, 0, 0, 0, 0);
 	dao_set_cell_expr (dao, 0, 0, expr_check);
 	dao_set_format (dao, 0, 0, 0, 0, label);
-	dao_set_align (dao, 0, 0, 0, 0, HALIGN_CENTER, VALIGN_BOTTOM);
+	dao_set_align (dao, 0, 0, 0, 0, GNM_HALIGN_CENTER, GNM_VALIGN_BOTTOM);
 
 	expr_statistic = gnm_expr_new_funcall1 (fd_sum,
 						gnm_expr_new_binary
diff --git a/src/tools/analysis-principal-components.c b/src/tools/analysis-principal-components.c
index b25c071..0235cc3 100644
--- a/src/tools/analysis-principal-components.c
+++ b/src/tools/analysis-principal-components.c
@@ -108,7 +108,7 @@ analysis_tool_principal_components_engine_run (data_analysis_output_t *dao,
 			_("\"Principal Components Analysis\";"
 			  "[Red]\"Principal Components Analysis is invalid.\""));
 	dao_set_align (dao, 0, 0, 0, 0,
-		       HALIGN_LEFT, VALIGN_BOTTOM);
+		       GNM_HALIGN_LEFT, GNM_VALIGN_BOTTOM);
 
 	dao->offset_row++;
 	analysis_tool_table (dao, info, _("Covariances"), "COVAR", TRUE);
@@ -165,7 +165,7 @@ analysis_tool_principal_components_engine_run (data_analysis_output_t *dao,
 
 	for (i = 1; i <= l; i++) {
 		dao_set_align (dao, i, 9 + 2 * l, i, 9 + 2 * l,
-			       HALIGN_CENTER, VALIGN_BOTTOM);
+			       GNM_HALIGN_CENTER, GNM_VALIGN_BOTTOM);
 		dao_set_cell_printf (dao, i, 9 + 2 * l, "\xce\xbe%i", i);
 		dao_set_cell_expr (dao, i, 11 + 3 * l,
 				   gnm_expr_new_binary (make_cellref (0,- 4 - 2 * l),
diff --git a/src/tools/analysis-tools.c b/src/tools/analysis-tools.c
index 4232bef..b506c55 100644
--- a/src/tools/analysis-tools.c
+++ b/src/tools/analysis-tools.c
@@ -2975,8 +2975,8 @@ analysis_tool_regression_engine_run (data_analysis_output_t *dao,
 
 	dao_set_format  (dao, 5, 15, 5, 15, _("\"Lower\" 0%"));
 	dao_set_format  (dao, 6, 15, 6, 15, _("\"Upper\" 0%"));
-	dao_set_align (dao, 5, 15, 5, 15, HALIGN_LEFT, VALIGN_TOP);
-	dao_set_align (dao, 6, 15, 6, 15, HALIGN_RIGHT, VALIGN_TOP);
+	dao_set_align (dao, 5, 15, 5, 15, GNM_HALIGN_LEFT, GNM_VALIGN_TOP);
+	dao_set_align (dao, 6, 15, 6, 15, GNM_HALIGN_RIGHT, GNM_VALIGN_TOP);
 
 	dao_set_cell_float (dao, 5, 15, 1.0 - info->base.alpha);
 	dao_set_cell_expr (dao, 6, 15, make_cellref (-1, 0));
diff --git a/src/validation.c b/src/validation.c
index 719732d..321bf91 100644
--- a/src/validation.c
+++ b/src/validation.c
@@ -69,7 +69,7 @@ static struct {
 	int ntrue;
 	char const *name;
 } const opinfo[] = {
-	/* Note: no entry for VALIDATION_OP_NONE */
+	/* Note: no entry for GNM_VALIDATION_OP_NONE */
 	{ 2, { GNM_EXPR_OP_GTE,       GNM_EXPR_OP_LTE }, 2, N_("Between") },
 	{ 2, { GNM_EXPR_OP_LT,        GNM_EXPR_OP_GT  }, 1, N_("Not_Between") },
 	{ 1, { GNM_EXPR_OP_EQUAL,     NONE            }, 1, N_("Equal") },
@@ -147,15 +147,15 @@ gnm_validation_style_get_type (void)
 	static GType etype = 0;
 	if (etype == 0) {
 		static GEnumValue const values[] = {
-			{ VALIDATION_STYLE_NONE,
+			{ GNM_VALIDATION_STYLE_NONE,
 			  "GNM_VALIDATION_STYLE_NONE", "none"},
-			{ VALIDATION_STYLE_STOP,
+			{ GNM_VALIDATION_STYLE_STOP,
 			  "GNM_VALIDATION_STYLE_STOP", "stop"},
-			{ VALIDATION_STYLE_WARNING,
+			{ GNM_VALIDATION_STYLE_WARNING,
 			  "GNM_VALIDATION_STYLE_WARNING", "warning"},
-			{ VALIDATION_STYLE_INFO,
+			{ GNM_VALIDATION_STYLE_INFO,
 			  "GNM_VALIDATION_STYLE_INFO", "info"},
-			{ VALIDATION_STYLE_PARSE_ERROR,
+			{ GNM_VALIDATION_STYLE_PARSE_ERROR,
 			  "GNM_VALIDATION_STYLE_PARSE_ERROR", "parse-error"},
 			{ 0, NULL, NULL }
 		};
@@ -171,21 +171,21 @@ gnm_validation_type_get_type (void)
 	static GType etype = 0;
 	if (etype == 0) {
 		static GEnumValue const values[] = {
-			{ VALIDATION_TYPE_ANY,
+			{ GNM_VALIDATION_TYPE_ANY,
 			  "GNM_VALIDATION_TYPE_ANY", "any"},
-			{ VALIDATION_TYPE_AS_INT,
+			{ GNM_VALIDATION_TYPE_AS_INT,
 			  "GNM_VALIDATION_TYPE_AS_INT", "int"},
-			{ VALIDATION_TYPE_AS_NUMBER,
+			{ GNM_VALIDATION_TYPE_AS_NUMBER,
 			  "GNM_VALIDATION_TYPE_AS_NUMBER", "number"},
-			{ VALIDATION_TYPE_IN_LIST,
+			{ GNM_VALIDATION_TYPE_IN_LIST,
 			  "GNM_VALIDATION_TYPE_IN_LIST", "list"},
-			{ VALIDATION_TYPE_AS_DATE,
+			{ GNM_VALIDATION_TYPE_AS_DATE,
 			  "GNM_VALIDATION_TYPE_AS_DATE", "date"},
-			{ VALIDATION_TYPE_AS_TIME,
+			{ GNM_VALIDATION_TYPE_AS_TIME,
 			  "GNM_VALIDATION_TYPE_AS_TIME", "time"},
-			{ VALIDATION_TYPE_TEXT_LENGTH,
+			{ GNM_VALIDATION_TYPE_TEXT_LENGTH,
 			  "GNM_VALIDATION_TYPE_TEXT_LENGTH", "length"},
-			{ VALIDATION_TYPE_CUSTOM,
+			{ GNM_VALIDATION_TYPE_CUSTOM,
 			  "GNM_VALIDATION_TYPE_CUSTOM", "custom"},
 			{ 0, NULL, NULL }
 		};
@@ -201,23 +201,23 @@ gnm_validation_op_get_type (void)
 	static GType etype = 0;
 	if (etype == 0) {
 		static GEnumValue const values[] = {
-			{ VALIDATION_OP_NONE,
+			{ GNM_VALIDATION_OP_NONE,
 			  "GNM_VALIDATION_OP_NONE", "none"},
-			{ VALIDATION_OP_BETWEEN,
+			{ GNM_VALIDATION_OP_BETWEEN,
 			  "GNM_VALIDATION_OP_BETWEEN", "between"},
-			{ VALIDATION_OP_NOT_BETWEEN,
+			{ GNM_VALIDATION_OP_NOT_BETWEEN,
 			  "GNM_VALIDATION_OP_NOT_BETWEEN", "not-between"},
-			{ VALIDATION_OP_EQUAL,
+			{ GNM_VALIDATION_OP_EQUAL,
 			  "GNM_VALIDATION_OP_EQUAL", "equal"},
-			{ VALIDATION_OP_NOT_EQUAL,
+			{ GNM_VALIDATION_OP_NOT_EQUAL,
 			  "GNM_VALIDATION_OP_NOT_EQUAL", "not-equal"},
-			{ VALIDATION_OP_GT,
+			{ GNM_VALIDATION_OP_GT,
 			  "GNM_VALIDATION_OP_GT", "gt"},
-			{ VALIDATION_OP_LT,
+			{ GNM_VALIDATION_OP_LT,
 			  "GNM_VALIDATION_OP_LT", "lt"},
-			{ VALIDATION_OP_GTE,
+			{ GNM_VALIDATION_OP_GTE,
 			  "GNM_VALIDATION_OP_GTE", "gte"},
-			{ VALIDATION_OP_LTE,
+			{ GNM_VALIDATION_OP_LTE,
 			  "GNM_VALIDATION_OP_LTE", "lte"},
 			{ 0, NULL, NULL }
 		};
@@ -256,26 +256,26 @@ validation_new (ValidationStyle style,
 
 	g_return_val_if_fail (type >= 0, NULL);
 	g_return_val_if_fail (type < G_N_ELEMENTS (typeinfo), NULL);
-	g_return_val_if_fail (op >= VALIDATION_OP_NONE, NULL);
+	g_return_val_if_fail (op >= GNM_VALIDATION_OP_NONE, NULL);
 	g_return_val_if_fail (op < (int)G_N_ELEMENTS (opinfo), NULL);
 
 	switch (type) {
-	case VALIDATION_TYPE_CUSTOM:
-	case VALIDATION_TYPE_IN_LIST:
+	case GNM_VALIDATION_TYPE_CUSTOM:
+	case GNM_VALIDATION_TYPE_IN_LIST:
 		nops = 1;
-		if (op != VALIDATION_OP_NONE) {
+		if (op != GNM_VALIDATION_OP_NONE) {
 			/*
 			 * This can happen if an .xls file was saved
 			 * as a .gnumeric.
 			 */
-			op = VALIDATION_OP_NONE;
+			op = GNM_VALIDATION_OP_NONE;
 		}
 		break;
-	case VALIDATION_TYPE_ANY:
+	case GNM_VALIDATION_TYPE_ANY:
 		nops = 0;
 		break;
 	default:
-		nops = (op == VALIDATION_OP_NONE) ? 0 : opinfo[op].nops;
+		nops = (op == GNM_VALIDATION_OP_NONE) ? 0 : opinfo[op].nops;
 	}
 
 	v = g_new0 (GnmValidation, 1);
@@ -364,10 +364,10 @@ validation_is_ok (GnmValidation const *v)
 	unsigned nops, i;
 
 	switch (v->type) {
-	case VALIDATION_TYPE_CUSTOM:
-	case VALIDATION_TYPE_IN_LIST:	nops = 1; break;
-	case VALIDATION_TYPE_ANY:	nops = 0; break;
-	default: nops = (v->op == VALIDATION_OP_NONE) ? 0 : opinfo[v->op].nops;
+	case GNM_VALIDATION_TYPE_CUSTOM:
+	case GNM_VALIDATION_TYPE_IN_LIST:	nops = 1; break;
+	case GNM_VALIDATION_TYPE_ANY:	nops = 0; break;
+	default: nops = (v->op == GNM_VALIDATION_OP_NONE) ? 0 : opinfo[v->op].nops;
 	}
 
 	for (i = 0 ; i < 2 ; i++)
@@ -390,9 +390,9 @@ validation_barf (WorkbookControl *wbc, GnmValidation const *gv,
 	char const *title = gv->title ? gv->title->str : _("Gnumeric: Validation");
 	ValidationStatus result;
 
-	if (gv->style == VALIDATION_STYLE_NONE) {
+	if (gv->style == GNM_VALIDATION_STYLE_NONE) {
 		/* Invalid, but we're asked to ignore.  */
-		result = VALIDATION_STATUS_VALID;
+		result = GNM_VALIDATION_STATUS_VALID;
 	} else {
 		if (showed_dialog) *showed_dialog = TRUE;
 		result = wb_control_validation_msg (wbc, gv->style, title, msg);
@@ -438,10 +438,10 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 
 	v = gnm_style_get_validation (mstyle);
 	if (v == NULL)
-		return VALIDATION_STATUS_VALID;
+		return GNM_VALIDATION_STATUS_VALID;
 
-	if (v->type == VALIDATION_TYPE_ANY)
-		return VALIDATION_STATUS_VALID;
+	if (v->type == GNM_VALIDATION_TYPE_ANY)
+		return GNM_VALIDATION_STATUS_VALID;
 
 	cell = sheet_cell_get (sheet, pos->col, pos->row);
 	if (cell != NULL)
@@ -449,7 +449,7 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 
 	if (gnm_cell_is_empty (cell)) {
 		if (v->allow_blank)
-			return VALIDATION_STATUS_VALID;
+			return GNM_VALIDATION_STATUS_VALID;
 		BARF (g_strdup_printf (_("Cell %s is not permitted to be blank"),
 				       cell_name (cell)));
 	}
@@ -464,7 +464,7 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 
 	case VALUE_BOOLEAN:
 		if (typeinfo[v->type].bool_always_ok)
-			return VALIDATION_STATUS_VALID;
+			return GNM_VALIDATION_STATUS_VALID;
 		break;
 
 	case VALUE_STRING:
@@ -480,7 +480,7 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 	eval_pos_init_cell (&ep, cell);
 
 	switch (v->type) {
-	case VALIDATION_TYPE_AS_INT:
+	case GNM_VALIDATION_TYPE_AS_INT:
 		x = value_get_as_float (val);
 		if (gnm_fake_floor (x) == gnm_fake_ceil (x))
 			break;
@@ -488,11 +488,11 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 			BARF (g_strdup_printf (_("'%s' is not an integer"),
 					       value_peek_string (val)));
 
-	case VALIDATION_TYPE_AS_NUMBER:
+	case GNM_VALIDATION_TYPE_AS_NUMBER:
 		x = value_get_as_float (val);
 		break;
 
-	case VALIDATION_TYPE_AS_DATE: /* What the hell does this do?  */
+	case GNM_VALIDATION_TYPE_AS_DATE: /* What the hell does this do?  */
 		x = value_get_as_float (val);
 		if (x < 0)
 			BARF (g_strdup_printf (_("'%s' is not a valid date"),
@@ -500,11 +500,11 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 		break;
 
 
-	case VALIDATION_TYPE_AS_TIME: /* What the hell does this do?  */
+	case GNM_VALIDATION_TYPE_AS_TIME: /* What the hell does this do?  */
 		x = value_get_as_float (val);
 		break;
 
-	case VALIDATION_TYPE_IN_LIST:
+	case GNM_VALIDATION_TYPE_IN_LIST:
 		if (NULL != v->texpr[0]) {
 			GnmValue *list = gnm_expr_top_eval (v->texpr[0], &ep,
 				 GNM_EXPR_EVAL_PERMIT_NON_SCALAR | GNM_EXPR_EVAL_PERMIT_EMPTY);
@@ -522,9 +522,9 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 				BARF (msg);
 			}
 		}
-		return VALIDATION_STATUS_VALID;
+		return GNM_VALIDATION_STATUS_VALID;
 
-	case VALIDATION_TYPE_TEXT_LENGTH:
+	case GNM_VALIDATION_TYPE_TEXT_LENGTH:
 		/* XL appears to use a very basic value->string mapping that
 		 * ignores formatting.
 		 * eg len (12/13/01) == len (37238) = 5
@@ -533,18 +533,18 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 		x = g_utf8_strlen (value_peek_string (val), -1);
 		break;
 
-	case VALIDATION_TYPE_CUSTOM: {
+	case GNM_VALIDATION_TYPE_CUSTOM: {
 		gboolean valid;
 
 		if (v->texpr[0] == NULL)
-			return VALIDATION_STATUS_VALID;
+			return GNM_VALIDATION_STATUS_VALID;
 
 		val = gnm_expr_top_eval (v->texpr[0], &ep, GNM_EXPR_EVAL_SCALAR_NON_EMPTY);
 		valid = value_get_as_bool (val, NULL);
 		value_release (val);
 
 		if (valid)
-			return VALIDATION_STATUS_VALID;
+			return GNM_VALIDATION_STATUS_VALID;
 		else {
 			GnmParsePos pp;
 			char *expr_str = gnm_expr_top_as_string
@@ -559,11 +559,11 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 
 	default:
 		g_assert_not_reached ();
-		return VALIDATION_STATUS_VALID;
+		return GNM_VALIDATION_STATUS_VALID;
 	}
 
-	if (v->op == VALIDATION_OP_NONE)
-		return VALIDATION_STATUS_VALID;
+	if (v->op == GNM_VALIDATION_OP_NONE)
+		return GNM_VALIDATION_STATUS_VALID;
 
 	nok = 0;
 	for (i = 0; i < opinfo[v->op].nops; i++) {
@@ -593,7 +593,7 @@ validation_eval (WorkbookControl *wbc, GnmStyle const *mstyle,
 		BARF (g_strdup_printf (_("%s is out of permitted range"),
 				       value_peek_string (val)));
 
-	return VALIDATION_STATUS_VALID;
+	return GNM_VALIDATION_STATUS_VALID;
 }
 
 #undef BARF
@@ -621,7 +621,7 @@ validation_eval_range_cb (GnmCellIter const *iter, validation_eval_t *closure)
 		if (closure->showed_dialog)
 			*closure->showed_dialog = *closure->showed_dialog || showed_dialog;
 
-		if (status != VALIDATION_STATUS_VALID) {
+		if (status != GNM_VALIDATION_STATUS_VALID) {
 			closure->status = status;
 			return VALUE_TERMINATE;
 		}
@@ -644,7 +644,7 @@ validation_eval_range (WorkbookControl *wbc,
 	closure.sheet = sheet;
 	closure.pos = pos;
 	closure.showed_dialog = showed_dialog;
-	closure.status = VALIDATION_STATUS_VALID;
+	closure.status = GNM_VALIDATION_STATUS_VALID;
 
 	eval_pos_init_pos (&ep, sheet, pos);
 
@@ -655,6 +655,6 @@ validation_eval_range (WorkbookControl *wbc,
 	value_release (cell_range);
 
 	if (result == NULL)
-		return VALIDATION_STATUS_VALID;
+		return GNM_VALIDATION_STATUS_VALID;
 	return closure.status;
 }
diff --git a/src/validation.h b/src/validation.h
index 419d8b2..b8adb64 100644
--- a/src/validation.h
+++ b/src/validation.h
@@ -7,37 +7,37 @@
 G_BEGIN_DECLS
 
 typedef enum {
-	VALIDATION_STATUS_VALID,		/* things validate */
-	VALIDATION_STATUS_INVALID_DISCARD,	/* things do not validate and should be discarded */
-	VALIDATION_STATUS_INVALID_EDIT		/* things do not validate and editing should continue */
+	GNM_VALIDATION_STATUS_VALID,		/* things validate */
+	GNM_VALIDATION_STATUS_INVALID_DISCARD,	/* things do not validate and should be discarded */
+	GNM_VALIDATION_STATUS_INVALID_EDIT		/* things do not validate and editing should continue */
 } ValidationStatus;
 typedef enum {
-	VALIDATION_STYLE_NONE,
-	VALIDATION_STYLE_STOP,
-	VALIDATION_STYLE_WARNING,
-	VALIDATION_STYLE_INFO,
-	VALIDATION_STYLE_PARSE_ERROR
+	GNM_VALIDATION_STYLE_NONE,
+	GNM_VALIDATION_STYLE_STOP,
+	GNM_VALIDATION_STYLE_WARNING,
+	GNM_VALIDATION_STYLE_INFO,
+	GNM_VALIDATION_STYLE_PARSE_ERROR
 } ValidationStyle;
 typedef enum {
-	VALIDATION_TYPE_ANY,
-	VALIDATION_TYPE_AS_INT,
-	VALIDATION_TYPE_AS_NUMBER,
-	VALIDATION_TYPE_IN_LIST,
-	VALIDATION_TYPE_AS_DATE,
-	VALIDATION_TYPE_AS_TIME,
-	VALIDATION_TYPE_TEXT_LENGTH,
-	VALIDATION_TYPE_CUSTOM
+	GNM_VALIDATION_TYPE_ANY,
+	GNM_VALIDATION_TYPE_AS_INT,
+	GNM_VALIDATION_TYPE_AS_NUMBER,
+	GNM_VALIDATION_TYPE_IN_LIST,
+	GNM_VALIDATION_TYPE_AS_DATE,
+	GNM_VALIDATION_TYPE_AS_TIME,
+	GNM_VALIDATION_TYPE_TEXT_LENGTH,
+	GNM_VALIDATION_TYPE_CUSTOM
 } ValidationType;
 typedef enum {
-	VALIDATION_OP_NONE = -1,
-	VALIDATION_OP_BETWEEN,
-	VALIDATION_OP_NOT_BETWEEN,
-	VALIDATION_OP_EQUAL,
-	VALIDATION_OP_NOT_EQUAL,
-	VALIDATION_OP_GT,
-	VALIDATION_OP_LT,
-	VALIDATION_OP_GTE,
-	VALIDATION_OP_LTE
+	GNM_VALIDATION_OP_NONE = -1,
+	GNM_VALIDATION_OP_BETWEEN,
+	GNM_VALIDATION_OP_NOT_BETWEEN,
+	GNM_VALIDATION_OP_EQUAL,
+	GNM_VALIDATION_OP_NOT_EQUAL,
+	GNM_VALIDATION_OP_GT,
+	GNM_VALIDATION_OP_LT,
+	GNM_VALIDATION_OP_GTE,
+	GNM_VALIDATION_OP_LTE
 } ValidationOp;
 
 struct _GnmValidation {
diff --git a/src/wbc-gtk-actions.c b/src/wbc-gtk-actions.c
index 1b5e5b9..686d1d9 100644
--- a/src/wbc-gtk-actions.c
+++ b/src/wbc-gtk-actions.c
@@ -1504,20 +1504,20 @@ wbcg_set_selection_halign (WBCGtk *wbcg, GnmHAlign halign)
 	 * then revert to general */
 	wb_view = wb_control_view (wbc);
 	if (gnm_style_get_align_h (wb_view->current_style) == halign)
-		halign = HALIGN_GENERAL;
+		halign = GNM_HALIGN_GENERAL;
 
 	style = gnm_style_new ();
 	gnm_style_set_align_h (style, halign);
 	cmd_selection_format (wbc, style, NULL, _("Set Horizontal Alignment"));
 }
 static GNM_ACTION_DEF (cb_align_left)
-	{ wbcg_set_selection_halign (wbcg, HALIGN_LEFT); }
+	{ wbcg_set_selection_halign (wbcg, GNM_HALIGN_LEFT); }
 static GNM_ACTION_DEF (cb_align_right)
-	{ wbcg_set_selection_halign (wbcg, HALIGN_RIGHT); }
+	{ wbcg_set_selection_halign (wbcg, GNM_HALIGN_RIGHT); }
 static GNM_ACTION_DEF (cb_align_center)
-	{ wbcg_set_selection_halign (wbcg, HALIGN_CENTER); }
+	{ wbcg_set_selection_halign (wbcg, GNM_HALIGN_CENTER); }
 static GNM_ACTION_DEF (cb_center_across_selection)
-	{ wbcg_set_selection_halign (wbcg, HALIGN_CENTER_ACROSS_SELECTION); }
+	{ wbcg_set_selection_halign (wbcg, GNM_HALIGN_CENTER_ACROSS_SELECTION); }
 
 /*****************************************************************************/
 
@@ -1535,9 +1535,9 @@ wbcg_set_selection_valign (WBCGtk *wbcg, GnmVAlign valign)
 	 * then revert to general */
 	wb_view = wb_control_view (wbc);
 	if (gnm_style_get_align_v (wb_view->current_style) == valign) {
-		if (valign == VALIGN_BOTTOM)
+		if (valign == GNM_VALIGN_BOTTOM)
 			return;
-		valign = VALIGN_BOTTOM;
+		valign = GNM_VALIGN_BOTTOM;
 	}
 
 	style = gnm_style_new ();
@@ -1545,11 +1545,11 @@ wbcg_set_selection_valign (WBCGtk *wbcg, GnmVAlign valign)
 	cmd_selection_format (wbc, style, NULL, _("Set Vertical Alignment"));
 }
 static GNM_ACTION_DEF (cb_align_top)
-	{ wbcg_set_selection_valign (wbcg, VALIGN_TOP); }
+	{ wbcg_set_selection_valign (wbcg, GNM_VALIGN_TOP); }
 static GNM_ACTION_DEF (cb_align_vcenter)
-	{ wbcg_set_selection_valign (wbcg, VALIGN_CENTER); }
+	{ wbcg_set_selection_valign (wbcg, GNM_VALIGN_CENTER); }
 static GNM_ACTION_DEF (cb_align_bottom)
-	{ wbcg_set_selection_valign (wbcg, VALIGN_BOTTOM); }
+	{ wbcg_set_selection_valign (wbcg, GNM_VALIGN_BOTTOM); }
 
 /*****************************************************************************/
 
@@ -2944,21 +2944,21 @@ static GtkToggleActionEntry const font_toggle_actions[] = {
 /****************************************************************************/
 
 static GOActionComboPixmapsElement const halignment_combo_info[] = {
-	{ N_("Align left"),		GTK_STOCK_JUSTIFY_LEFT,		HALIGN_LEFT },
-	{ N_("Center horizontally"),	GTK_STOCK_JUSTIFY_CENTER,	HALIGN_CENTER },
-	{ N_("Align right"),		GTK_STOCK_JUSTIFY_RIGHT,	HALIGN_RIGHT },
-	{ N_("Fill Horizontally"),	"Gnumeric_HAlignFill",		HALIGN_FILL },
-	{ N_("Justify Horizontally"),	GTK_STOCK_JUSTIFY_FILL,		HALIGN_JUSTIFY },
+	{ N_("Align left"),		GTK_STOCK_JUSTIFY_LEFT,		GNM_HALIGN_LEFT },
+	{ N_("Center horizontally"),	GTK_STOCK_JUSTIFY_CENTER,	GNM_HALIGN_CENTER },
+	{ N_("Align right"),		GTK_STOCK_JUSTIFY_RIGHT,	GNM_HALIGN_RIGHT },
+	{ N_("Fill Horizontally"),	"Gnumeric_HAlignFill",		GNM_HALIGN_FILL },
+	{ N_("Justify Horizontally"),	GTK_STOCK_JUSTIFY_FILL,		GNM_HALIGN_JUSTIFY },
 	{ N_("Center horizontally across the selection"),
-					"Gnumeric_CenterAcrossSelection", HALIGN_CENTER_ACROSS_SELECTION },
+					"Gnumeric_CenterAcrossSelection", GNM_HALIGN_CENTER_ACROSS_SELECTION },
 	{ N_("Align numbers right, and text left"),
-					"Gnumeric_HAlignGeneral",	HALIGN_GENERAL },
+					"Gnumeric_HAlignGeneral",	GNM_HALIGN_GENERAL },
 	{ NULL, NULL }
 };
 static GOActionComboPixmapsElement const valignment_combo_info[] = {
-	{ N_("Align Top"),		"stock_alignment-top",			VALIGN_TOP },
-	{ N_("Center Vertically"),	"stock_alignment-centered-vertically",	VALIGN_CENTER },
-	{ N_("Align Bottom"),		"stock_alignment-bottom",		VALIGN_BOTTOM },
+	{ N_("Align Top"),		"stock_alignment-top",			GNM_VALIGN_TOP },
+	{ N_("Center Vertically"),	"stock_alignment-centered-vertically",	GNM_VALIGN_CENTER },
+	{ N_("Align Bottom"),		"stock_alignment-bottom",		GNM_VALIGN_BOTTOM },
 	{ NULL, NULL}
 };
 
diff --git a/src/wbc-gtk-edit.c b/src/wbc-gtk-edit.c
index 1a04aac..6e47b40 100644
--- a/src/wbc-gtk-edit.c
+++ b/src/wbc-gtk-edit.c
@@ -135,7 +135,7 @@ wbcg_edit_finish (WBCGtk *wbcg, WBCEditResult result,
 
 	/* Save the results before changing focus */
 	if (result != WBC_EDIT_REJECT) {
-		ValidationStatus valid = VALIDATION_STATUS_VALID;
+		ValidationStatus valid = GNM_VALIDATION_STATUS_VALID;
 		char *free_txt = NULL;
 		char const *txt;
 		GnmStyle const *mstyle;
@@ -279,13 +279,13 @@ wbcg_edit_finish (WBCGtk *wbcg, WBCEditResult result,
 								   GTK_EDITABLE (wbcg_get_entry (wbcg)), -1);
 
 				reedit = wb_control_validation_msg (WORKBOOK_CONTROL (wbcg),
-								    VALIDATION_STYLE_PARSE_ERROR, NULL,
+								    GNM_VALIDATION_STYLE_PARSE_ERROR, NULL,
 								    perr.err->message);
 				if (showed_dialog != NULL)
 					*showed_dialog = TRUE;
 
 				parse_error_free (&perr);
-				if (reedit == VALIDATION_STATUS_INVALID_EDIT) {
+				if (reedit == GNM_VALIDATION_STATUS_INVALID_EDIT) {
 					range_fragment_free (selection);
 					return FALSE;
 				}
@@ -340,7 +340,7 @@ wbcg_edit_finish (WBCGtk *wbcg, WBCEditResult result,
 				sheet_range_set_text (&pp, r, txt);
 				valid =	validation_eval_range (wbc, sheet, &sv->edit_pos, r,
 							       showed_dialog);
-				if (valid != VALIDATION_STATUS_VALID)
+				if (valid != GNM_VALIDATION_STATUS_VALID)
 					break;
 			}
 			break;
@@ -391,9 +391,9 @@ wbcg_edit_finish (WBCGtk *wbcg, WBCEditResult result,
 
 		/* Now we can respond to our validation information */
 
-		if (valid != VALIDATION_STATUS_VALID) {
+		if (valid != GNM_VALIDATION_STATUS_VALID) {
 			result = WBC_EDIT_REJECT;
-			if (valid == VALIDATION_STATUS_INVALID_EDIT) {
+			if (valid == GNM_VALIDATION_STATUS_INVALID_EDIT) {
 				gtk_window_set_focus (wbcg_toplevel (wbcg),
 					(GtkWidget *) wbcg_get_entry (wbcg));
 				g_free (free_txt);
diff --git a/src/wbc-gtk.c b/src/wbc-gtk.c
index f452892..207cf48 100644
--- a/src/wbc-gtk.c
+++ b/src/wbc-gtk.c
@@ -2735,31 +2735,31 @@ wbcg_validation_msg (WorkbookControl *wbc, ValidationStyle v,
 		     char const *title, char const *msg)
 {
 	WBCGtk *wbcg = (WBCGtk *)wbc;
-	ValidationStatus res0, res1 = VALIDATION_STATUS_VALID; /* supress warning */
+	ValidationStatus res0, res1 = GNM_VALIDATION_STATUS_VALID; /* supress warning */
 	char const *btn0, *btn1;
 	GtkMessageType  type;
 	GtkWidget  *dialog;
 	int response;
 
 	switch (v) {
-	case VALIDATION_STYLE_STOP :
-		res0 = VALIDATION_STATUS_INVALID_EDIT;		btn0 = _("_Re-Edit");
-		res1 = VALIDATION_STATUS_INVALID_DISCARD;	btn1 = _("_Discard");
+	case GNM_VALIDATION_STYLE_STOP :
+		res0 = GNM_VALIDATION_STATUS_INVALID_EDIT;		btn0 = _("_Re-Edit");
+		res1 = GNM_VALIDATION_STATUS_INVALID_DISCARD;	btn1 = _("_Discard");
 		type = GTK_MESSAGE_ERROR;
 		break;
-	case VALIDATION_STYLE_WARNING :
-		res0 = VALIDATION_STATUS_VALID;			btn0 = _("_Accept");
-		res1 = VALIDATION_STATUS_INVALID_DISCARD;	btn1 = _("_Discard");
+	case GNM_VALIDATION_STYLE_WARNING :
+		res0 = GNM_VALIDATION_STATUS_VALID;			btn0 = _("_Accept");
+		res1 = GNM_VALIDATION_STATUS_INVALID_DISCARD;	btn1 = _("_Discard");
 		type = GTK_MESSAGE_WARNING;
 		break;
-	case VALIDATION_STYLE_INFO :
-		res0 = VALIDATION_STATUS_VALID;			btn0 = GTK_STOCK_OK;
+	case GNM_VALIDATION_STYLE_INFO :
+		res0 = GNM_VALIDATION_STATUS_VALID;			btn0 = GTK_STOCK_OK;
 		btn1 = NULL;
 		type = GTK_MESSAGE_INFO;
 		break;
-	case VALIDATION_STYLE_PARSE_ERROR:
-		res0 = VALIDATION_STATUS_INVALID_EDIT;		btn0 = _("_Re-Edit");
-		res1 = VALIDATION_STATUS_VALID;			btn1 = _("_Accept");
+	case GNM_VALIDATION_STYLE_PARSE_ERROR:
+		res0 = GNM_VALIDATION_STATUS_INVALID_EDIT;		btn0 = _("_Re-Edit");
+		res1 = GNM_VALIDATION_STATUS_VALID;			btn1 = _("_Accept");
 		type = GTK_MESSAGE_ERROR;
 		break;
 
@@ -3509,23 +3509,23 @@ wbc_gtk_style_feedback_real (WorkbookControl *wbc, GnmStyle const *changes)
 	if (gnm_style_is_element_set (changes, MSTYLE_ALIGN_H)) {
 		GnmHAlign align = gnm_style_get_align_h (changes);
 		gtk_toggle_action_set_active (wbcg->h_align.left,
-			align == HALIGN_LEFT);
+			align == GNM_HALIGN_LEFT);
 		gtk_toggle_action_set_active (wbcg->h_align.center,
-			align == HALIGN_CENTER);
+			align == GNM_HALIGN_CENTER);
 		gtk_toggle_action_set_active (wbcg->h_align.right,
-			align == HALIGN_RIGHT);
+			align == GNM_HALIGN_RIGHT);
 		gtk_toggle_action_set_active (wbcg->h_align.center_across_selection,
-			align == HALIGN_CENTER_ACROSS_SELECTION);
+			align == GNM_HALIGN_CENTER_ACROSS_SELECTION);
 		go_action_combo_pixmaps_select_id (wbcg->halignment, align);
 	}
 	if (gnm_style_is_element_set (changes, MSTYLE_ALIGN_V)) {
 		GnmVAlign align = gnm_style_get_align_v (changes);
 		gtk_toggle_action_set_active (wbcg->v_align.top,
-			align == VALIGN_TOP);
+			align == GNM_VALIGN_TOP);
 		gtk_toggle_action_set_active (wbcg->v_align.bottom,
-			align == VALIGN_BOTTOM);
+			align == GNM_VALIGN_BOTTOM);
 		gtk_toggle_action_set_active (wbcg->v_align.center,
-			align == VALIGN_CENTER);
+			align == GNM_VALIGN_CENTER);
 		go_action_combo_pixmaps_select_id (wbcg->valignment, align);
 	}
 
@@ -5317,7 +5317,7 @@ cb_graph_dim_editor_update (GnmExprEntry *gee,
 				g_return_if_fail (perr.err != NULL);
 
 				wb_control_validation_msg (WORKBOOK_CONTROL (scg_wbcg (scg)),
-					VALIDATION_STYLE_INFO, NULL, perr.err->message);
+					GNM_VALIDATION_STYLE_INFO, NULL, perr.err->message);
 				parse_error_free (&perr);
 				gtk_editable_select_region (GTK_EDITABLE (gnm_expr_entry_get_entry (editor->entry)), 0, G_MAXINT);
 				editor->changed = TRUE;
diff --git a/src/widgets/ChangeLog b/src/widgets/ChangeLog
index 7a22772..17cb392 100644
--- a/src/widgets/ChangeLog
+++ b/src/widgets/ChangeLog
@@ -1,3 +1,8 @@
+2011-11-22  Andreas J. Guelzow <aguelzow pyrshep ca>
+
+	* src/widgets/gnm-validation-combo-view.c: rename enums
+	* src/widgets/widget-font-selector.c: rename enums
+
 2011-10-26  Andreas J. Guelzow <aguelzow pyrshep ca>
 
 	* gnm-format-sel.c (cb_generate_preview): call go_pango_translate_layout
diff --git a/src/widgets/gnm-validation-combo-view.c b/src/widgets/gnm-validation-combo-view.c
index 90bccbf..bcb1aed 100644
--- a/src/widgets/gnm-validation-combo-view.c
+++ b/src/widgets/gnm-validation-combo-view.c
@@ -106,7 +106,7 @@ vcombo_create_list (SheetObject *so,
 	SheetView const *sv = vcombo->parent.sv;
 
 	g_return_val_if_fail (val != NULL, NULL);
-	g_return_val_if_fail (val->type == VALIDATION_TYPE_IN_LIST, NULL);
+	g_return_val_if_fail (val->type == GNM_VALIDATION_TYPE_IN_LIST, NULL);
 	g_return_val_if_fail (val->texpr[0] != NULL, NULL);
 	g_return_val_if_fail (sv != NULL, NULL);
 
diff --git a/src/widgets/widget-font-selector.c b/src/widgets/widget-font-selector.c
index 9befafd..803b6e4 100644
--- a/src/widgets/widget-font-selector.c
+++ b/src/widgets/widget-font-selector.c
@@ -376,8 +376,8 @@ fs_init (FontSelector *fs)
                 return;
 
 	fs->mstyle = gnm_style_new_default ();
-	gnm_style_set_align_v   (fs->mstyle, VALIGN_CENTER);
-	gnm_style_set_align_h   (fs->mstyle, HALIGN_CENTER);
+	gnm_style_set_align_v   (fs->mstyle, GNM_VALIGN_CENTER);
+	gnm_style_set_align_h   (fs->mstyle, GNM_HALIGN_CENTER);
 	gnm_style_set_font_size (fs->mstyle, 10);
 
 	gtk_box_pack_start (GTK_BOX (fs),
diff --git a/src/workbook-cmd-format.c b/src/workbook-cmd-format.c
index 767f798..528f815 100644
--- a/src/workbook-cmd-format.c
+++ b/src/workbook-cmd-format.c
@@ -91,8 +91,8 @@ workbook_cmd_inc_indent (WorkbookControl *wbc)
 	if (i < 20) {
 		GnmStyle *style = gnm_style_new ();
 
-		if (HALIGN_LEFT != gnm_style_get_align_h (wbv->current_style))
-			gnm_style_set_align_h (style, HALIGN_LEFT);
+		if (GNM_HALIGN_LEFT != gnm_style_get_align_h (wbv->current_style))
+			gnm_style_set_align_h (style, GNM_HALIGN_LEFT);
 		gnm_style_set_indent (style, i+1);
 		cmd_selection_format (wbc, style, NULL, _("Increase Indent"));
 	}
diff --git a/src/workbook-view.c b/src/workbook-view.c
index c2783b3..d1b90d6 100644
--- a/src/workbook-view.c
+++ b/src/workbook-view.c
@@ -307,7 +307,7 @@ wb_view_style_feedback (WorkbookView *wbv)
 
 	if (gnm_style_is_element_set (style, MSTYLE_VALIDATION) &&
 	    NULL != (val = gnm_style_get_validation (style)) &&
-	    val->type == VALIDATION_TYPE_IN_LIST &&
+	    val->type == GNM_VALIDATION_TYPE_IN_LIST &&
 	    val->use_dropdown)
 		wbv->in_cell_combo = gnm_validation_combo_new (val, sv);
 	else if (NULL != (dslicer = gnm_sheet_slicers_at_pos (sv->sheet, &sv->edit_pos)) &&
diff --git a/src/xml-sax-read.c b/src/xml-sax-read.c
index 75e54d3..6d3298d 100644
--- a/src/xml-sax-read.c
+++ b/src/xml-sax-read.c
@@ -1585,9 +1585,9 @@ xml_sax_validation (GsfXMLIn *xin, xmlChar const **attrs)
 	g_return_if_fail (state->validation.texpr[0] == NULL);
 	g_return_if_fail (state->validation.texpr[1] == NULL);
 
-	state->validation.style = VALIDATION_STYLE_NONE;
-	state->validation.type = VALIDATION_TYPE_ANY;
-	state->validation.op = VALIDATION_OP_NONE;
+	state->validation.style = GNM_VALIDATION_STYLE_NONE;
+	state->validation.type = GNM_VALIDATION_TYPE_ANY;
+	state->validation.op = GNM_VALIDATION_OP_NONE;
 	state->validation.allow_blank = TRUE;
 	state->validation.use_dropdown = FALSE;
 
diff --git a/src/xml-sax-write.c b/src/xml-sax-write.c
index 53a0a35..bb807dd 100644
--- a/src/xml-sax-write.c
+++ b/src/xml-sax-write.c
@@ -556,11 +556,11 @@ xml_write_style (GnmOutputXML *state, GnmStyle const *style)
 				      GNM_VALIDATION_TYPE_TYPE, v->type);
 
 		switch (v->type) {
-		case VALIDATION_TYPE_AS_INT :
-		case VALIDATION_TYPE_AS_NUMBER :
-		case VALIDATION_TYPE_AS_DATE :
-		case VALIDATION_TYPE_AS_TIME :
-		case VALIDATION_TYPE_TEXT_LENGTH :
+		case GNM_VALIDATION_TYPE_AS_INT :
+		case GNM_VALIDATION_TYPE_AS_NUMBER :
+		case GNM_VALIDATION_TYPE_AS_DATE :
+		case GNM_VALIDATION_TYPE_AS_TIME :
+		case GNM_VALIDATION_TYPE_TEXT_LENGTH :
 			gsf_xml_out_add_enum (state->output, "Operator",
 					      GNM_VALIDATION_OP_TYPE, v->op);
 			break;



[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]