bom_TURAG.ulp

#require 6.0500 //Version 6.5.0

#usage 	"<b>Teileliste exportieren</b>"
		"<p>"
		"Erzeugt die Teileliste (Bill of Material) eines Projektes"
		"<p>"


///start define
//arguments
string ARG_NOUPDATE = "--noupdate";
string ARG_ABS_OCPATH = "--ocpath";
string ARG_ABS_BLACKLISTPATH = "--blpath";
//special attributes
string NO_ORDER = "NOORDER";
string PROTOTYPE = "PROTOTYPE";
string KEEP_AS_IS = "KEEP_AS_IS";
//providers
string PROVIDER_NAMES[] = {"FARNELL","REICHELT","DIGIKEY","WUERTH","MINICIRCUITS","RS"}; ///Only these attributes are important; all other will be ignored without warning
int PROVIDER_COUNT	= 6;
//pathes
string ORDER_CODE_RELPATH = "order_codes/";
string BLACKLIST_RELPATH = "";
///end define

string msg;
int row=0;
numeric string list_rows[];
enum {output_text, output_farnell, output_reichelt, output_DigiKey, output_Excel};
// arrays for order codes from file
numeric string oc_device[], oc_package[], oc_value[], oc_provider[], oc_ordercode[];
int oc_index[], oc_count;
//arrays for order codes from schematic
numeric string part_name[], part_value[], part_device[], part_package[], part_headline[], part_description[], part_attributes[];
int part_amount[];
int num_parts = 0, output_format;
//run the update!
int run_update;
//order code path
string oc_path = "";
string bl_path = "";

/**
 * \brief Returns the path to the directory of the ULP-file
 */
string get_pwd(void){
	int index = strrchr(argv[0], '\\');
	if (index < 0){
		index = strrchr(argv[0], '/');
	}
	return strsub(argv[0], 0, index + 1 );
}

string remove_whitespaces(string input){
  int start=0;
  while(isspace(input[start])){
    start++;
  }
  int end=strlen(input)-1;
  if(start >= end){
    return "";
  }
  while(isspace(input[end])){
    end--;
  }
  return strsub(input, start, end-start+1);
}

/**
 * \brief Collects part data from all files in ORDER_CODE_RELPATH directory and subdirectories
 */
void collectFilePartData(void){
	string files[], lines[], line[], path;
	int filecount, line_count, line_nargs;
	
	oc_count = 0;
	
	path = oc_path + "*.txt";
	//dlgMessageBox(path);
	filecount = fileglob(files,path);
	fileerror(); //reset error buffer
	for (int i=0;i<filecount;i++){
		line_count = fileread(lines, files[i]);
		if(fileerror()){
			sprintf(msg, ":Error reading file %s", files[i]); dlgMessageBox(msg);
			exit(1);
		}
		for (int line_nr=0;line_nr<line_count;line_nr++){
      lines[line_nr] = remove_whitespaces(lines[line_nr]);
			if( !(lines[line_nr]) ){
				//ignore empty lines
				continue;
			}
			if(strchr(lines[line_nr],'#') == 0){
				//line starts with a '#' -> ignore
				continue;
			}
			line_nargs = strsplit(line, lines[line_nr], ';');
      //remove whitespaces
      for(int j=0;j<line_nargs;j++){
        line[j] = remove_whitespaces(line[j]);
      }
			if( line_nargs < 4 ){
				string err;
				sprintf(err, ":File '%s' has not enough arguments in line %d.", files[i], line_nr+1);
				dlgMessageBox(err);
				exit(-1);
			}
			if( strlen(line[0]) == 0){
				string err;
				sprintf(err, ":File '%s' has no device argument in line %d.", files[i], line_nr+1);
				dlgMessageBox(err);
				exit(-1);
			}
			if( strlen(line[1]) == 0){
				string err;
				sprintf(err, ":File '%s' has no package argument in line %d.", files[i], line_nr+1);
				dlgMessageBox(err);
				exit(-1);
			}
			
			for(j=0; j<(line_nargs-3); j++){
				oc_device[oc_count] = strlwr(line[0]);
				oc_package[oc_count] = strlwr(line[1]);
				oc_value[oc_count] = strlwr(line[2]);
				string order_codes[];
				strsplit(order_codes, line[j+3], '>');
				oc_provider[oc_count] = order_codes[0];
				oc_ordercode[oc_count] = order_codes[1];
				++oc_count;
			}
		}
	}
	
	sort(oc_count, oc_index, oc_device, oc_package, oc_value, oc_provider, oc_ordercode);
	//print for debug
if(0){
	sprintf(msg, "%d codes found", oc_count);
	for(i=0; i<oc_count; i++){
		int idx = oc_index[i];
		sprintf(msg, "%s\n%d|%d|%s|%s|%s|%s|%s", msg, i, idx, oc_device[idx], oc_package[idx], oc_value[idx], oc_provider[idx], oc_ordercode[idx]);
	}
	dlgMessageBox(msg);
} //if(0)
}

