Smart DXL

Display Unique IDs

Tony Goodman — Thu, 23 Jun 2011 14:53:53 +0000

This very simple script displays the Unique ID, type, full path and URL of the items currently selected in the database explorer. To see information for other items, select the item(s) in the database explorer and click on the refresh button.

//	Show Unique IDs of selected items

/*

	Change History
	-----------------
	29-DEC-10	Tony Goodman	Initial Version

*/

pragma runLim,0

DB   dbMain        = null
DBE infoTextDBE = null

/******************************
	getInfo
******************************/
void getInfo()
{
	Buffer outputBuf = create
	Skip selectedItems = getSelectedItems() // sneaky undocumented function...
	Item selectedItem
	string uid = ""
	string quid = ""
	string itemType = ""
	string rootOfItem = ""
	string urlOfItem = ""
	string nameOfItem =""
	bool noItemsSelected = true

	for selectedItem in selectedItems do
	{
		// loop through the list of selected Items via the Skip

		noItemsSelected = false // got at least one Item

		// get required data...
		uid = uniqueID selectedItem
		quid = qualifiedUniqueID selectedItem
		nameOfItem = name(selectedItem)
		itemType = type(selectedItem)
		rootOfItem = rootName_(selectedItem)
		urlOfItem = getURL(selectedItem)

		if( itemType == "Formal" || itemType == "Descriptive" || itemType == "Link" )
		{
			itemType = itemType " Module"
		}

		// Build output buffer...
		outputBuf += "Name: {\\b " nameOfItem "}\n"
		outputBuf += "Unique ID: " uid "\n"
		outputBuf += "Qualified Unique ID: " quid "\n"
		outputBuf += "Type: " itemType "\n"
		outputBuf += "Path: " rootOfItem "\n"
		outputBuf += "URL: " urlOfItem "\n"
		outputBuf += "\n"

	}

	// write out info gathered
	if( noItemsSelected )
	{
		set (infoTextDBE, "No items selected")
	}
	else
	{
		set (infoTextDBE, stringOf( outputBuf ))
	}

	delete outputBuf
	delete selectedItems
}

/******************************
	getInfo
******************************/
void getInfo(DB db)
{
	getInfo()
} 

/******************************
	showUniqueIDs
******************************/
void showUniqueIDs()
{
	dbMain = create(dbExplorer, "Unique ID of Selected Items", styleCentered|styleFloating)
	infoTextDBE = richText(dbMain, "", "", 500, 150, true)
	apply(dbMain, "Refresh", getInfo)
	realize(dbMain)
	getInfo()
	show(dbMain)
}

showUniqueIDs()

Export Changes

Tony Goodman — Thu, 23 Jun 2011 13:45:57 +0000

This script exports changes between two baselines as red-lined markup in an HTML table. Object Heading and Text are included in the output, with changes highlighted in the newer baseline. You can select the attribute used to identify the objects and an additional attribute can be included in the output.

//

/*

*/

pragma runLim, 0

//<  Export Change Report to HTML

/*
	18-MAR-2011		Tony Goodman
*/

Buffer textBuf2 = create
Buffer tempBuf = create

