Index: trunk/src/draw_composite.c
===================================================================
--- trunk/src/draw_composite.c	(revision 12014)
+++ trunk/src/draw_composite.c	(revision 12015)
@@ -163,7 +163,7 @@
 
 int pcb_draw_layer_is_comp(pcb_layer_id_t id)
 {
-	pcb_layergrp_t *g = pcb_get_layergrp(PCB, PCB->Data->Layer[id].grp);
+	pcb_layergrp_t *g = pcb_get_layergrp(PCB, PCB->Data->Layer[id].meta.real.grp);
 	if (g == NULL) return 0;
 	return pcb_draw_layergrp_is_comp(g);
 }
Index: trunk/src/gui_act.c
===================================================================
--- trunk/src/gui_act.c	(revision 12014)
+++ trunk/src/gui_act.c	(revision 12015)
@@ -1580,8 +1580,14 @@
 	int ret = 0, n, interactive = 1, explicit = 0;
 	pcb_layergrp_t *g = NULL;
 
+#warning layer TODO: rewrite this with DAD in two versions (bound and unbound)
+	if (CURRENT->is_bound) {
+		pcb_message(PCB_MSG_ERROR, "Can't edit bound layers yet\n");
+		return 1;
+	}
+
 	if (CURRENT != NULL)
-		g = pcb_get_layergrp(PCB, CURRENT->grp);
+		g = pcb_get_layergrp(PCB, CURRENT->meta.real.grp);
 
 	for(n = 0; n < argc; n++) {
 		if (!explicit && (*argv[n] == '@')) {
Index: trunk/src/layer.c
===================================================================
--- trunk/src/layer.c	(revision 12014)
+++ trunk/src/layer.c	(revision 12015)
@@ -206,7 +206,7 @@
 		return 0;
 
 	l = &pcb->Data->Layer[layer_idx];
-	return pcb_layergrp_flags(pcb, l->grp);
+	return pcb_layergrp_flags(pcb, l->meta.real.grp);
 }
 
 unsigned int pcb_layer_flags_(pcb_board_t *pcb, pcb_layer_t *layer)
@@ -319,7 +319,7 @@
 		if (PCB->Data->Layer[n].name != NULL)
 			free((char *)PCB->Data->Layer[n].name);
 		PCB->Data->Layer[n].name = pcb_strdup("<pcb_layers_reset>");
-		PCB->Data->Layer[n].grp = -1;
+		PCB->Data->Layer[n].meta.real.grp = -1;
 	}
 
 	/* reset layer groups */
@@ -336,7 +336,7 @@
 static void layer_clear(pcb_layer_t *dst)
 {
 	memset(dst, 0, sizeof(pcb_layer_t));
-	dst->grp = -1;
+	dst->meta.real.grp = -1;
 }
 
 pcb_layer_id_t pcb_layer_create(pcb_layergrp_id_t grp, const char *lname)
@@ -361,7 +361,7 @@
 		PCB->LayerGroups.grp[grp].len++;
 		PCB->Data->Layer[id].meta.real.vis = PCB->Data->Layer[PCB->LayerGroups.grp[grp].lid[0]].meta.real.vis;
 	}
-	PCB->Data->Layer[id].grp = grp;
+	PCB->Data->Layer[id].meta.real.grp = grp;
 
 	PCB->Data->Layer[id].parent = PCB->Data;
 	return id;