/**
 * \brief Updates and collects part data from schematic
 */
void updateCollectPartData(){
	int printed_no_attributes_error = 0;
	string update_cmd = "";
	
	schematic(schem){
		schem.parts(part){
			if(part.device.package){
				int keep_as_is = 0;
				int attr_count, i, index;
				numeric string attr_value[];
				
				///get the properties
				part_name[num_parts] = part.name;
				part_value[num_parts] = strlwr(part.value);
				part_device[num_parts] = strlwr(part.device.name);
				part_package[num_parts] = strlwr(part.device.package.name);
				part_headline[num_parts] = part.device.headline;
				part_description[num_parts] = part.device.description;
				part_attributes[num_parts] = "";
				part_amount[num_parts]=1;
				
				///simplify part package
				if (part.device.prefix == "R" || part.device.prefix == "C" || part.device.prefix == "L") {
					if (strstr(part_package[num_parts], "rcl_") == 0) { // remove "RCL_" from start of package name
						part_package[num_parts] = strsub(part_package[num_parts], 4);
					}
				}
				if (part.device.prefix == "C") {
					if (strrchr(part_package[num_parts], 'k') == (strlen(part_package[num_parts])-1)) { // remove "K" from end of package name (Cs without Keepout)
						part_package[num_parts] = strsub(part_package[num_parts], 0, strlen(part_package[num_parts])-1);
					}
					if( strrchr(part_device[num_parts], 'k') == (strlen(part_device[num_parts])-1) ){//remove 'K' from end of device name (Cs without Keepout
						part_device[num_parts] = strsub(part_device[num_parts], 0, strlen(part_device[num_parts])-1);
					}
				}
				
				///search for special attributes
				part.attributes(attribute){
					if(attribute.name == KEEP_AS_IS){
						keep_as_is = 1;
					}
				}
				
				///prepare part values
				string new_value = part_value[num_parts];
				int pos;
				pos = strchr(new_value, 'µ'); if( pos >= 0 ) new_value[pos] = 'u';
				pos = strchr(new_value, '.'); if( pos >= 0 ) new_value[pos] = ',';
				if(new_value != part_value[num_parts]){
					update_cmd += " VALUE " + part_name[num_parts] + " " + new_value + ";";
					//sprintf(msg, "old value:%s, new:%s",part_value[num_parts], new_value); dlgMessageBox(msg);
				}
				
				///update attributes
				if(run_update && !keep_as_is){
					//try to find order code for the part in codes read from files
					string updated_providers[];
					int updated_providers_count = 0;
					
					for(i=(oc_count-1); i>=0; i--){ //reverse search: empty value-entries should be used last. (like a wildcard)
						index = oc_index[i];

						if(oc_device[index] == part_device[num_parts]){
							if(oc_package[index] == part_package[num_parts]){
								//correspoinding entry found
								break;
							}
						}
					}
int debug = 0;//(part_name[num_parts] == ("UST$1"));
if(debug){sprintf(msg, "name:%s, dev:%s, pack:%s, %d",part_name[num_parts], part_device[num_parts], part_package[num_parts], i);dlgMessageBox(msg);}
					while(i >= 0){
						index = oc_index[i];
						if(oc_package[index] != part_package[num_parts]){
				if(debug>0){sprintf(msg, "no pack, i:%d", i); dlgMessageBox(msg); }
							break;
						}
						if(oc_device[index] != part_device[num_parts]){
				if(debug>0) dlgMessageBox("no dev");
							break;
						}
						for(int j=0; j<updated_providers_count; j++){
							if(oc_provider[index] == updated_providers[j]){
								break;
							}
						}
						if(j<updated_providers_count){
        if(debug>0) dlgMessageBox("provider already updated");
							//this provider was already updated. Trying to find another provider for the part
              --i;
							continue;
						}
				
				if(debug){sprintf(msg, "oc_val:%s, part_val:%s, i:%d", oc_value[index], part_value[num_parts], i); dlgMessageBox(msg);}
						if( (!oc_value[index]) /*|| (!part_value[num_parts])*/ || (oc_value[index] == part_value[num_parts]) ){
							//we (probably) found a suitable order code for the part
if(debug){sprintf(msg, "found. part attr:%s, oc:%s", part.attribute[oc_provider[index]], oc_ordercode[index]); dlgMessageBox(msg); debug=-1;}
							if( part.attribute[oc_provider[index]] != oc_ordercode[index] ){
								update_cmd += " ATTRIBUTE " + part_name[num_parts] + " " + oc_provider[index] + " '" + oc_ordercode[index] + "';";
							}
              updated_providers[updated_providers_count++] = oc_provider[index];
						}
						--i;
					}
if(debug){ if(dlgMessageBox("continue?", "+Yes", "-No") == 1) exit(0); }
				} //Update attributes ready
				
				///collect Data for BOM
				if(!update_cmd){
					//only collect necessary data, when there is no part, that requires an update
					
					///get the attributes
					attr_count = 0;
					part.attributes(attribute){
						if(attr_count != -1){
							for(int i=0;i<PROVIDER_COUNT;i++){
								if( PROVIDER_NAMES[i] == attribute.name ){
									if(attribute.value != ""){
										attr_value[i] = attribute.value;
										attr_count++;
									}
									break;
								}
								if( attribute.name == NO_ORDER){
									attr_count = -1;
									break;
								} else if(attribute.name == PROTOTYPE){
									string msg;
									sprintf(msg,":Part '%s' is marked as PROTOTYPE and will be ordered twice.\n Please check, if the board is still in prototyping and you really want to order it twice", part_name[num_parts]);
									if(dlgMessageBox(msg, "+Continue", "-Abort") == 1){
										exit(1);
									}
									attr_value[PROVIDER_COUNT]=PROTOTYPE; //create an additional value in this array; PROVIDER_COUNT is the last+1 index
									break;
								}

							}
						}
					}
					
					///Check, whether there is at least one order code
					if ( (attr_count == 0) && !printed_no_attributes_error){
						string err_msg;
						err_msg = "No order code found for part '" + part.name + "'";
						dlgDialog("Order code not found"){
							dlgVBoxLayout{
								dlgHBoxLayout{
									dlgLabel("<img src=warning.bmp>");
									dlgStretch(1);
									dlgLabel(err_msg);
									dlgStretch(1);
								}
								//dlgSpacing(40);
								dlgHBoxLayout{
									dlgPushButton("I&gnore") { 
										dlgReject();
									}
									dlgPushButton("Ignore &All") {
										printed_no_attributes_error = 1;
										dlgAccept();
									}
									dlgPushButton("&Show Part"){
										dlgReject();
										exit("SHOW " + part.name);
									}
									dlgPushButton("+Show Part &Info"){
										dlgReject();
										exit("Info " + part.name);
									}
									dlgPushButton("-&Abort"){
										dlgReject();
										exit(0);
									}
								}
							}
						}; //dlgDialog
						
						
						/*switch( dlgMessageBox(err_msg,"+Ignore","Ignore all","-Abort") ){
							case 1: //Ignore all
								printed_no_attributes_error = 1; break;
							case 2: //abort
								exit(0);
								break;
						}*/
					}
				} //if(!update_cmd)
				
				///Check blacklisted parts
				fileerror(); //reset error memory
				string file[], line[];
				string path = bl_path;//get_pwd() + "Blacklist.txt";
				fileread(file, path);
				if(fileerror()){
					sprintf(msg, ":Error reading blacklist file %s", path); dlgMessageBox(msg);
					exit(1);
				}
				for (int k=0; file[k]; k++){
					if(!strchr(file[k],'#')){ /// ignore Lines beginning with '#'
						continue;
					}
					int splitcount=strsplit(line, file[k], ';');
					for(int j=0;j<PROVIDER_COUNT;j++){
						if( (attr_value[j] == line[0]) && (PROVIDER_NAMES[j] == line[1]) ){
							string err_msg;
							err_msg = ":Part '" + part.name + "' with order code '" + attr_value[j] + "' is no longer available at "+ line[1] + " !!";
							if(splitcount >2){
								err_msg += "\n\nPossible alternative: '" + line[2] + "'";
							}
							if (dlgMessageBox(err_msg,"Ignore","+Abort") == 1) exit(0);
						}
					}
				}
				
				///separate the order codes if there is more than one (numbers are seperated by an ':')
				int num_add_attr_total = 0;
				int prototype_multi= 1;
				string substr;
				for(i=0;i<PROVIDER_COUNT;i++){
					int index = 0, num_add_attr = 0;

					if(attr_value[i] == ""){
						//no attribute here -> nothing to do; only append a '\t' for displaying
						while(num_add_attr <= num_add_attr_total){
							part_attributes[num_parts + num_add_attr++] += "\t";
						}
						continue;
					}

					int pos = strchr(attr_value[i], ':', index);

					if( (attr_value[PROVIDER_COUNT] == PROTOTYPE) ){ //check the part for prototype status
						prototype_multi = 2;
					} else {
						prototype_multi = 1;
					}
					while( pos > -1){ ///there is another number
						if(num_add_attr_total < num_add_attr){
							for(int j=0;j<i;j++) part_attributes[num_parts + num_add_attr] += "\t";
						}
						substr = strsub(attr_value[i],index,pos-index);
						index = pos+1;
						pos = strchr(substr,'*');
						if (pos == -1){
							part_amount[num_parts + num_add_attr] = prototype_multi;
						} else {
							//there is already an multiple part --> get the amount and multiply it
							int amount = strtol(strsub(substr,pos+1));
							part_amount[num_parts + num_add_attr] = amount*prototype_multi;
						}

						part_attributes[num_parts + num_add_attr] += strsub(substr,0,pos) + "\t";
						part_name[num_parts + num_add_attr] = part_name[num_parts]; ///get the corresponding part
						//index = pos + 1;
						pos = strchr(attr_value[i], ':', index);
						num_add_attr++;
					}

					if(num_add_attr_total < num_add_attr){ ///this tabs are needed to dispay it properly in the list
						for(int j=0;j<i;j++) part_attributes[num_parts + num_add_attr] += "\t";
						num_add_attr_total = num_add_attr;
					}

					substr = strsub(attr_value[i],index);
					pos = strchr(substr,'*');
					if(pos == -1){
						part_amount[num_parts + num_add_attr] = prototype_multi;
					} else {
						int amount = strtol(strsub(substr,pos+1));
						part_amount[num_parts + num_add_attr] = amount*prototype_multi;
					}

					part_attributes[num_parts + num_add_attr] += strsub(substr,0,pos) + "\t";
					part_name[num_parts + num_add_attr] = part_name[num_parts]; ///get the corresponding part

					while(num_add_attr < num_add_attr_total){ ///this tabs are needed to dispay it properly in the list
						num_add_attr++;
						part_attributes[num_parts + num_add_attr] += "\t";
					}

				}
				num_parts += num_add_attr_total + 1;
				
			} //if(part.device.package)
		}
	}
	if(update_cmd){
		update_cmd = "CHANGE DISPLAY OFF;" + update_cmd + " run bom_TURAG " + ARG_NOUPDATE + ";";
		//if( dlgMessageBox(update_cmd, "+OK", "-Abort") == 1) { exit(1); }
		exit(update_cmd);
	}
} //updateCollectPartData()