/***********************************
	getAttr
***********************************/
string getAttr(Object o, string attr)
{
	string s = ""

	if (attr == "Identifier")
	{
		return(identifier(o))
	}

	if (attr == "Level")
	{
		return(level(o) "")
	}

	if (attr == "Number")
	{
		return(number(o) "")
	}

	s = probeAttr_(o, attr)

	if (s "" == "")
	{
		return("
")
	}
	else
	{
		return(s)
	}
}

/***********************************
	emitHeader
***********************************/
void emitHeader(Stream out)
{
	out << "\n"
	out << "\n"
	out << "\n"

	out << "\n"
	out << "\n"
	out << "\n"
}

/***********************************
	emitFooter
***********************************/
void emitFooter(Stream out)
{
	out << "\n"
	out << "\n"
	out << "\n"
}

/***********************************
	convertRichText
***********************************/
void convertRichText(Buffer& b, string s)
{
	RichTextParagraph rp = null
    RichText rt = null
    bool limitText = false
	int ind = 0
	int i = 0

    setempty(b)

	for rp in s do
	{
		ind = rp.indentLevel

		for (i = 0; i < ind; i += 360) b += ""

		if (rp.isBullet) b += ""

		for rt in rp do
		{
			setempty(textBuf2)
			textBuf2 += rt.text

			safeHTMLBuffer(textBuf2, true, true)

			if (rt.bold) b += ""

			if (rt.underline)
			{
				b += ""
				b += ""
			}

			if (rt.italic) b += ""

			if (rt.strikethru)
			{
				b += ""
				b += ""
			}

			if (rt.superscript) b += "^{"
			if (rt.subscript) b += "_{"
			if (rt.charset == charsetSymbol) b += ""

			b += textBuf2

			if (rt.charset == charsetSymbol) b += ""
			if (rt.subscript) b += "}"
			if (rt.superscript) b += "}"
			if (rt.strikethru)
			{
				b += ""
				b += ""
			}

			if (rt.italic) b += ""
			if (rt.underline)
			{
				b += ""
				b += ""
			}

			if (rt.bold) b += ""

			if (rt.newline) b += "
"
		}

		if (rp.isBullet) b += ""

		for (i = 0; i < ind; i += 360) b += ""
	}
}

/***********************************
	emitFileHeader
***********************************/
void emitFileHeader(Stream out, string moduleName, Skip selectedAttributes)
{
	string attr = ""
	bool doneOne = false

	out << "\n"

	// header row
	out << "\n"
	out << "\n"
	out << "\n"

	out << "\n"

	out << "Module: " moduleName "
"
	out << "Exported from DOORS on: " stringOf(today) "
"

	out << "Showing history of values for attributes: " 

	for attr in selectedAttributes do
	{
		if (doneOne)
		{
			out << ", "
		}

		out << attr ""

		doneOne = true
	}

	out << "\n"
}

/***********************************
	emitTableHeader
***********************************/
void emitTableHeader(Stream out, Skip selectedBaselines, string selectedIdentifier, Skip selectedAttributes)
{
	Baseline b = null
	string attr = ""

	out << "\n"

	out << "
\n"

	for b in selectedBaselines do
	{
		out << "" "Baseline " (major b) "." (minor b) (suffix b "" != "" ? " (" (suffix b) ")" : "") "\n"
	}

	out << "" "Current version"  "\n"

	out << "\n"

	out << "\n"

	out << "" selectedIdentifier "\n"

	for b in selectedBaselines do
	{
		for attr in selectedAttributes do
		{
			if (length(attr) > 8 && attr[0:7] == "DXL for ")
			{
				out << "" attr[8:] "\n"
			}
			else
			{
				out << "" attr "\n"
			}
		}
	}

	for attr in selectedAttributes do
	{
		if (length(attr) > 8 && attr[0:7] == "DXL for ")
		{
			out << "" attr[8:] "\n"
		}
		else
		{
			out << "" attr "\n"
		}
	}

	out << "\n"
}

/***********************************
	exportChangeHistory
***********************************/
string exportChangeHistory(Module m, Skip selectedBaselines, string selectedIdentifier, Skip selectedAttributes, string outputFile)
{
	string res = ""
	Module bm = null
	Baseline b = null
	Object o = null
	Object bo = null
	int absno = 0
	string s = ""
	string attr = ""
	AttrDef ad = null
	Skip baselineModules = create

	out = write(outputFile)

	if (null out)
	{
		return("failed to open file for writing: " outputFile "")
	}

	for b in selectedBaselines do
	{
		bm = load(m, b, false)

		put(baselineModules, (int key selectedBaselines), bm)
	}

	emitHeader(out)

	emitFileHeader(out, fullName(m), selectedAttributes)

	out << "\n"

	emitTableHeader(out, selectedBaselines, selectedIdentifier, selectedAttributes)

	for o in document m do
	{
		//if (isDeleted(o2)) continue
		if (table(o)) continue

			out << "\n"

			out << "\n"

			absno = o."Absolute Number"

			for bm in baselineModules do
			{
				for attr in selectedAttributes do
				{
					out << "\n"
				}
			}

			for attr in selectedAttributes do
			{
				out << "\n"
			}

			out << "\n"
	}

	out << "" getAttr(o, selectedIdentifier) " "

					bo = object(absno, bm)

					if (null bo)
					{
						out << "
"
					}
					else
					{
						out <<" " 

						if (probeAttr_(bo, attr) == "")
						{
							out << "
"
						}
						else
						{
							convertRichText(tempBuf, probeRichAttr_(bo, attr))
							out << tempBuf
						}

						out << "\n"
					}

					out << " "

				out <<" " 

				if (probeAttr_(o, attr) == "")
				{
					out << "
"
				}
				else
				{
					convertRichText(tempBuf, probeRichAttr_(o, attr))
					out << tempBuf
				}

				out << "\n"

				out << "\n"

	emitFooter(out)

	close(out)

	noError
	for bm in baselineModules do
	{
		close(bm)
	}
	lastError

	return("")
}

//<  Export Change History Dialog 

/*

	18-MAR-2011		Tony Goodman
*/

DB   dbMain   = null
DBE dbeLabel = null

DBE dbeFrame = null
DBE dbebaselinesFrame = null
DBE dbeBaselines = null

DBE dbeIdentifierFrame = null
DBE dbeAttributeFrame = null
DBE dbeIdentifier = null
DBE dbeAttributes = null

DBE dbeExportFrame = null
DBE dbeFileName  = null
DBE exportBtn    = null

string dummy[] = { }

Skip skipBaselines = create
Skip skipAttributes = createString

/***********************************
	getBaselines
***********************************/
void getBaselines(Module currMod)
{
	Baseline b = null
	int index = 0

	for b in currMod do
	{
		put(skipBaselines, index, b)

		insert(dbeBaselines, index, major(b) "." minor(b) " " suffix(b) " " annotation(b), iconNone)

		index++
	}

	put(skipBaselines, index, null)
	//insert(dbeBaselines, index, "Current", iconNone)

	if (index > 0)
	{
		set(dbeBaselines, index-1, true)
	}
	else
	{
		set(dbeBaselines, index, true)
	}
}

/***********************************
	getAttributes
***********************************/
void getAttributes(Module currMod)
{
	AttrDef ad = null
	string attr = ""
	int index = 0

	for ad in currMod do
	{
		if (!ad.object) continue

		put(skipAttributes, ad.name, ad.name)
	}

	insert(dbeIdentifier, 0, "Identifier", iconNone)

	index = 1

	for attr in skipAttributes do
	{
		insert(dbeIdentifier, index, attr, iconNone)
		insert(dbeAttributes, index, attr, iconNone)
		index++
	}

	set(dbeIdentifier, 0, true)
	set(dbeAttributes, 0, true)
}

/***********************************
	doExport
***********************************/
void doExport(DB db)
{
	Baseline b = null
	string selectedIdentifier = ""
	string selectedAttribute = null
	string outputFile = ""
	string res = ""
	string attr = ""
	int i = 0
	int j = 0
	Skip selectedBaselines = create
	Skip selectedAttributes = createString

	for (i = 0; i < noElems(dbeBaselines); i++)
	{
		if (getCheck(dbeBaselines, i))
		{
			find(skipBaselines, i, b)
			put(selectedBaselines, j++, b)
		}
	}

	selectedIdentifier = get(dbeIdentifier)

	for (i = 0; i < noElems(dbeAttributes); i++)
	{
		if (getCheck(dbeAttributes, i))
		{
			attr = getColumnValue(dbeAttributes, i, 0)
			put(selectedAttributes, attr, attr)
		}
	}
	//selectedAttribute = get(dbeAttributes)

	outputFile = get(dbeFileName)

	res = exportChangeHistory(current Module, selectedBaselines, selectedIdentifier, selectedAttributes, outputFile)

	if (res "" != "")
	{
		infoBox(res)
		return
	}
	else
	{
		infoBox("Export complete\nSee " outputFile)
	}

	release(dbMain)
}

/***********************************
	doClose
***********************************/
void doClose(DB db)
{
	release(dbMain)
}

/***********************************
	buildDialog
***********************************/
void buildDialog(Module currMod)
{
	dbMain = create(currMod, "Export Change History", styleCentered|styleFixed)

	dbeLabel = label(dbMain, "This utility exports change history for selected attributes to an HTML file.\n" //-
	                                   "The values of the selected attributes are shown in a separate columns for each baseline.")

	dbeFrame = frame(dbMain, "", 400, 450)
	dbeFrame->"top"->"flush"->dbeLabel
	dbeFrame->"left"->"form"
	dbeFrame->"right"->"form"
	dbeFrame->"bottom"->"form"

	dbeBaselinesFrame = frame(dbMain, "Baselines to include", 400, 100)
	dbeBaselinesFrame->"top"->"inside"->dbeFrame
	dbeBaselinesFrame->"left"->"inside"->dbeFrame
	dbeBaselinesFrame->"right"->"inside"->dbeFrame
	dbeBaselinesFrame->"bottom"->"unattached"

	dbeBaselines = listView(dbMain, listViewOptionCheckboxes | listViewOptionMultiselect, 390, 5, dummy)
	dbeBaselines->"top"->"inside"->dbeBaselinesFrame
	dbeBaselines->"left"->"inside"->dbeBaselinesFrame
	dbeBaselines->"right"->"inside"->dbeBaselinesFrame
	dbeBaselines->"bottom"->"inside"->dbeBaselinesFrame

	dbeIdentifierFrame = frame(dbMain, "Identifier for each object", 400, 100)
	dbeIdentifierFrame->"top"->"flush"->dbeBaselinesFrame
	dbeIdentifierFrame->"left"->"inside"->dbeFrame
	dbeIdentifierFrame->"right"->"inside"->dbeFrame
	dbeIdentifierFrame->"bottom"->"unattached"	

	dbeIdentifier = listView(dbMain, 0, 390, 5, dummy)
	dbeIdentifier->"top"->"inside"->dbeIdentifierFrame
	dbeIdentifier->"left"->"inside"->dbeIdentifierFrame
	dbeIdentifier->"right"->"inside"->dbeIdentifierFrame
	dbeIdentifier->"bottom"->"inside"->dbeIdentifierFrame

	dbeAttributeFrame = frame(dbMain, "Attributes to display", 400, 100)
	dbeAttributeFrame->"top"->"flush"->dbeIdentifierFrame
	dbeAttributeFrame->"left"->"inside"->dbeFrame
	dbeAttributeFrame->"right"->"inside"->dbeFrame
	dbeAttributeFrame->"bottom"->"unattached"

	dbeAttributes = listView(dbMain, listViewOptionCheckboxes | listViewOptionMultiselect, 390, 5, dummy)
	dbeAttributes->"top"->"inside"->dbeAttributeFrame
	dbeAttributes->"left"->"inside"->dbeAttributeFrame
	dbeAttributes->"right"->"inside"->dbeAttributeFrame
	dbeAttributes->"bottom"->"inside"->dbeAttributeFrame

	dbeFileName = fileName(dbMain, "Export to:", "U:\\" name(currMod) "_history.html", "*.html", "HTML Files", false)
	dbeFileName->"top"->"flush"->dbeAttributeFrame
	dbeFileName->"left"->"inside"->dbeFrame
	dbeFileName->"right"->"unattached"
	dbeFileName->"bottom"->"inside"->dbeFrame

	exportBtn = apply(dbMain, "Export", doExport)

	realize(dbMain)

	insertColumn(dbeBaselines, 0, "Baselines", 350, iconNone)

	insertColumn(dbeIdentifier, 0, "Identifier", 350, iconNone)
	insertColumn(dbeAttributes, 0, "Attributes", 350, iconNone)

	getBaselines(currMod)

	getAttributes(currMod)

	block(dbMain)
	destroy(dbMain)
	dbMain = null
}

/***********************************
	exportChangeHistory
***********************************/
void exportChangeHistory()
{
	Module currMod = null

	currMod = current Module

	if (null currMod)
	{
		infoBox("This utility can only be run from a formal module.")
		return
	}

	buildDialog(currMod)
}

exportChangeHistory()

Export Baseline Comparison Report

Tony Goodman — Thu, 23 Jun 2011 13:29:59 +0000

This script allows you to export a baseline comparison report to an HTML file.

The dialog allows you to select the baselines to compare, and which attributes to include in the comparison.

//

/*

*/

//  Export Baseline Comparison Report

/*

	The values for each selected attribute are compared and included in the report if they
	differ. The export contains a row for each attribute change made between the selected
	baselines. Attributes that do not exist in the older baseline are identified at the top of
	the report. New and deleted objects are identified in the right-hand column.

	Inclusion of tables cells is optional.
	New and deleted cells objcts are identified, but deleted rows are not.

	Change History
	-----------------

	24-MAY-2011		Tony Goodman	Standalone version.

*/

pragma runLim, 0

string OUTPUT_FOLDER = "U:\\"

/**********************************
	Smart DXL logo bitmap file - this is loaded once when first dialog is displayed.
**********************************/
Bitmap smartDxlLogo = null

string SMART_DXL_DB_TITLE      = "Smart DXL"
string SMART_DXL_BANNER_WEBSITE  = "www.smartdxl.com"
string SMART_DXL_BANNER_BITMAP    = "lac\\inc\\tophat.bmp"

DBE smartDxlBanner = null

bool smartDxlLogoFound = false

string smartDxlBannerText = ""

int   smartDxlLogoWidth   = 0
int   smartDxlLogoHeight  = 0

/**********************************
	getAbsolutePath
**********************************/
string getAbsolutePath(string sFileName)
{
	string sResult  = ""

	string sAddinsPathList      = (getenv "ADDINS") ";"
	string sDoorsAddinsPathList = (getenv "DOORSADDINS") ";"

	if (sAddinsPathList != sDoorsAddinsPathList)
	{
		sAddinsPathList = sDoorsAddinsPathList ";" sAddinsPathList
	}

	Regexp rPath = regexp "([^;]*);(.*)"

	string sLeft    = ""
	string sRight   = ""

	if (rPath sAddinsPathList)
	{
		// test each path in the semicolon separated list
		while (rPath sAddinsPathList)
		{
			  sLeft  = sAddinsPathList[match 1]
			  sRight = sAddinsPathList[match 2]

			  if (fileExists_ (sLeft "\\" sFileName))
			  {
					sResult  = sLeft "\\" sFileName
					break;
			  }
			  else
			  {
					sAddinsPathList = sRight
			  }
		}
	}
	return(sResult)
}

/***********************************
  smartDrawLogo
***********************************/
void smartDrawLogo(DBE cnvs)
{
	string smartDxlBitmapFile = ""
	Stat   st = null

	if (null smartDxlLogo)
	{
		// bitmap has not been loaded yet, so load it
		smartDxlBitmapFile = getAbsolutePath(SMART_DXL_BANNER_BITMAP)

		// check that the file exists
		st = create(smartDxlBitmapFile)

		if (!null st)
		{
			// file does exist so we can load the bitmap
			delete(st)

			smartDxlLogo = loadBitmap(cnvs, smartDxlBitmapFile, false, smartDxlLogoWidth, smartDxlLogoHeight)
		}
    }

    // draw the bitmap if it was successfully loaded
    if (!null smartDxlLogo)
    {
    	drawBitmap(cnvs, smartDxlLogo, 0, 0)
		smartDxlLogoFound = true
	}
}

/**********************************
	doLogoMouse
**********************************/
void doLogoMouse(DBE cnv, int but, bool ctrl, int x, int y)
{
	if (x > width(cnv) - width(cnv, SMART_DXL_BANNER_WEBSITE) - 5)
	{
		activateURL(SMART_DXL_BANNER_WEBSITE)
	}
}

/**********************************
	doRepaintSmartDxlBanner
**********************************/
void doRepaintSmartDxlBanner(DBE cnv)
{
	int canvasWidth  = width(cnv)
	int titleHeight  = 0
	int y = 0

	realBackground(cnv, realColor_White)

	smartDrawLogo(cnv)

	realColor(cnv, realColor_Black)
	font(cnv, 4, HeadingsFont)

	y = (height(cnv) / 2) + (height(cnv, smartDxlBannerText) / 2) - 3

	draw(cnv, smartDxlLogoWidth + 3, y, smartDxlBannerText)

	realColor(cnv, realColor_Blue)
	font(cnv, 9, HeadingsFont)
	draw(cnv, canvasWidth - width(cnv, SMART_DXL_BANNER_WEBSITE) - 5, y - 1, SMART_DXL_BANNER_WEBSITE)
	line(cnv, canvasWidth - width(cnv, SMART_DXL_BANNER_WEBSITE) - 5, y, canvasWidth - 5, y)
}

/**********************************
	addSmartDxlBanner
**********************************/
void addSmartDxlBanner(DB db)
{
	smartDxlBanner = canvas(db, 0, 32, doRepaintSmartDxlBanner)

	set(smartDxlBanner, doLogoMouse)
}

/**********************************
	showHelp
**********************************/
void showHelp(string helpFile)
{
	system("\"C:\\Program Files\\Internet Explorer\\iexplore.exe\" -nohome \"" (getAbsolutePath(helpFile)) "\"")
}

/**********************************
	smartDialog
**********************************/
DB smartDialog(Module mParent, string banner, int options)
{
	DB smartDb = null

	smartDb = create(mParent, SMART_DXL_DB_TITLE, options)

	smartDxlBannerText = banner

	addSmartDxlBanner(smartDb)

    return(smartDb)
}

//<  Export Change Report to HTML

/*
	18-MAR-2011		Tony Goodman
*/

Buffer textBuf2 = create
Buffer tempBuf = create

Buffer bSource = create
Buffer bTarget = create
Buffer bResult = create

/**********************************
	getRedLineMarkup
**********************************/
void getRedLineMarkup()
{
	setempty(bResult)

	diff(bResult, bSource, bTarget)
}

/**********************************
	emitHeader
**********************************/
void emitHeader(Stream out)
{
	out << "\n"
	out << "\n"
	out << "\n"

	out << "\n"
	out << "\n"
	out << "\n"
}

/**********************************
	emitFooter
**********************************/
void emitFooter(Stream out)
{
	out << "\n"
	out << "\n"
	out << "\n"
}

/**********************************
	convertRichText
**********************************/
void convertRichText(Buffer& b, string s)
{
	RichTextParagraph rp = null
    RichText rt = null
    bool limitText = false
	int ind = 0
	int i = 0

    setempty(b)

	for rp in s do
	{
		ind = rp.indentLevel

		for (i = 0; i < ind; i += 360) b += ""

		if (rp.isBullet) b += ""

		for rt in rp do
		{
			setempty(textBuf2)
			textBuf2 += rt.text

			safeHTMLBuffer(textBuf2, true, true)

			if (rt.bold) b += ""

			if (rt.underline)
			{
				b += ""
				b += ""
			}

			if (rt.italic) b += ""

			if (rt.strikethru)
			{
				b += ""
				b += ""
			}

			if (rt.superscript) b += "^{"
			if (rt.subscript) b += "_{"
			if (rt.charset == charsetSymbol) b += ""

			b += textBuf2

			if (rt.charset == charsetSymbol) b += ""
			if (rt.subscript) b += "}"
			if (rt.superscript) b += "}"
			if (rt.strikethru)
			{
				b += ""
				b += ""
			}

			if (rt.italic) b += ""
			if (rt.underline)
			{
				b += ""
				b += ""
			}

			if (rt.bold) b += ""

			if (rt.newline) b += "
"
		}

		if (rp.isBullet) b += ""

		for (i = 0; i < ind; i += 360) b += ""
	}
}

/**********************************
	emitFileHeader
**********************************/
void emitFileHeader(Stream out, string moduleName, Skip newAttributes, bool newAttrs)
{
	string attr = ""

	out << "\n"

	// header row
	out << "\n"
	out << "\n"
	out << "\n"

	if (newAttrs)
	{
		out << "\n"
		out << "\n"
		out << "\n"
	}

	out << "\n"

	out << "Baseline Comparison Report"
	out << "Module: " moduleName "
"
	out << "Exported from DOORS on: " stringOf(today) "
"

	out << "
\n"
		out << "The following attributes are new since the older baseline, so have not been compared:
"

		for attr in newAttributes do
		{
			out << attr "
"
		}

		out << "\n"
}

/**********************************
	emitTableHeader
**********************************/
void emitTableHeader(Stream out, string ver1, string ver2)
{
	out << "\n"

	out << "" "Object ID" "\n"
	out << "" "Change" "\n"
	out << "" ver1 "\n"
	out << "" ver2 "\n"

	out << "\n"
}

/**********************************
	emitNewObject
**********************************/
void emitNewObject(Stream out, Object o)
{
	// new object
	out << "\n"

	out << "" identifier(o) "\n"

	out << "NEW OBJECT\n"

	out << "
"

	out << ""

	if (o."Object Heading" "" != "")
	{
		out << ""
		out << ""
		out << "" number(o) " " o."Object Heading" "
"
		out << ""
		out << ""
	}

	convertRichText(tempBuf, probeRichAttr_(o, "Object Text"))
	out << ""
	out << ""
	out <<  tempBuf

	if (o."Object Heading" "" == "" && o."Object Text" "" == "")
	{
		out << "
"
	}

	out << ""
	out << ""

	out << "\n"
	out << "\n"
}

/**********************************
	emitDeletedObject
**********************************/
void emitDeletedObject(Stream out, Object o)
{
	out << "\n"

	out << "" identifier(o) "\n"

	out << "OBJECT DELETED\n"

	out << ""

	if (o."Object Heading" "" != "")
	{
		out << "" number(o) " " o."Object Heading" "
"
	}

	convertRichText(tempBuf, probeRichAttr_(o, "Object Text"))
	out <<  tempBuf

	if (o."Object Heading" "" == "" && o."Object Text" "" == "")
	{
		out << "
"
	}

	out << "\n"

	out << "
"

	out << "\n"
}

/**********************************
	emitChangedObject
**********************************/
void emitChangedObject(Stream out, Object o1, Object o2, string attr)
{
	out << "\n"

	out << "" identifier(o2) "\n"

	out << "Attribute "" attr "" Changed"

	out << ""

	if (o1.attr "" == "")
	{
		out << "
"
	}
	else
	{
		convertRichText(tempBuf, probeRichAttr_(o1, attr))
		out <<  tempBuf
	}
	out << "\n"

	out << ""

	if (o2.attr "" == "")
	{
		out << "
"
	}
	else
	{
		setempty(bSource)
		setempty(bTarget)

		bSource += o1.attr ""
		bTarget += o2.attr ""
		getRedLineMarkup()
		convertRichText(tempBuf, stringOf(bResult))
		//convertRichText(tempBuf, probeRichAttr_(o2, attr))
		out <<  tempBuf
	}

	out << "\n"

	out << "\n"
}

/**********************************
	compareTableCells
**********************************/
void compareTableCells(Stream out, Module bm1, Skip selectedAttributes, Object oTable)
{
	int absno = 0
	Object oRow = null
	Object o2 = null
	Object o1 = null
	string attr = ""

	for oRow in table(oTable) do
	{
		if (isDeleted oRow) continue

		for o2 in row(oRow) do
		{
			if (isDeleted o2) continue

			absno = o2."Absolute Number"

			o1 = object(absno, bm1)

			if (null o1)
			{
				emitNewObject(out, o2)
				continue
			}

			for attr in selectedAttributes do
			{
				if (o1.attr "" == o2.attr "") continue

				emitChangedObject(out, o1, o2, attr)
			}
		}
	}
}

/**********************************
	checkDeletedCells
**********************************/
void checkDeletedCells(Stream out, Module bm2, Object oTable)
{
	int absno = 0
	Object oRow = null
	Object o2 = null
	Object o1 = null

	for oRow in table(oTable) do
	{
		if (isDeleted oRow) continue

		for o1 in row(oRow) do
		{
			if (isDeleted o1) continue

			absno = o1."Absolute Number"

			o2 = object(absno, bm2)

			if (null o2)
			{
				emitDeletedObject(out, o1)
				continue
			}
		}
	}
}

/**********************************
	exportChangeReport
**********************************/
string exportChangeReport(Module m, Baseline b1, Baseline b2, Skip selectedAttributes, bool includeTableCells, string outputFile)
{
	string res = ""
	Module bm1 = null
	Module bm2 = null
	Object o1 = null
	Object o2 = null
	int absno = 0
	string s = ""
	AttrDef ad = null
	string ver1 = ""
	string ver2 = ""
	string attr = ""
	bool newAttrs = false

	Skip newAttributes = createString

	out = write(outputFile)

	if (null out)
	{
		return("failed to open file for writing: " outputFile "")
	}

	if (null b1)
	{
		bm1 = m
		ver1 = "Current Version"
	}
	else
	{
		bm1 = load(m, b1, true)
		ver1 = "Baseline " (major b1) "." (minor b1) (suffix b1 "" != "" ? " (" (suffix b1) ")" : "")
	}

	if (null bm1)
	{
		return(ver1 " not found for module")
	}

	if (null b2)
	{
		bm2 = m
		ver2 = "Current Version"
	}
	else
	{
		bm2 = load(m, b2, true)
		ver2 = "Baseline " (major b2) "." (minor b2) (suffix b2 "" != "" ? " (" (suffix b2) ")" : "")
	}

	if (null bm2)
	{
		return(ver2 " not found for module.")
	}

	// check for attributes that do not exist in the first baseline
	for attr in selectedAttributes do
	{
		ad = find(bm1, attr)

		if (null ad)
		{
			put(newAttributes, attr, attr)
			newAttrs = true
		}
	}

	for attr in newAttributes do
	{
		if (find(selectedAttributes, attr))
		{
			delete(selectedAttributes, attr)
		}
	}

	emitHeader(out)

	emitFileHeader(out, fullName(m), newAttributes, newAttrs)

	out << "\n"

	emitTableHeader(out, ver1, ver2)

	for o2 in document(bm2) do
	{
		if (isDeleted(o2))
		{
			continue
		}

		if (table(o2))
		{
			if (includeTableCells)
			{
				compareTableCells(out, bm1, selectedAttributes, o2)
			}
		}
		else
		{
			// find this object in the older baseline
			absno = o2."Absolute Number"

			o1 = object(absno, bm1)

			if (null o1)
			{
				emitNewObject(out, o2)
				continue
			}

			for attr in selectedAttributes do
			{
				if (o1.attr "" == o2.attr "") continue

				emitChangedObject(out, o1, o2, attr)
			}
		}
	}

	// Deleted Objects
	for o1 in document(bm1) do
	{
		if (isDeleted(o1)) continue

		if (table(o1))
		{
			if (includeTableCells)
			{
				checkDeletedCells(out, bm2, o1)
			}
		}
		else
		{
			// find this object in the older baseline
			absno = o1."Absolute Number"

			o2 = object(absno, bm2)

			if (null o2)
			{
				emitDeletedObject(out, o1)
			}
		}
	}

	out << "\n"

	emitFooter(out)

	close(out)

	noError
	close(bm1)

	if (bm2 != m)
	{
		close(bm2)
	}

	lastError

	return("")
}

//<  Export Change Report Dialog 

/*

	18-MAR-2011		Tony Goodman
*/

DB   dbMain   = null
DBE dbeLabel = null

DBE dbeFrame = null
DBE dbebaselinesFrame = null
DBE dbeBaseline1 = null
DBE dbeBaseline2 = null

DBE dbeAttributesFrame = null
DBE dbeAttributes = null
DBE dbeSelectAll = null
DBE dbeClearAll = null

DBE dbeIncludeTableCells = null
DBE dbeExportFrame = null
DBE dbeFileName  = null
DBE exportBtn    = null

string dummy[] = { }

Skip skipBaselines = create
Skip skipAttributes = createString

/**********************************
	getBaselines
**********************************/
void getBaselines(Module currMod)
{
	Baseline b = null
	int index = 0

	for b in currMod do
	{
		put(skipBaselines, index, b)

		insert(dbeBaseline1, index, major(b) "." minor(b) " " suffix(b), iconNone)

		insert(dbeBaseline2, index, major(b) "." minor(b) " " suffix(b), iconNone)

		index++
	}

	put(skipBaselines, index, null)
	insert(dbeBaseline1, index, "Current", iconNone)
	insert(dbeBaseline2, index, "Current", iconNone)

	if (index > 0)
	{
		set(dbeBaseline1, index-1, true)
	}
	else
	{
		set(dbeBaseline1, index, true)
	}

	set(dbeBaseline2, index, true)
}

/**********************************
	getAttributes
**********************************/
void getAttributes(Module currMod)
{
	AttrDef ad = null
	string attr = ""
	int index = 0

	for ad in currMod do
	{
		if (!ad.object) continue

		if (ad.system) continue

		put(skipAttributes, ad.name, ad.name)
	}

	put(skipAttributes, "Object Text", "Object Text")
	put(skipAttributes, "Object Heading", "Object Heading")

	for attr in skipAttributes do
	{
		insert(dbeAttributes, index, attr, iconNone)

		if (attr == "Object Heading" || attr == "Object Text")
		{
			setCheck(dbeAttributes, index, true)
		}
		index++
	}
}

/**********************************
	doExport
**********************************/
void doExport(DB db)
{
	Baseline b1 = null
	Baseline b2 = null
	string attr = ""
	string outputFile = ""
	string res = ""
	int i = 0
	bool includeTableCells = false

	Skip selectedAttributes = createString

	includeTableCells = get(dbeIncludeTableCells)

	i = get(dbeBaseline1)
	find(skipBaselines, i, b1)

	i = get(dbeBaseline2)
	find(skipBaselines, i, b2)

	if (b1 == b2)
	{
		infoBox("Please select two different baselines")
		return
	}

	for (i = 0; i < noElems(dbeAttributes); i++)
	{
		if (getCheck(dbeAttributes, i))
		{
			attr = getColumnValue(dbeAttributes, i, 0)
			put(selectedAttributes, attr, attr)
		}
	}

	outputFile = get(dbeFileName)

	res = exportChangeReport(current Module, b1, b2, selectedAttributes, includeTableCells, outputFile)

	if (res "" != "")
	{
		infoBox(res)
		return
	}

	infoBox("Report complete. See " outputFile)

	release(dbMain)
}

/**********************************
	doSelectAll
**********************************/
void doSelectAll(DBE dbe)
{
	int i = 0

	for (i = 0; i < noElems(dbeAttributes); i++)
	{
		setCheck(dbeAttributes, i, true)
	}
}

/**********************************
	doClearAll
**********************************/
void doClearAll(DBE dbe)
{
	int i = 0

	for (i = 0; i < noElems(dbeAttributes); i++)
	{
		setCheck(dbeAttributes, i, false)
	}
}

/**********************************
	doClose
**********************************/
void doClose(DB db)
{
	release(dbMain)
}

/**********************************
	doHelp
**********************************/
void doHelp(DB db)
{
	showHelp("SmartDXL/export/exportBaselineComparison.mht")
} 

/**********************************
	buildDialog
**********************************/
void buildDialog(Module currMod)
{
	dbMain = smartDialog(currMod, "Export Baseline Comparison", styleCentered|styleFixed)

	dbeLabel = label(dbMain, "This utility exports a baseline comparison report to an HTML file.")

	dbeFrame = frame(dbMain, "", 400, 450)
	dbeFrame->"top"->"flush"->dbeLabel
	dbeFrame->"left"->"form"
	dbeFrame->"right"->"form"
	dbeFrame->"bottom"->"form"

	dbeBaselinesFrame = frame(dbMain, "Baselines to compare", 400, 100)
	dbeBaselinesFrame->"top"->"inside"->dbeFrame
	dbeBaselinesFrame->"left"->"inside"->dbeFrame
	dbeBaselinesFrame->"right"->"inside"->dbeFrame
	dbeBaselinesFrame->"bottom"->"unattached"

	dbeBaseline1 = listView(dbMain, 0, 190, 5, dummy)
	dbeBaseline1->"top"->"inside"->dbeBaselinesFrame
	dbeBaseline1->"left"->"inside"->dbeBaselinesFrame
	dbeBaseline1->"right"->"unattached"
	dbeBaseline1->"bottom"->"inside"->dbeBaselinesFrame

	dbeBaseline2 = listView(dbMain, 0, 190, 5, dummy)
	dbeBaseline2->"top"->"inside"->dbeBaselinesFrame
	dbeBaseline2->"left"->"flush"->dbeBaseline1
	dbeBaseline2->"right"->"inside"->dbeBaselinesFrame
	dbeBaseline2->"bottom"->"inside"->dbeBaselinesFrame

	dbeAttributesFrame = frame(dbMain, "Attributes to compare", 400, 100)
	dbeAttributesFrame->"top"->"flush"->dbeBaselinesFrame
	dbeAttributesFrame->"left"->"inside"->dbeFrame
	dbeAttributesFrame->"right"->"inside"->dbeFrame
	dbeAttributesFrame->"bottom"->"unattached"	

	dbeAttributes = listView(dbMain, listViewOptionCheckboxes | listViewOptionMultiselect, 190, 5, dummy)
	dbeAttributes->"top"->"inside"->dbeAttributesFrame
	dbeAttributes->"left"->"inside"->dbeAttributesFrame
	dbeAttributes->"right"->"inside"->dbeAttributesFrame
	dbeAttributes->"bottom"->"inside"->dbeAttributesFrame

	dbeSelectAll = button(dbMain, "Select All", doSelectAll)
	dbeSelectAll->"top"->"flush"->dbeAttributes
	dbeSelectAll->"left"->"inside"->dbeAttributesFrame
	dbeSelectAll->"right"->"unattached"
	dbeSelectAll->"bottom"->"unattached"

	dbeClearAll = button(dbMain, "Clear All", doClearAll)
	dbeClearAll->"top"->"flush"->dbeAttributes
	dbeClearAll->"left"->"flush"->dbeSelectAll
	dbeClearAll->"right"->"unattached"
	dbeClearAll->"bottom"->"inside"->dbeAttributesFrame

	dbeExportFrame = frame(dbMain, "Export options", 400, 50)
	dbeExportFrame->"top"->"flush"->dbeAttributesFrame
	dbeExportFrame->"left"->"inside"->dbeFrame
	dbeExportFrame->"right"->"inside"->dbeFrame
	dbeExportFrame->"bottom"->"inside"->dbeFrame

	dbeIncludeTableCells = toggle(dbMain, "Include Table Cells", false)
	dbeIncludeTableCells->"top"->"inside"->dbeExportFrame
	dbeIncludeTableCells->"left"->"inside"->dbeExportFrame
	dbeIncludeTableCells->"right"->"unattached"
	dbeIncludeTableCells->"bottom"->"unattached"

	dbeFileName = fileName(dbMain, "Export to:", OUTPUT_FOLDER name(currMod) "_baseline_comparison.html", "*.html", "HTML Files", false)
	dbeFileName->"top"->"flush"->dbeIncludeTableCells
	dbeFileName->"left"->"inside"->dbeExportFrame
	dbeFileName->"right"->"unattached"
	dbeFileName->"bottom"->"inside"->dbeExportFrame

	exportBtn = apply(dbMain, "Export", doExport)
	apply(dbMain, "Help", doHelp)

	realize(dbMain)

	insertColumn(dbeBaseline1, 0, "Older Baseline", 160, iconNone)
	insertColumn(dbeBaseline2, 0, "Newer Baseline", 160, iconNone)

	insertColumn(dbeAttributes, 0, " ", 160, iconNone)

	getBaselines(currMod)

	getAttributes(currMod)

	block(dbMain)
	destroy(dbMain)
	dbMain = null
}

/**********************************
	exportBaselineComparison
**********************************/
void exportBaselineComparison()
{
	Module currMod = null

	currMod = current Module

	if (null currMod)
	{
		infoBox("This utility can only be run from a formal module.")
		return
	}

	buildDialog(currMod)
}

exportBaselineComparison()

Find Public Views

Tony Goodman — Thu, 23 Jun 2011 13:18:18 +0000

Public views are a menace. They clutter up the drop down view list and can only be deleted by the owner or the Adminsitrator. This script demonstrates how you can identify public views.

Public views can be identified by looking at thier access records. They will have exactly two access records, one will be RMCDA for the view owner, and the other will be read-only for everyone else.

This example checks modules in the current folder and gives you the option to send an email to the owners asking that they make their views private.

// List Public Views

/*
	Lists public views found in modules.

	Reports public views found in modules together with the owner
	and their email address.

	24-MAY-2011		Tony Goodman
*/

pragma runLim, 0

string ccEmail = "yourname@yourdomain.com"

string MESSAGE = "Dear DOORS User,

This \"Public View\" is owned by you. Public views are reserved for project/department-wide purposes and should only be created following agreement with the Requirements Manager. Please can you change the view to a \"Private View\" as soon as possible. This will not impact the view contents in any way, but will mean that only you can see the view.
We need to take this disciplined approach as too many views clutter up the DOORS module and can cause confusion. Unfortunately DOORS defaults new views to public views and this cannot be re-configured, so whenever you create a new view please remember to set it to a private view.

To make a view private:

1. open the module
2. select Views > Manage Views...
3. select the view in the list
4. open the Access tab
5. select Everyone else
6. click on Edit..
7. select None
8. click OK
9. click OK

Many thanks.

Your Name

"

DB  dbMain      = null
DBE dbeResults  = null
DBE dbeSendEmails = null
DBE dbeMessage = null

Buffer buf = create

bool sendEmails = false

targetAddresses = createString
ccAddresses = createString

User u = find()
string myEmail = u.email

/*********************************
	getAccessRecord
*********************************/
string getAccessRecord(AccessRec ar)
{
	string r = ((read ar)    ? "R" : "")
	string m = ((modify ar)  ? "M" : "")
	string c = ((create ar)  ? "C" : "")
	string d = ((delete ar)  ? "D" : "")
	string a = ((control ar) ? "A" : "")

	string accessStr =  r m c d a ""

	if (null accessStr)
	{
		accessStr = "None"
	}

	return(accessStr)
}

/*********************************
	isPublic
*********************************/
bool isPublic(View v, string &uName, string &uEmail)
{
	AccessRec ar = null
	User u = null
	int count = 0
	bool def = false

	for ar in v do
	{
		count++
	}

	if (count == 2)
	{
		for ar in v do
		{
			if (getAccessRecord(ar) == "R")
			{
				def = true
			}
			else if (getAccessRecord(ar) == "RMCDA")
			{
				uName = username ar

				if (uName "" != "")
				{
					u = find(uName)
				}

				if (!null u)
				{
					uEmail = u.email
				}
			}
		}

		return(def && !null u)
	}

	return(false)
}

/*********************************
	getPublicViews
*********************************/
void getPublicViews(string mName, Buffer resBuf)
{
	Module m = null
	string vn = ""
	string uName = ""
	string uEmail = ""
	string res = ""
	string msg = ""
	bool noneFound = true

	m = read(mName, false)

	if (null m)
	{
		resBuf += "ERROR: Failed to open module " mName ".\n"
		return
	}

	(current ModuleRef__) = m

	for vn in views m do
	{
		if (isPublic(view vn, uName, uEmail))
		{
			if (sendEmails)
			{
				if (uEmail "" != "")
				{
					delete(targetAddresses)
					targetAddresses = createString
					put(targetAddresses, uEmail, uEmail)
					delete(ccAddresses)
					ccAddresses = createString
					put(ccAddresses, ccEmail, ccEmail)

					res = sendEMailMessage(myEmail, targetAddresses, ccAddresses, "Public View \"" vn "\" in DOORS module " name(m), MESSAGE)

					if (res "" == "")
					{
						msg = "An Email has been sent to " uEmail ""
					}
					else
					{
						msg = "Error sending email to " uEmail "." res
					}
				}
				else
				{
					msg = "Could not send Email - Email address unknown!"
				}
			}
			else
			{
				msg = uEmail
			}

			resBuf += name(m) " has public view \"" vn "\" owned by " uName " (" msg ").\n"
			noneFound = false
		}
	}

	if (noneFound)
	{
		resBuf += name(m) " does not have any public views.\n"
	}

	close(m)
}

/*********************************
	doRun
*********************************/
void doRun(DB db)
{
	Item i
	setempty(buf)
	int pCount = 0
	int pLimit = 0

	for i in current Folder do
	{
		if (type(i) != "Formal") continue

		pLimit++
	}

	if (pLimit == 0)
	{
		buf += "No modules found.\n"
	}
	else
	{
		//buf += pLimit " modules found.\n"

		if (!confirm("You are about to search for public views in " pLimit " modules\nAre you sure you want to continue?"))
		{
			buf += "Command aborted by user.\n"
		}
		else
		{
			progressStart(dbMain, "Checking modules", "Checking modules", pLimit)

			for i in current Folder do
			{
				if (type(i) != "Formal") continue

				pCount++
				progressRange("Checking module " pCount " of " pLimit ".", pCount, pLimit)

				getPublicViews(fullName(i), buf)
			}

			progressStop()
		}
	}

	set(dbeResults, buf)
}

/*********************************
	toggleEmails
*********************************/
void toggleEmails(DBE dbe)
{
	sendEmails = get(dbeSendEmails)

	if (sendEmails)
	{
		active(dbeMessage)
	}
	else
	{
		inactive(dbeMessage)
	}
}

/*********************************
	listPublicViews
*********************************/
void listPublicViews()
{
	dbMain = create(dbExplorer, "List Public Views", styleCentered|styleFloating)

	label(dbMain, "This utility allows you identify public views, and their owners, contained in modules below the current folder.")

	field(dbMain, "Folder:", fullName(current Folder), 50, true)

	dbeSendEmails = toggle(dbMain, "Send Emails to View Owners", sendEmails)

	dbeMessage = text(dbMain, "Message:", MESSAGE, 600, 100, false)

	dbeResults = text(dbMain, "Results:", "", 600, 150, true)

	apply(dbMain, "Run", doRun)

	realize(dbMain)

	set(dbeSendEmails, toggleEmails)
	inactive(dbeMessage)

	show(dbMain)
}

/*********************************
	MAIN
*********************************/
listPublicViews()

Email Selected Objects

Tony Goodman — Thu, 23 Jun 2011 10:44:18 +0000

This script allows you to send selected objects or the current view by email. The view is included in the email body as an HTML table.

The following options allow you to send the current object, selected objects or the current view.

emailRequirements(current Module, SELECTION)

emailRequirements(current Module, OBJECT)

emailRequirements(current Module, VIEW)

The following code should be saved in a file and #included before calling one of the above options.

//  Email selected objects or view

/*
	02-MAR-2011		Tony Goodman	Initial Version
*/

pragma runLim, 0

int VIEW      = 0
int OBJECT    = 1
int SELECTION = 2

Buffer tb2 = create

/*************************************
	makeEmail
*************************************/
void makeEmail(string subject, Buffer htmlBuffer)
{
	string      res        = null
	OleAutoObj  objOutlook = null
	OleAutoObj  objItem    = null
	OleAutoArgs args       = create

	objOutlook = oleCreateAutoObject("Outlook.Application")

	if (null objOutlook)
	{
		return
	}

    	clear args

	if (!null objItem)
	{
		oleCloseAutoObject(objItem)
	}

    	put(args, 0)

    	res = oleMethod(objOutlook, "CreateItem", args, objItem)

    	if (null objItem)
	{
		ack "Failed to create item"
		return
    	}

   	res = olePut(objItem,"HTMLBody", stringOf(htmlBuffer))

    	res = olePut(objItem, "Subject", subject)

    	res = oleMethod(objItem, "Display")

	if (!null objOutlook)
	{
		oleCloseAutoObject(objOutlook)
	}

}

/*************************************
	escapeQuotes
*************************************/
void escapeQuotes(Buffer buf, Buffer &bTemp) {
	int i = 0

	setempty(bTemp)

	for (i = 0; i < length(buf); i++)
	{
		if (buf[i] == '"')
		{
			bTemp += '"' ""
		}

		bTemp += buf[i] ""
	}
}

/*************************************
	escapeBrackets
*************************************/
void escapeBrackets(string s, Buffer &bTemp) {
	int i = 0

	setempty(bTemp)

	for (i = 0; i < length(s); i++)
	{
		if (s[i] == '<')
		{
			bTemp += "<"
		}
		else if (s[i] == '>')
		{
			bTemp += ">"
		}
		else
		{
			bTemp += s[i] ""
		}
	}
}

/*************************************
	convertRichText
*************************************/
void convertRichText(Buffer& b, string s, int& len, int max)
{
	RichTextParagraph rp = null
    RichText rt = null
    bool     limitText = false
	int ind = 0
	int i = 0

    if (!null len && !null max)
        limitText = true
    else
        limitText = false

    if (limitText && len >= max)
        return

    setempty b

	for rp in s do
	{
		ind = rp.indentLevel

		for (i = 0; i < ind; i += 360)
		{
				b += ""
		}

		if (rp.isBullet)
		{
			b += ""
		}

    for rt in rp do {
        if (limitText && len >= max)
            break
        setempty tb2
        tb2 += rt.text
        if (limitText)
           // truncateBuffer(tb2, len, max)
        safeHTMLBuffer(tb2, true, true)

        if (rt.bold)
            b += ""
        if (rt.underline)
            b += ""
        if (rt.italic)
            b += ""
        if (rt.strikethru)
            b += ""
        if (rt.superscript)
            b += "^{"
        if (rt.subscript)
            b += "_{"
        if (rt.charset == charsetSymbol)
            b += ""

        b += tb2

        if (rt.charset == charsetSymbol)
            b += ""
        if (rt.subscript)
            b += "}"
        if (rt.superscript)
            b += "}"
        if (rt.strikethru)
            b += ""
        if (rt.italic)
            b += ""
        if (rt.underline)
            b += ""
        if (rt.bold)
            b += ""

		if (rt.newline)
            b += "
"
    }

	if (rp.isBullet)
	{
		b += ""
	}

	for (i = 0; i < ind; i += 360)
	{
			b += ""
	}
}

}

/*************************************
	emitHeader
*************************************/
void emitHeader(Buffer htmlBuffer)
{
	htmlBuffer += "\n"
	htmlBuffer += "\n"
	htmlBuffer += "\n"

	htmlBuffer += "\n"
	htmlBuffer += "\n"
	htmlBuffer += "\n"
}

/*************************************
	emitFooter
*************************************/
void emitFooter(Buffer htmlBuffer)
{
	htmlBuffer += "\n"
	htmlBuffer += "\n"
	htmlBuffer += "\n"
}

/*************************************
	emitTableObject
*************************************/
void emitTableObject(Object oTable, int scope, Buffer htmlBuffer)
{
	Buffer tempBuf = create
	string s = ""
	Object oRow = null
	Object oCell = null
	bool 	tableCellsAreVisible = false
	bool tableCellsAreSelected = false

	if (isVisible(oTable))
	{
		if (scope == SELECTION)
		{
			if (!isSelected(oTable))
			{
				return
			}
		}

		htmlBuffer += ">> Table\n"
		return
	}

	for oRow in oTable do
	{
		for oCell in oRow do
		{
			if (isVisible(oCell))
			{
				tableCellsAreVisible = true

				if (isSelected(oCell))
				{
					tableCellsAreSelected = true
				}
			}
		}
	}

	if (!tableCellsAreVisible) return

	if (scope == SELECTION && !tableCellsAreSelected)
	{
		return
	}

	htmlBuffer += "\n"

	htmlBuffer += "\n"

	htmlBuffer += "\n"

	htmlBuffer += "\n"

	for oRow in oTable do
	{
		htmlBuffer += "\n"

		for oCell in oRow do
		{
			if (!isVisible(oCell))
			{
				continue
			}

			htmlBuffer += "\n"
		}

		htmlBuffer += "\n"
	}

	htmlBuffer += "\n"
			htmlBuffer += " "
			convertRichText(tempBuf, richText(oCell."Object Text"), i, null)
			htmlBuffer += tempBuf
			htmlBuffer += "\n"
			htmlBuffer += ""

	htmlBuffer += "\n"

	htmlBuffer += "\n"

	delete(tempBuf)
	tempBuf = null
}

/*************************************
	emitView
*************************************/
string emitView(Module m, int scope, Buffer htmlBuffer)
{
	string res          = ""
	Object o            = null
	Object currObj      = null
	Column c            = null
	real   w            = 0.0
	real   myWidth = 0.0
	Buffer tempBuf = create
	int i = 0

	emitHeader(htmlBuffer)

	currObj = current Object

	htmlBuffer += "\n"

	// header row
	htmlBuffer += "\n"
	htmlBuffer += "\n"
	htmlBuffer += "\n"
	htmlBuffer += "\n"

	htmlBuffer += "Exported from DOORS: " stringOf(dateOf intOf today) "
"

	htmlBuffer += "Module: " fullName(m) " [version " version(m) "]
"

	if (scope == VIEW)
	{
		htmlBuffer += "View: " currentView(m) "
"
	}
	else if (scope == SELECTION)
	{
		htmlBuffer += "View: " currentView(m) " (Selected Objects Only)
"
	}
	else if (scope == OBJECT)
	{
		htmlBuffer += "View: " currentView(m) " (Single Object Only)
"
	}

	htmlBuffer += "\n"

	htmlBuffer += "\n"

	for c in m do
	{
		w += realOf(width(c))
	}

	// table header
	htmlBuffer += "\n"
	for c in m do
	{
		myWidth = (realOf(width(c)) / w) * 100.0
		htmlBuffer += "\n"
	}
	htmlBuffer += "\n"

	// standard DOORS module - just export all objects in order.
	for o in document m do
	{
		//print identifier(o) "\n"

		if (table(o))
		{
			emitTableObject(o, scope, htmlBuffer)
		}
		else
		{
			if (!isVisible(o))
			{
				continue
			}

			if (scope == SELECTION)
			{
				if (!(isSelected(o) || o == currObj))
				{
					continue
				}
			}

			// new row in the table for each object in the current entity
			htmlBuffer += "\n"

			for c in m do
			{
				if (main(c))
				{
					if (o."Object Heading" "" != "")
					{
						htmlBuffer += "\n"
					}
					else if (o."Object Text" "" != "")
					{
						htmlBuffer += "\n"
					}
					else
					{
						htmlBuffer += "\n"
					}
				}
				else
				{
					if (text(c, o) == "")
					{
						htmlBuffer += "\n"
					}
					else
					{
						htmlBuffer += "\n"
					}
				}
			}

			// end of row for the current object
			htmlBuffer += "\n"
		}
	}

	htmlBuffer += "" title(c) "
" number(o) " "
						convertRichText(tempBuf, o."Object Heading" "", i, null)
						htmlBuffer += tempBuf
						htmlBuffer += " "
						convertRichText(tempBuf, richText(o."Object Text"), i, null)
						htmlBuffer += tempBuf
						htmlBuffer += " 

"
						convertRichText(tempBuf, richText(c, o), i, null)
						htmlBuffer += tempBuf
						htmlBuffer += " \n"

	emitFooter(htmlBuffer)

	return(res)
}

/*************************************
	emailRequirements (no dialog)
*************************************/
void emailRequirements(Module m, int scope)
{
	string res = ""

	if (null m)
	{
		return
	}

	if (scope == SELECTION)
	{
		if (null current Object)
		{
			return
		}
	}

	Buffer htmlBuffer = create

	res = emitView(m, scope, htmlBuffer)

	if (res != "")
	{
		warningBox("ERROR: " res "")
		return
	}

	makeEmail(fullName(m), htmlBuffer)

	delete(htmlBuffer)
}

//emailRequirements(current Module, SELECTION)
//emailRequirements(current Module, OBJECT)
//emailRequirements(current Module, VIEW)

" title(c) "
" number(o) " " convertRichText(tempBuf, o."Object Heading" "", i, null) htmlBuffer += tempBuf htmlBuffer += "	" convertRichText(tempBuf, richText(o."Object Text"), i, null) htmlBuffer += tempBuf htmlBuffer += "			" convertRichText(tempBuf, richText(c, o), i, null) htmlBuffer += tempBuf htmlBuffer += "

Create DOORS Links Modules

Tony Goodman — Thu, 23 Jun 2011 10:38:37 +0000

If you create a link without setting up linkset pairings, DOORS will use the default link module. This causes problems when trying to analyse links if your links are not where you expect them to be.

To prevent the default link module being used, you need to place a soft-deleted DOORS Links module in every folder of your project. This will ensure that users can only create links as intended, and specified in your linkset pairings.

The following script will create, and soft-delete, a DOORS Links module in every folder below the current folder.

//  Create and Soft delete DOORS Links module in current folder and all sub-folders

/*
	Creates and Soft deletes a "DOORS Links" link module in the current folder and all sub-folders.

	If any DOORS Links modules already exist but are not soft-deleted, these are reported but the modules
	are left untouched. These modules should be renamed manually and then run this script again.

	Reports an error if a module cannot be created due to access permissions.

	Output is to the DXL interaction window.

	Tony Goodman		tony@smartdxl.com
*/

pragma runLim, 0

string DOORS_LINKS = "DOORS Links"

int existsCount = 0
int newCount = 0
int folderCount = 0
int errors = 0

/***********************************
	createDoorsLinksModule
************************************/
void createDoorsLinksModule(Folder f)
{
	Item i

	folderCount++

	if (module(fullName(f) "/" DOORS_LINKS))
	{
		if (!isDeleted(module(fullName(f) "/" DOORS_LINKS)))
		{
			existsCount++
			print("Already exists (undeleted): " fullName(f) "/" DOORS_LINKS "\n")
			//softDelete(module(fullName(f) "/DOORS Links"))
		}
		else
		{
			//print "already deleted\n"
		}
	}
	else
	{
		(current FolderRef__) = f

		noError
		Module m = create(DOORS_LINKS, "DO NOT UNDELETE OR PURGE", manyToMany, false)

		res = lastError

		if (res "" != "")
		{
			errors++
			print("Error trying to create " fullName(f) "/" DOORS_LINKS ": " res "\n")
		}

		if (!null m)
		{
			close(m)
			softDelete(module(fullName(f) "/" DOORS_LINKS))
			newCount++
		}
		else
		{
			errors++
			print("Failed to create: " fullName(f) "/" DOORS_LINKS "\n")
		}

	}

	for i in f do
	{
		if (type(i) == "Folder" || type(i) == "Project")
		{
			createDoorsLinksModule(folder(fullName(i)))
		}
	}
}

/************************************
	MAIN
*************************************/
if (!confirm("You are about to create and soft-delete \"" DOORS_LINKS "\" modules in all folders below\n" //-
	             fullName(current Folder) "\n" //-
                 "Are you sure you want to continue?"))
{
	halt
}

createDoorsLinksModule(current Folder)

refreshDBExplorer()

print(folderCount " folders checked\n")
print(newCount " modules created and soft-deleted\n")
print(existsCount " modules found (undeleted)\n")
print(errors " errors (unable to create module)\n")

Branded Dialogs

Tony Goodman — Wed, 22 Jun 2011 14:42:35 +0000

This library file allows you to easily create branded dialog boxes. The dialogs have a canvas across the top with your logo and a link to your website.

Include this file and call smartDialog() instead of create() when creating your dialog.

Usage:

DB smartDialog([Module m | DB db,] string title [,int options])

You will need to edit the include file to define your logo bitmap file and website URL etc.

Source file:

//<  Smart DXL Dialog Definitions

/*
    S M A R T   D X L   L I M I T E D

    Copyright:          (c) 2008 Smart DXL Limited.

    The information contained in this document is the property
    of Smart DXL Limited. Transmittal, receipt or possession
    of this information does not express licence or imply any
    rights to use sell or manufacture from this information
    and no reproduction of it in whole or part shall be made
    without the written authorisation from an officer of the company.

	Description:

	Provides smartDialog function to create a dialog box with a Smart DXL
	banner across the top.

	Usage:

		DB smartDialog([Module m | DB db,] string title [,int options])

	Change History:

	25-NOV-2008		Tony Goodman	Initial version.

	24-FEB-2011		Tony Goodman	Locate bitmap from addins path.
											Add banner title and website url.
											Use more complex names for global variables.

*/

/***********************************
	Smart DXL logo bitmap file - this is loaded once when first dialog is displayed.
***********************************/
Bitmap smartDxlLogo = null

string SMART_DXL_DB_TITLE      = "Smart DXL"
string SMART_DXL_BANNER_WEBSITE  = "www.smartdxl.com"
string SMART_DXL_BANNER_BITMAP    = "SmartDXL\\bitmaps\\tophat.bmp"

DBE smartDxlBanner = null

bool smartDxlLogoFound = false

string smartDxlBannerText = ""

int   smartDxlLogoWidth   = 0
int   smartDxlLogoHeight  = 0

/***********************************
	getAbsolutePath
***********************************/
string getAbsolutePath(string sFileName)
{
	string sResult  = ""

	string sAddinsPathList      = (getenv "ADDINS") ";"
	string sDoorsAddinsPathList = (getenv "DOORSADDINS") ";"

	if (sAddinsPathList != sDoorsAddinsPathList)
	{
		sAddinsPathList = sDoorsAddinsPathList ";" sAddinsPathList
	}

	Regexp rPath = regexp "([^;]*);(.*)"

	string sLeft    = ""
	string sRight   = ""

	if (rPath sAddinsPathList)
	{
		// test each path in the semicolon separated list
		while (rPath sAddinsPathList)
		{
			  sLeft  = sAddinsPathList[match 1]
			  sRight = sAddinsPathList[match 2]

			  if (fileExists_ (sLeft "\\" sFileName))
			  {
					sResult  = sLeft "\\" sFileName
					break;
			  }
			  else
			  {
					sAddinsPathList = sRight
			  }
		}
	}
	return(sResult)
}

/************************************
  smartDrawLogo
************************************/
void smartDrawLogo(DBE cnvs)
{
	string smartDxlBitmapFile = ""
	Stat   st = null

	if (null smartDxlLogo)
	{
		// bitmap has not been loaded yet, so load it
		smartDxlBitmapFile = getAbsolutePath(SMART_DXL_BANNER_BITMAP)

		// check that the file exists
		st = create(smartDxlBitmapFile)

		if (!null st)
		{
			// file does exist so we can load the bitmap
			delete(st)

			smartDxlLogo = loadBitmap(cnvs, smartDxlBitmapFile, false, smartDxlLogoWidth, smartDxlLogoHeight)
		}
    }

    // draw the bitmap if it was successfully loaded
    if (!null smartDxlLogo)
    {
    	drawBitmap(cnvs, smartDxlLogo, 0, 0)
		smartDxlLogoFound = true
	}
}

/***********************************
	doLogoMouse
***********************************/
void doLogoMouse(DBE cnv, int but, bool ctrl, int x, int y)
{
	if (x > width(cnv) - width(cnv, SMART_DXL_BANNER_WEBSITE) - 5)
	{
		activateURL(SMART_DXL_BANNER_WEBSITE)
	}
}

/***********************************
	doRepaintSmartDxlBanner
***********************************/
void doRepaintSmartDxlBanner(DBE cnv)
{
	int canvasWidth  = width(cnv)
	int titleHeight  = 0
	int y = 0

	realBackground(cnv, realColor_White)

	smartDrawLogo(cnv)

	realColor(cnv, realColor_Black)
	font(cnv, 4, HeadingsFont)

	y = (height(cnv) / 2) + (height(cnv, smartDxlBannerText) / 2) - 3

	draw(cnv, smartDxlLogoWidth + 3, y, smartDxlBannerText)

	realColor(cnv, realColor_Blue)
	font(cnv, 9, HeadingsFont)
	draw(cnv, canvasWidth - width(cnv, SMART_DXL_BANNER_WEBSITE) - 5, y - 1, SMART_DXL_BANNER_WEBSITE)
	line(cnv, canvasWidth - width(cnv, SMART_DXL_BANNER_WEBSITE) - 5, y, canvasWidth - 5, y)
}

/***********************************
	addSmartDxlBanner
***********************************/
void addSmartDxlBanner(DB db)
{
	smartDxlBanner = canvas(db, 0, 32, doRepaintSmartDxlBanner)

	set(smartDxlBanner, doLogoMouse)
}

/***********************************
	showHelp
***********************************/
void showHelp(string helpFile)
{
	system("\"C:\\Program Files\\Internet Explorer\\iexplore.exe\" -nohome \"" (getAbsolutePath(helpFile)) "\"")
}

/***********************************
	smartDialog
***********************************/
DB smartDialog(string banner, int options)
{
	DB smartDb = null

	smartDb = create(SMART_DXL_DB_TITLE, options)

	smartDxlBannerText = banner

	addSmartDxlBanner(smartDb)

    return(smartDb)
}

/***********************************
	smartDialog
***********************************/
DB smartDialog(string dbTitle)
{
	return(smartDialog(dbTitle, styleCentered|styleFloating))
}	

/***********************************
	smartDialog
***********************************/
DB smartDialog(Module mParent, string banner, int options)
{
	DB smartDb = null

	smartDb = create(mParent, SMART_DXL_DB_TITLE, options)

	smartDxlBannerText = banner

	addSmartDxlBanner(smartDb)

    return(smartDb)
}

/***********************************
	smartDialog
***********************************/
DB smartDialog(Module mParent, string dbTitle)
{
	return(smartDialog(mParent, dbTitle, styleCentered|styleFloating))
}

/***********************************
	smartDialog
***********************************/
DB smartDialog(DB dbParent, string banner, int options)
{
	DB  smartDb     = null

	smartDb = create(dbParent, SMART_DXL_DB_TITLE, options)

	smartDxlBannerText = banner

	addSmartDxlBanner(smartDb)

    return(smartDb)
}

/***********************************
	smartDialog
***********************************/
DB smartDialog(DB dbParent, string banner)
{
	return(smartDialog(dbParent, banner, styleCentered|styleFloating))
}

Folder Browser DBE

Tony Goodman — Wed, 22 Jun 2011 14:31:50 +0000

This function implements a folder browser dialog element. Use it in a similar fashion to the builtin fileName() function.

Usage:

DBE foldername = smartFolderBrowser(DB dbParent, string label, bool readOnly)

Source file:

//<  Smart Folder Browser

/*
    S M A R T   D X L   L I M I T E D

    Copyright:          (c) 2008 Smart DXL Limited.

	Description:

	Folder Browser Facility. 

    provides smartFolderBrowser() which may be used in place of fileName()
    when browsing for a folder rather than a file.

    Uses COM to invoke windows folder browser.

	Change History:

	25-NOV-2008		Tony Goodman	

*/

/************************************
	Field and Browse button that are created on the parent dialog box.
*************************************/
DBE dbeBrowse         = null
DBE dbeDirectory      = null

/************************************
	getWindowsFolder
*************************************/
string getWindowsFolder(string &dirPath)
{
	OleAutoObj  objDialog     = null
	OleAutoObj  objFolder     = null
	OleAutoObj  objFolderItem = null
	OleAutoArgs args          = create
	string      folderPath    = ""
	string      res           = ""

	dirPath = ""

	objDialog = oleCreateAutoObject("Shell.Application")

	if (null objDialog)
	{
		return("Failed to create dialog object")
	}

	put(args, 0)                         // always zero
	put(args, "Please select a folder")  // title
	put(args, 0)                         // options
	//put(args, "c:\\temp")              // root folder

	res = oleMethod(objDialog, "BrowseForFolder", args, objFolder)

	if (null objFolder)
	{
		if (res "" != "")
		{
			return("Failed to launch browser: " res)
		}
		else
		{
			return("")
		}
	}

	res = oleGet(objFolder, "Self", objFolderItem)

	if (null objFolderItem)
	{
		return("Failed to get folder item: " res)
	}

	oleGet(objFolderItem, "Path", folderPath)

	dirPath = folderPath

	return(res)
}

/************************************
	doBrowse
*************************************/
void doBrowse(DBE dbe)
{
	string res           = ""
	string directoryName = ""

	res = getWindowsFolder(directoryName)

	if (res == "")
	{
		set(dbeDirectory, directoryName)
	}
	else
	{
		infoBox("Error: " res)
	}
}

/************************************
	smartFolderBrowser
*************************************/
DBE smartFolderBrowser(DB     dbParent,
                     string sLabel,
                     bool   readOnly)
{
    // use default if parameter is null
    if (dbParent == null)
    {
        dbParent = dbExplorer
    }

    // Create Field and Browse button on parent dialog
    dbeDirectory = field(dbParent, sLabel, "", 40, readOnly)
    beside(dbParent)
   	dbeBrowse = button(dbParent, "Browse...", doBrowse)
   	left(dbParent)

    // return handle on directory field dbe
    return(dbeDirectory)
}

List Linked Modules

Tony Goodman — Wed, 22 Jun 2011 08:56:42 +0000

This simple script creates a dialog box showing a list of all modules that are linked to the current module. It also includes the name of the link module used and a count of the number of links.

//   List Linked Modules

/*
	02-MAR-2011		Tony Goodman	Initial Version
*/

// List Linked Modules

/*
   Lists modules that are linked to from the current module, together with a count of links.
*/

pragma runLim, 0

DB dbMain = null
DBE dbeResults = null

Module m = null

/***********************
	populateBuffer
************************/
void populateBuffer(Buffer &b)
{
	Object o = null
	Link l = null
	LinkRef lr = null
	ModName_ mn = null
	int count = 0
	int outTotal = 0
	int inTotal = 0 

	Skip inLinks = createString
	Skip outLinks = createString

	string s = ""

	for o in m do
	{
		for l in o -> "*" do
		{
			mn = target(l)

			s = fullName(mn) " [" fullName(module(l)) "]"

			if (find(outLinks, s, count))
			{
				delete(outLinks, s)
				put(outLinks, s, count + 1)
			}
			else
			{
				put(outLinks, s, 1)
			}
			outTotal++
		}
	}

	b += fullName(m) "\n\n"

	if (outTotal == 0)
	{
		b += "has no outgoing links\n"
	}
	else
	{
		b += "has outgoing links to:\n"

		for count in outLinks do
		{
			b += (string key outLinks) " - " count " links\n"
		}
	}

	for o in (m) do
	{
		for lr in o <- "*" do
		{
			mn = source(lr)

			s = fullName(mn) " [" fullName(module(lr)) "]"

			if (find(inLinks, s, count))
			{
				delete(inLinks, s)
				put(inLinks, s, count + 1)
			}
			else
			{
				put(inLinks, s, 1)
			}
			inTotal++
		}
	}

	if (inTotal == 0)
	{
		b += "has no incoming links\n"
	}
	else
	{
		b += "\nhas incoming links from:\n"

		for count in inLinks do
		{
			b += (string key inLinks) " - " count " links\n"
		}
	}

	b += "\n"
}

/*******************************
	listLinkedModules
********************************/
void buildDialog()
{
	Buffer b = create
	populateBuffer(b)

	dbMain = create(m, "Linked Modules", styleFloating|styleCentered)
	dbeResults = text(dbMain, "", "", 800, 250, false)

	realize(dbMain)
	set(dbeResults, b)

	delete(b)
	b = null

	show(dbMain)
}

/*******************************
	listLinkedModules
********************************/
void listLinkedModules()
{
	m = current Module

	buildDialog()
}

listLinkedModules()

Export Attribute Definitions

Tony Goodman — Fri, 17 Jun 2011 14:23:49 +0000

This utility allows you to export attribute definitions from the current Module to a CSV file.

// Export Attributes

/*

*/

DB dbMain = null
DBE dbeFileName = null

Module m = null
string outputFile = ""

/************************************
	doExport
*************************************/
void doExport(DB db)
{
	AttrDef ad = null
	AttrType at = null
	string existsForObject = ""
	string existsForModule = ""
	string inheritValue = ""
	string defVal = ""
	AttrBaseType abt = null
	string isDxl = ""
	string hasHistory = ""
	string hasBars = ""
	string hasDates = ""
	string minVal = ""
	string maxVal = ""
	string isMulti = ""
	Stream st = null
	Buffer enumerations = create
	int enumSize = 0
	int i = 0
	bool isHidden = false
	bool isSystem = false

	outputFile = get(dbeFileName)

	st = write(outputFile)

	if (null st)
	{
		infoBox("failed to open file for writing: " outputFile)
		return
	}

	st << "Name,"
	st << "Description,"
	st << "Type," 

	st << "Exists For Object,"
	st << "Exists For Module,"  

	st << "Generates History,"
	st << "Affects Change Bars,"
	st << "Affects Change Dates," 

	st << "DXL Attribute,"
	st << "Inherits Value,"
	st << "Default Value," 

	st << "Base Type,"
	st << "Enumerations," 

	st << "Multi Valued,"
	st << "Min Value,"
	st << "Max Value\n"  

	for ad in m do
	{
		isSystem = ad.system

		if (ad.system) continue

		isHidden = ad.hidden

		if (ad.hidden) continue

		if (ad.module)
		{
			existsForModule = "Y"
		}
		else
		{
			existsForModule = ""
		}

		if (ad.object)
		{
			existsForObject = "Y"
		}
		else
		{
			existsForObject = ""
		}	

		if (ad.inherit)
		{
			inheritValue = "Y"
		}
		else
		{
			inheritValue = ""
		}

		defVal = ""

		if (ad.defval)
		{
			defVal = plainText(ad.defval)
		}

		at = ad.type

		abt = at.type

		isMulti = ""

		if (abt == attrEnumeration)
		{
			if (ad.multi)
			{
				isMulti = "Y"
			}

			setempty(enumerations)

			enumSize = at.size

			for (i = 0; i < enumSize; i++)
			{
				enumerations += at.strings[i] "\n"
			}
		}

		if (ad.dxl)
		{
			isDxl = "Y"
		}
		else
		{
			isDxl = ""
		}

		if (!ad.nohistory)
		{
			hasHistory = "Y"
		}
		else
		{
			hasHistory = ""
		}

		if (!ad.nochanges)
		{
			hasDates = "Y"
		}
		else
		{
			hasDates = ""
		}

		if (!ad.nobars)
		{
			hasBars = "Y"
		}
		else
		{
			hasBars = ""
		}

		minVal = ""
		maxVal = ""

		if (abt == attrInteger)
		{
			if (at.minValue)
			{
				minVal = (int at.minValue) ""
			}

			if (at.maxValue)
			{
				maxVal = (int at.maxValue) ""
			}
		}
		else if (abt == attrDate)
		{
			if (at.minValue)
			{
				minVal = (Date at.minValue) ""
			}

			if (at.maxValue)
			{
				maxVal = (Date at.maxValue) ""
			}
		}
		else if (abt == attrReal)
		{
			if (at.minValue)
			{
				minVal = (real at.minValue) ""
			}

			if (at.maxValue)
			{
				maxVal = (real at.maxValue) ""
			}
		}

		st << "\"" ad.name "\","
		st << "\"" ad.description "\","
		st << "\"" ad.typeName "\","

		st << "\"" existsForObject "\","
		st << "\"" existsForModule "\","

		st << "\"" hasHistory "\","
		st << "\"" hasBars "\","
		st << "\"" hasDates "\","

		st << "\"" isDxl "\","
		st << "\"" inheritValue "\","
		st << "\"" defVal "\","

		st << "\"" abt "\","
		st << "\"" stringOf(enumerations) "\","

		st << "\"" isMulti "\","
		st << "\"" minVal "\","
		st << "\"" maxVal "\"\n"

	}

	close(st)

	infoBox("Export complete!")

	release(dbMain)
}

/***************************************
	doHelp
***************************************/
void doHelp(DB db)
{
	showHelp("SmartDXL/export/exportAttributesCsv.mht")
} 

/***********************************
	buildDialog
***********************************/
void buildDialog()
{
	dbMain = create(m, "Export Attributes to CSV", styleCentered)

	label(dbMain, "This utility exports attribute details to a CSV file.\n\n")

	dbeFileName = fileName(dbMain, "Export to:", "U:\\" name(m) ".csv", "*.csv", "CSV Files", false)

	apply(dbMain, "Export", doExport)
	apply(dbMain, "Help", doHelp)

	realize(dbMain)

	block(dbMain)
	destroy(dbMain)
	dbMain = null
}

/************************************
	exportAttributes
************************************/
void exportAttributes()
{
	m = current Module

	buildDialog()
}