@@ -438,7 +438,7 @@
 static void layer_init(pcb_layer_t *lp, pcb_layer_id_t idx, pcb_layergrp_id_t gid, pcb_data_t *parent)
 {
 	memset(lp, 0, sizeof(pcb_layer_t));
-	lp->grp = gid;
+	lp->meta.real.grp = gid;
 	lp->meta.real.vis = 1;
 	lp->name = pcb_strdup("New Layer");
 	lp->meta.real.color = conf_core.appearance.color.layer[idx];
@@ -492,9 +492,9 @@
 		if (new_in_grp >= 0)
 			layer_init(lp, new_lid, new_in_grp, PCB->Data);
 		else
-			layer_init(lp, new_lid, PCB->Data->Layer[new_index].grp, PCB->Data);
+			layer_init(lp, new_lid, PCB->Data->Layer[new_index].meta.real.grp, PCB->Data);
 
-		g = pcb_get_layergrp(PCB, lp->grp);
+		g = pcb_get_layergrp(PCB, lp->meta.real.grp);
 
 		if (new_in_grp >= 0) {
 			if (new_index == 0)
@@ -524,7 +524,7 @@
 #warning layer TODO remove objects, free fields layer_free(&PCB->Data->Layer[old_index]);
 
 		/* remove the current lid from its group */
-		g = pcb_get_layergrp(PCB, PCB->Data->Layer[old_index].grp);
+		g = pcb_get_layergrp(PCB, PCB->Data->Layer[old_index].meta.real.grp);
 		grp_idx = pcb_layergrp_index_in_grp(g, old_index);
 		if (grp_idx < 0) {
 			pcb_message(PCB_MSG_ERROR, "Internal error; layer not in group\n");
@@ -662,9 +662,10 @@
 
 void pcb_layer_real2bound(pcb_layer_t *dst, pcb_layer_t *src, int share_rtrees)
 {
-	dst->grp = src->grp;
 	dst->comb = src->comb;
 
+	assert(!src->is_bound);
+
 	dst->is_bound = 1;
 
 	if (!src->is_bound) {
@@ -675,7 +676,7 @@
 	else
 		dst->meta.bound.real = NULL;
 
-	dst->meta.bound.type = pcb_layergrp_flags(PCB, src->grp);
+	dst->meta.bound.type = pcb_layergrp_flags(PCB, src->meta.real.grp);
 	if (src->name != NULL)
 		dst->name = pcb_strdup(src->name);
 	else
@@ -684,8 +685,8 @@
 	if ((dst->meta.bound.type & PCB_LYT_INTERN) && (dst->meta.bound.type & PCB_LYT_COPPER)) {
 		int from_top, from_bottom, res;
 		
-		res = pcb_layergrp_dist(PCB, src->grp, pcb_layergrp_get_top_copper(), PCB_LYT_COPPER, &from_top);
-		res |= pcb_layergrp_dist(PCB, src->grp, pcb_layergrp_get_bottom_copper(), PCB_LYT_COPPER, &from_bottom);
+		res = pcb_layergrp_dist(PCB, src->meta.real.grp, pcb_layergrp_get_top_copper(), PCB_LYT_COPPER, &from_top);
+		res |= pcb_layergrp_dist(PCB, src->meta.real.grp, pcb_layergrp_get_bottom_copper(), PCB_LYT_COPPER, &from_bottom);
 		if (res == 0) {
 			if (from_top <= from_bottom)
 				dst->meta.bound.stack_offs = from_top;
@@ -758,7 +759,6 @@
 	lay->is_bound = 1;
 	lay->name = pcb_strdup(name);
 	lay->meta.bound.type = type;
-	lay->grp = -1;
 	lay->parent = data;
 
 	return lay;
@@ -865,7 +865,7 @@
 	pcb_layergrp_t *g;
 
 	if (*cache < PCB->Data->LayerN) { /* check if the cache is still pointing to the right layer */
-		pcb_layergrp_id_t gid = PCB->Data->Layer[*cache].grp;
+		pcb_layergrp_id_t gid = PCB->Data->Layer[*cache].meta.real.grp;
 		if ((gid >= 0) && (gid < PCB->LayerGroups.len)) {
 			g = &(PCB->LayerGroups.grp[gid]);
 			if ((g->type & loc) && (g->type & typ) && (g->lid[0] == *cache))
Index: trunk/src/layer.h
===================================================================
--- trunk/src/layer.h	(revision 12014)
+++ trunk/src/layer.h	(revision 12015)
@@ -102,7 +102,6 @@
 
 	const char *name;              /* layer name */
 
-	pcb_layergrp_id_t grp;         /* the group this layer is in (cross-reference) */
 	pcb_layer_combining_t comb;    /* how to combine this layer with other layers in the group */
 
 	/* for bound layers these point to the board layer's*/
@@ -110,6 +109,7 @@
 
 	union {
 		struct { /* A real board layer */
+			pcb_layergrp_id_t grp;         /* the group this layer is in (cross-reference) */
 			pcb_bool vis;                  /* visible flag */
 			const char *color;             /* color */
 			const char *selected_color;
Index: trunk/src/layer_grp.c
===================================================================
--- trunk/src/layer_grp.c	(revision 12014)
+++ trunk/src/layer_grp.c	(revision 12015)
@@ -64,12 +64,12 @@
 pcb_layergrp_id_t pcb_layer_get_group_(pcb_layer_t *Layer)
 {
 	if (!Layer->is_bound)
-		return Layer->grp;
+		return Layer->meta.real.grp;
 
 	if (Layer->meta.bound.real == NULL) /* bound layer without a binding */
 		return -1;
 
-	return Layer->meta.bound.real->grp;
+	return Layer->meta.bound.real->meta.real.grp;
 }
 
 pcb_layergrp_t *pcb_get_layergrp(pcb_board_t *pcb, pcb_layergrp_id_t gid)
@@ -99,13 +99,13 @@
 
 	layer = pcb->Data->Layer + lid;
 	if (gid < 0)
-		gid = layer->grp;
+		gid = layer->meta.real.grp;
 	if (gid >= pcb->LayerGroups.len)
 		return -1;
 
 	grp = &pcb->LayerGroups.grp[gid];
 
-	if (layer->grp != gid)
+	if (layer->meta.real.grp != gid)
 		return -1;
 
 	for(n = 0; n < grp->len; n++) {
@@ -114,7 +114,7 @@
 			if (remain > 0)
 				memmove(&grp->lid[n], &grp->lid[n+1], remain * sizeof(pcb_layer_id_t));
 			grp->len--;
-			layer->grp = -1;
+			layer->meta.real.grp = -1;
 			NOTIFY();
 			return 0;
 		}
@@ -193,7 +193,7 @@
 			free(g->name);
 		for(n = 0; n < g->len; n++) {
 			pcb_layer_t *layer = pcb->Data->Layer + g->lid[n];
-			layer->grp = -1;
+			layer->meta.real.grp = -1;
 		}
 		memset(g, 0, sizeof(pcb_layergrp_t));
 		return 0;
@@ -218,7 +218,7 @@
 	/* update layer's group refs to the new grp */
 	for(n = 0; n < d->len; n++) {
 		pcb_layer_t *layer = pcb->Data->Layer + d->lid[n];
-		layer->grp = dst;
+		layer->meta.real.grp = dst;
 	}
 
 	memset(s, 0, sizeof(pcb_layergrp_t));
@@ -345,8 +345,8 @@
 			pcb_layer_id_t lid =stk->grp[g].lid[n];
 			if ((lid >= 0) && (lid < pcb->Data->LayerN)) {
 				pcb_layer_t *l = &pcb->Data->Layer[lid];
-				if (l->grp > 0)
-					l->grp += delta;
+				if (l->meta.real.grp > 0)
+					l->meta.real.grp += delta;
 			}
 		}
 	}
@@ -415,7 +415,7 @@
 			}
 			else {
 				/* detach only */
-				l->grp = -1;
+				l->meta.real.grp = -1;
 			}
 		}
 	}
@@ -458,8 +458,8 @@
 #warning TODO: use pcb_get_layer when it becomes pcb-safe
 /*		pcb_layer_t *l = pcb_get_layer(stk->grp[to_before].lid[n]);*/
 		pcb_layer_t *l = &pcb->Data->Layer[stk->grp[to_before].lid[n]];
-		if ((l != NULL) && (l->grp > 0))
-			l->grp = to_before;
+		if ((l != NULL) && (l->meta.real.grp > 0))
+			l->meta.real.grp = to_before;
 	}
 
 	NOTIFY();
@@ -614,7 +614,7 @@
 
 	grp->lid[grp->len] = layer_id;
 	grp->len++;
-	pcb->Data->Layer[layer_id].grp = group_id;
+	pcb->Data->Layer[layer_id].meta.real.grp = group_id;
 
 	return 0;
 }
Index: trunk/src/obj_subc.c
===================================================================
--- trunk/src/obj_subc.c	(revision 12014)
+++ trunk/src/obj_subc.c	(revision 12015)
@@ -98,7 +98,6 @@
 	memcpy(&dst->meta, &src->meta, sizeof(src->meta));
 	dst->is_bound = 1;
 	dst->comb = src->comb;
-	dst->grp = -1;
 	dst->parent = sc->data;
 	return dst;
 }
Index: trunk/src/obj_text.c
===================================================================
--- trunk/src/obj_text.c	(revision 12014)
+++ trunk/src/obj_text.c	(revision 12015)
@@ -848,8 +848,8 @@
 	else
 		pcb_gui->set_color(Output.fgGC, layer->meta.real.color);
 
-	if (layer->grp >= 0)
-		flg = pcb_layergrp_flags(PCB, layer->grp);
+	if (layer->meta.real.grp >= 0)
+		flg = pcb_layergrp_flags(PCB, layer->meta.real.grp);
 
 	if (flg & PCB_LYT_SILK)
 		min_silk_line = PCB->minSlk;
Index: trunk/src/object_act.c
===================================================================
--- trunk/src/object_act.c	(revision 12014)
+++ trunk/src/object_act.c	(revision 12015)
@@ -1139,7 +1139,7 @@
 	}
 	else if (strncmp(argv[1], "step", 4) == 0) {
 		pcb_layer_t *l = CURRENT;
-		pcb_layergrp_t *g = pcb_get_layergrp(PCB, l->grp);
+		pcb_layergrp_t *g = pcb_get_layergrp(PCB, l->meta.real.grp);
 		if (g == NULL) {
 			pcb_message(PCB_MSG_ERROR, "Invalid layer group\n");
 			return 1;
@@ -1158,7 +1158,7 @@
 	if (new_index < 0) {
 		if (pcb_layer_flags(PCB, old_index) & PCB_LYT_SILK) {
 			pcb_layer_t *l = pcb_get_layer(old_index);
-			pcb_layergrp_t *g = pcb_get_layergrp(PCB, l->grp);
+			pcb_layergrp_t *g = pcb_get_layergrp(PCB, l->meta.real.grp);
 			if (g->len == 1) {
 				pcb_message(PCB_MSG_ERROR, "Removing this layer would result in an empty top or bottom silk group, which is not possible at the moment.\n");
 				return 1;
Index: trunk/src_plugins/draw_csect/draw_csect.c
===================================================================
--- trunk/src_plugins/draw_csect/draw_csect.c	(revision 12014)
+++ trunk/src_plugins/draw_csect/draw_csect.c	(revision 12015)
@@ -707,7 +707,7 @@
 				if (gactive >= 0) {
 					pcb_layer_t *l = &PCB->Data->Layer[drag_lid];
 					pcb_layergrp_t *g;
-					if (l->grp == gactive) { /* move within the group */
+					if (l->meta.real.grp == gactive) { /* move within the group */
 						int d, s, at;
 						g = &PCB->LayerGroups.grp[gactive];
 
@@ -810,8 +810,8 @@
 			if (l->comb & PCB_LYC_SUB) printf(" sub");
 			if (l->comb & PCB_LYC_AUTO) printf(" auto");
 			printf("\n");
-			if (l->grp != gid)
-				printf("         *** broken layer-to-group cross reference: %ld\n", l->grp);
+			if (l->meta.real.grp != gid)
+				printf("         *** broken layer-to-group cross reference: %ld\n", l->meta.real.grp);
 		}
 	}
 	return 0;
Index: trunk/src_plugins/io_lihata/read.c
===================================================================
--- trunk/src_plugins/io_lihata/read.c	(revision 12014)
+++ trunk/src_plugins/io_lihata/read.c	(revision 12015)
@@ -649,7 +649,7 @@
 		if (pcb != NULL) {
 			int grp_id;
 			parse_int(&grp_id, lht_dom_hash_get(grp, "group"));
-			dt->Layer[layer_id].grp = grp_id;
+			dt->Layer[layer_id].meta.real.grp = grp_id;
 	/*		pcb_trace("parse_data_layer name: %d,%d '%s' grp=%d\n", layer_id, dt->LayerN-1, ly->name, grp_id);*/
 		}
 	}
@@ -875,18 +875,18 @@
 	pcb_layer_group_setup_default(&pcb->LayerGroups);
 
 	/* old silk assumption: last two layers are silk, bottom and top */
-	bottom_silk = pcb->Data->Layer[pcb->Data->LayerN-2].grp;
-	top_silk = pcb->Data->Layer[pcb->Data->LayerN-1].grp;
-	pcb->Data->Layer[pcb->Data->LayerN-2].grp = -1;
-	pcb->Data->Layer[pcb->Data->LayerN-1].grp = -1;
+	bottom_silk = pcb->Data->Layer[pcb->Data->LayerN-2].meta.real.grp;
+	top_silk = pcb->Data->Layer[pcb->Data->LayerN-1].meta.real.grp;
+	pcb->Data->Layer[pcb->Data->LayerN-2].meta.real.grp = -1;
+	pcb->Data->Layer[pcb->Data->LayerN-1].meta.real.grp = -1;
 
 /*	pcb_trace("NAME: '%s' '%s'\n", pcb->Data->Layer[pcb->Data->LayerN-1].Name,pcb->Data->Layer[pcb->Data->LayerN-2].Name);*/
 
 	for(n = 0; n < pcb->Data->LayerN - 2; n++) {
 		pcb_layer_t *l = &pcb->Data->Layer[n];
-		pcb_layergrp_id_t grp = l->grp;
+		pcb_layergrp_id_t grp = l->meta.real.grp;
 		/*pcb_trace("********* l=%d %s g=%ld (top=%ld bottom=%ld)\n", n, l->name, grp, top_silk, bottom_silk);*/
-		l->grp = -1;
+		l->meta.real.grp = -1;
 
 		if (grp == bottom_silk)
 			g = pcb_get_grp(&pcb->LayerGroups, PCB_LYT_BOTTOM, PCB_LYT_COPPER);
@@ -894,7 +894,7 @@
 			g = pcb_get_grp(&pcb->LayerGroups, PCB_LYT_TOP, PCB_LYT_COPPER);
 		else
 			g = pcb_get_grp_new_intern(pcb, grp);
-/*			pcb_trace(" add %ld\n", g - pcb->LayerGroups.grp);*/
+/*			pcb_trace(" add %ld\n", g - pcb->LayerGroups.meta.real.grp);*/
 		if (g != NULL) {
 			pcb_layer_add_in_group_(pcb, g, g - pcb->LayerGroups.grp, n);
 			if (strcmp(l->name, "outline") == 0)
Index: trunk/src_plugins/io_pcb/file.c
===================================================================
--- trunk/src_plugins/io_pcb/file.c	(revision 12014)
+++ trunk/src_plugins/io_pcb/file.c	(revision 12015)
@@ -755,7 +755,7 @@
 {
 	pcb_layer_id_t lid;
 	for(lid = 0; lid < PCB_MAX_LAYER; lid++) {
-		if (pcb->Data->Layer[lid].grp == 0) {
+		if (pcb->Data->Layer[lid].meta.real.grp == 0) {
 			free((char *)pcb->Data->Layer[lid].name);
 			pcb->Data->Layer[lid].name = pcb_strdup(name);
 			return lid;
Index: trunk/src_plugins/lib_gtk_common/dlg_propedit.c
===================================================================
--- trunk/src_plugins/lib_gtk_common/dlg_propedit.c	(revision 12014)
+++ trunk/src_plugins/lib_gtk_common/dlg_propedit.c	(revision 12015)
@@ -317,7 +317,7 @@
 
 	memcpy(&preview_pcb.LayerGroups, &PCB->LayerGroups, sizeof(PCB->LayerGroups));
 	preview_pcb.Data->LayerN = 1;
-	preview_pcb.Data->Layer[0].grp = 0;
+	preview_pcb.Data->Layer[0].meta.real.grp = 0;
 	preview_pcb.LayerGroups.grp[0].type = PCB_LYT_COPPER | PCB_LYT_TOP;
 	preview_pcb.LayerGroups.grp[0].lid[0] = 0;
 	preview_pcb.LayerGroups.grp[0].len = 1;
Index: trunk/src_plugins/lib_gtk_common/wt_layersel.c
===================================================================
--- trunk/src_plugins/lib_gtk_common/wt_layersel.c	(revision 12014)
+++ trunk/src_plugins/lib_gtk_common/wt_layersel.c	(revision 12015)
@@ -172,8 +172,10 @@
 	if (CURRENT->meta.real.vis)
 		return;
 
+#warning layer TODO#5: do something with bound layers here
+
 	/* look for the next one to enable, group-vise */
-	for(gid = CURRENT->grp + 1; gid != CURRENT->grp; gid++) {
+	for(gid = CURRENT->meta.real.grp + 1; gid != CURRENT->meta.real.grp; gid++) {
 		pcb_layergrp_t *g;
 		if (gid >= pcb_max_group(PCB))
 			gid = 0;
Index: trunk/src_plugins/millpath/toolpath.c
===================================================================
--- trunk/src_plugins/millpath/toolpath.c	(revision 12014)
+++ trunk/src_plugins/millpath/toolpath.c	(revision 12015)
@@ -22,6 +22,8 @@
 
 #include "config.h"
 
+#include <assert.h>
+
 #include "toolpath.h"
 
 #include "board.h"
@@ -152,7 +154,9 @@
 	pcb_layergrp_id_t otl;
 	int has_otl;
 
-	result->grp = pcb_get_layergrp(pcb, layer->grp);
+	assert(!layer->is_bound);
+
+	result->grp = pcb_get_layergrp(pcb, layer->meta.real.grp);
 	has_otl = (pcb_layergrp_list(pcb, PCB_LYT_OUTLINE, &otl, 1) == 1);
 
 	if (has_otl) { /* if there's an outline layer, the remove-poly shouldn't be bigger than that */