void GenerateList(void){
	int index[];
	int ind1, ind2, amount = 0;
	string qty;

	sort(num_parts, index, part_value, part_device, part_headline, part_package, part_attributes, part_name);

	row = 0;
	list_rows[row] = "Menge\tWert\tBauelement\tPackage\t";
	for(int i=0;i<PROVIDER_COUNT;i++){
		list_rows[row] += PROVIDER_NAMES[i] + "\t";
	}
	list_rows[row++] += "Beschreibung\tBauteile";


	///accumulate the parts and get the amount if there is more than one part with the same properties
	for(int i1 = 0, i2 = 1; i2<=num_parts; i2++){
		int is_prototype = 0;
		ind1 = index[i1]; //first part with same properties
		ind2 = index[i2]; //the other(last) part with same properties
		if(i1 == (i2-1)){
			amount = part_amount[ind1];
		}

		if( (i2 != num_parts) && (part_value[ind1] == part_value[ind2]) && (part_package[ind1] == part_package[ind2]) && (part_device[ind1] == part_device[ind2]) && (part_attributes[ind1] == part_attributes[ind2])){
			amount += part_amount[ind2];
			continue;
		}

		sprintf(qty, "%d", (amount)); ///calculate quantity of same parts
		amount = 0;

		list_rows[row] = qty + "\t" + part_value[ind1] + "\t" + part_device[ind1] + "\t" + part_package[ind1] + "\t" + part_attributes[ind1] + part_headline[ind1] + "\t";

		///list the part names
		do{
			list_rows[row] += part_name[index[i1]];
			if(i1 < (i2-1)) list_rows[row] += ",";
		}while(++i1<i2);



		row++;
	}


}

string MakeTextOutput(void){
	string out = "", line, split[];
	int i, width[], headers;

	headers = strsplit(split,list_rows[0],'\t');

	///get the maximum width for each column
	for(i=0;list_rows[i];i++){
		strsplit(split,list_rows[i],'\t');
		for(int j=0;j<headers;j++){
			width[j] = max(width[j], strlen(split[j]));
		}
	}

	///print the rows
	for(i=0;i<row;i++){
		line = "";
		int n = strsplit(split,list_rows[i],'\t');

		if(i == 0){
			headers = n;
		} else {
			n = headers; /// for the Rows with missing cells
		}

		for(int j=0;j<n;j++){
			while(strlen(split[j]) <= width[j] ){ ///add spaces --> every row in every column the same width
				split[j] += " ";
			}
			line += split[j] + "|";
		}

		if( i == 0 ){ ///the '-------' below the heading
			int len = strlen(line);
			line += "\n";
			for(int j=0;j<=len;j++){
				line += "-";
			}
		}

		out += line + "\n";
	}

	return out;
}

string MakeFarnellOutput(void){ ///Farnell Syntax: 'number, quantity'
	string out = "Bestellnummer,Menge\n", split[];
	int farnell_index, i, j;

	strsplit(split, list_rows[0], '\t');
	for(i=0;list_rows[i];i++){ ///get the index of the Farnell-number
		if (split[i] == "FARNELL"){
			farnell_index = i;
			break;
		}
	}

	for(i=1;i<row;i++){
		strsplit(split, list_rows[i], '\t');
		if(split[farnell_index] != ""){
			if( strtol(split[0]) ) out += split[farnell_index] + "," + split[0] + "\n"; ///split[0] is the quantity; make only an output, when there is any needed part
		}
	}

	return out;
}

string MakeReicheltOutput(void){///Reichelt-Syntax: 'number;quantity'
	string out = "", split[];
	int reichelt_index, i, j;

	strsplit(split, list_rows[0], '\t');
	for(i=0;list_rows[i];i++){ ///get the index of the Reichelt-number
		if (split[i] == "REICHELT"){
			reichelt_index = i;
			break;
		}
	}

	for(i=1;i<row;i++){
		strsplit(split, list_rows[i], '\t');
		if(split[reichelt_index] != ""){
			if( strtol(split[0]) ) out += split[reichelt_index] + ";" + split[0] + "\n";///split[0] is the quantity; make only an output, when there is any needed part
		}
	}

	return out;
}

string MakeDigikeyOutput(void){///Digikey-Syntax: 'quantity,number'
	string out = "", split[];
	int digikey_index, i, j;

	strsplit(split, list_rows[0], '\t');
	for(i=0;list_rows[i];i++){ ///get the index of the Digikey-number
		if (split[i] == "DIGIKEY"){
			digikey_index = i;
			break;
		}
	}

	for(i=1;i<row;i++){
		strsplit(split, list_rows[i], '\t');
		if(split[digikey_index] != ""){
			if( strtol(split[0]) ) out += split[0] + "," + split[digikey_index] + "\n";///split[0] is the quantity; make only an output, when there is any needed part
		}
	}

	return out;
}

string MakeExcelOutput(void){
	string out = "", line, split[];
	int i, width[], headers;

	headers = strsplit(split,list_rows[0],'\t');

	///print the rows
	for(i=0;i<row;i++){
		line = "";
		int n = strsplit(split,list_rows[i],'\t');

		if(i == 0){
			headers = n;
		} else {
			n = headers; /// for the Rows with missing cells
		}

		for(int j=0;j<n;j++){
			line += split[j] + "\t";
		}

		out += line + "\n";
	}

	return out;
}

string MakeOutput(void){ ///Choose the Output-Format
	switch(output_format){
		case output_text: return MakeTextOutput(); break;
		case output_farnell: return MakeFarnellOutput(); break;
		case output_reichelt: return MakeReicheltOutput(); break;
		case output_DigiKey: return MakeDigikeyOutput(); break;
		case output_Excel: return MakeExcelOutput(); break;
	}
	return "";
}

void SaveData(void){
	string file_name;
	schematic(schem) file_name = filesetext(schem.name,""); ///filename is the name of the schematic; file will be stored in the folder of schematic

	switch(output_format){
		case output_farnell: file_name += "_farnell"; break;
		case output_reichelt: file_name += "_reichelt"; break;
		case output_DigiKey: file_name += "_digikey"; break;
		case output_Excel: file_name += "_excel"; break;
	}

	file_name += ".txt";

	string path = dlgFileSave("Teileliste speichern", file_name ); ///Open save-Dialog

	if (path){ ///do not save if the path is empty
		fileerror();
		string s[];
		if (!fileglob (s, path) || dlgMessageBox ("!Datei existiert - überschreiben?", "+&Ja", "-&Nein") == 0){ ///check, whether the file already exists and ask for overwriting
			output (path, "wt"){ ///open the file
				printf ("%s", MakeOutput()); ///write to the file
			}
		}

		if (fileerror()){ ///there was an error while writing the file
			dlgMessageBox(":Unable to save file");
			return;
		}
	}
}

void ViewList(void){
	dlgDialog("Voransicht"){ ///The window
		dlgVBoxLayout{ ///box to stack it vertically
			string s = MakeOutput();
			s = "<pre>" + s + "</pre>";
			dlgTextView(s); ///Text box
			dlgHBoxLayout{ ///box for buttons (stack it horizontally)
				dlgStretch(1); ///stretch: the buttons should be in the middle
				dlgPushButton("+&Speichern...") SaveData();
				dlgPushButton("+Schließen") dlgReject();
				dlgStretch(1); ///stretch: the buttons should be in the middle
			}
		}
	};
}

/// ~~~BEGIN of the ULP ~~~~~~

if (!schematic) ///this ULP only works in Schematicss
{
  dlgMessageBox (":Die Bauteilliste kann nur innerhalb eines Schaltplanes erstellt werden.");
  exit (1);
}

run_update = 1;

//check for parameters
for(int i=1; i<argc; i++){ //argv[0] is the path of this ULP
	if( argv[i] == ARG_NOUPDATE){
		run_update = 0;
	}
	if( argv[i] == ARG_ABS_OCPATH ){
		//user provided an absolute path for order codes (or at least he should)
		++i;
		oc_path = argv[i];
		int idx = strchr(oc_path, '\\');
		while(idx >= 0){
			oc_path[idx] = '/';
			idx = strchr(oc_path, '\\');
		}
		oc_path += "/";
	}
  if( argv[i] == ARG_ABS_BLACKLISTPATH){
    //user provided an absolute path for the blacklist-file (or at least he should)
    ++i;
    bl_path = argv[i];
    int idx = strchr(bl_path, '\\');
    while(idx >= 0){
      bl_path[idx] = '/';
      idx = strchr(bl_path, '\\');
    }
  }
}

/// check for empty pathes
if(oc_path == ""){
  oc_path = get_pwd() + ORDER_CODE_RELPATH;
}
if(bl_path == ""){
  bl_path = get_pwd() + BLACKLIST_RELPATH + "Blacklist.txt";;
}

if(run_update){
	collectFilePartData();
}
updateCollectPartData();

GenerateList();

//string str; sprintf(str, "parts: %d",num_parts); dlgMessageBox(str);

dlgDialog("Teileliste"){ ///Main Dialog

	int selected = -2, sort_col = 2, format;
	string head = ""; ///empty, because it will be generated in 'GenerateList()' as the row[0]

	dlgVBoxLayout { ///Box to stack it vertically
		dlgListView (head, list_rows, selected);//, sort_col); ///List
		dlgHBoxLayout{ ///Box for the output-format
			dlgGroup("Ausgabe-Format"){
				dlgRadioButton("&Text", output_format);
				dlgRadioButton("&Farnell-Bestellliste", output_format);
				dlgRadioButton("&Reichelt-Bestellliste", output_format);
				dlgRadioButton("&DigiKey-Bestellliste", output_format);
				dlgRadioButton("Bestelliste für &Excel-Import", output_format);
			}
			dlgStretch(1);
		}
		dlgHBoxLayout{ ///box to stack the buttons horizontally
			//dlgStretch(1);
			dlgPushButton("&Voransicht") ViewList();
			dlgPushButton("+&Speichern...") SaveData();
			dlgPushButton("S&chließen") dlgReject();
			dlgStretch(1);
		}
	}


};