ATL / WTL / STL

<code>// Included all generally needed stuff here
#include "stdafx.h"
#include "DBItem.h"
#include "DB_Obj1.h"

DBItem::DBItem(int nId, _ConnectionPtr  pConnectionGeneral)
{
	pConnDB = pConnectionGeneral;
	pRstDB.CreateInstance(__uuidof(Recordset));
	nIid = nId;
}

DBItem::~DBItem()
{
	pRstDB->Close();
	pRstDB.Release();
	pRstDB.Detach();

	ds.mAttr.clear();
	ds.mAttrFields.clear();
	ds.mAttrLoaded.clear();
	ds.mAttrModified.clear();
	ds.mDeps.clear();
	ds.mLinks.clear();
	ds.sIdField.~basic_string();
	ds.sTableName.~basic_string();
	ds.sTittleAttr.~basic_string();
	ds.sTreeLink.~basic_string();

	while (!mMessages.empty())
	{
		mMessages.pop();
	}
}

 /**
 *	Loads object's attributes from DB to ds.mAttr, as variants.
 *      Sets Loaded flag
 */
BOOL DBItem::Load()
{
	char *sztempQuery;
	string sQuery, sFldName;
	int i;
	FieldPtr pField;

	FormLoadQuery(&sztempQuery);
	sQuery = sztempQuery;
	free(sztempQuery);

	if (ExecuteQuery(sQuery))
	{
		for (i = 0; i < pRstDB->Fields->Count; i++)
		{
			pField = pRstDB->Fields->GetItem(_variant_t((long)i, VT_I4));
			sFldName = pField->Name;
			ds.mAttr[ds.mAttrFields[sFldName]] = pField->Value;
			ds.mAttrLoaded[ds.mAttrFields[sFldName]] = TRUE;
		}
	}
	else
	{
		AddMessage(DB_ERROR, "Error while executing load query. Check previous message!");
		return FALSE;
	}

	return TRUE;
}

 /**
 *	Returns a variant attribute. Loads the attributes is requested one isn't loaded, just so we won't load too early
 *	or too much
 */
_variant_t DBItem::GetAttr(string sAttr)
{
	_variant_t vAttr;

	if (nIid == 0)
	{
		vAttr.vt = VT_NULL;
		return vAttr;
	}

	if (!ds.mAttrLoaded[sAttr])
	{
		if (!Load())
		{
			vAttr.vt = VT_NULL;
		}
		else
		{
			vAttr = ds.mAttr[sAttr];
		}
	}
	else
	{
		vAttr = ds.mAttr[sAttr];
	}

	return vAttr;
}

 /**
 *	Tries to execute sQuery on the ADO connection object. Fills pRstDB
 *	Exceptions will fail it and push a massage describing themselves onto message stack.
 */
BOOL DBItem::ExecuteQuery(string sQuery)
{
	try
	{
		pRstDB = pConnDB->Execute(sQuery.c_str(), NULL, adCmdText);
	}
	catch (_com_error &e)
	{
		AddMessage(DB_EXCEPTION, "Exception in DBItem::ExecuteQuery(), Class '" + GetClass() + "', ID " + ToString(nIid) + " Error: " + (string)e.ErrorMessage());
		return FALSE;
	}

	return TRUE;
}

 /**
 *	Pushes a message to the object's message stack. Errors, Exceptions, Infos, we'll see about others
 *	TODO: pop message
 */
void DBItem::AddMessage(int nMsgType, string sMessage)
{
	string stempMessage;

	stempMessage = ToString(nMsgType) + sMessage;
	mMessages.push(stempMessage);
}

 /**
 *	Returns a string containing objects name, as defined by ds.sTittleAttr
 *	TODO: Treat case where there's no such thing as ds.sTittleAttr
 */
string DBItem::GetName()
{
	_variant_t vVar;
	string stempName = "";

	vVar = GetAttr(ds.sTittleAttr);
	try
	{
		stempName =  vVar.operator _bstr_t().operator const char *();
	}
	catch (_com_error &e)
	{
		AddMessage(DB_EXCEPTION, "Exception in DBItem::GetName(), Class '" + GetClass() + "', ID " + ToString(nIid) + " Error: " + (string)e.ErrorMessage());
		stempName = "";
	}
	return stempName;
}

/*
 *	Returns a pointer to the instance of the type and ID specified by attribute's value, hopefully (it does!!!)
 *
 */
DBItem *DBItem::GetObject(string sAttr)
{
	DBItem *mliInstance;
	_variant_t vIdAttr;
	unsigned long dInstId;

	vIdAttr = GetAttr(sAttr);
	dInstId = vIdAttr.operator long();

	mliInstance = GetInstance(ds.mLinks[sAttr], dInstId);

	return mliInstance;
}

 /**
 *	Returns a DBIList pointer to a vector containing pointers to object instances masked as DBItem
 *	Have to remember to delete each instance and possibly the vector in the place of use
 *	To use, iterate through vector, cast to required class, they're all hiding as base class DBItem.
 */
DBIList *DBItem::GetInstances()
{
	DBIList *pVector;
	DBItem *mliInstance;
	char *sztempQuery;
	string sQuery;
	unsigned long ulID, ulCount;
	long i;
	FieldPtr pField;

	// Query to get all IDs
	FormGetIDsQuery(&sztempQuery);
	sQuery = sztempQuery;
	free(sztempQuery);

	if (ExecuteQuery(sQuery))
	{
		// Get number of instances to init our little vector container
		ulCount = pRstDB->Fields->Count;
		pVector = new DBIList(ulCount);
		for (i = 0; i < pRstDB->Fields->Count; i++)
		{
			pField = pRstDB->Fields->GetItem(_variant_t((long)i, VT_I4));
			// Get each ID value
			ulID = pField->Value.ulVal;
			// Instantiate
			mliInstance = GetInstance(GetClass(), ulID);
			// Push pointer in vector
			pVector->push_back(mliInstance);
		}
		// Return a pointer to our filled vector.
		return pVector;
	}
	else
	{
		AddMessage(DB_ERROR, "Error while executing ID query. Check previous message!");
		return NULL;
	}
}

 /**
 *	Returns current object's base class name. Should be overidden by all classes deriving from this.
 */
string DBItem::GetClass()
{
	return (string)"DBItem";
}

 /**
 *	Returns a pointer to a specific item type instance, posing as a base item instance, hopefully
 *	Given a class name and database ID
 */
DBItem *DBItem::GetInstance(string sClassName, unsigned long nId)
{	

	if (sClassName == "DB_Obj1")
		return new DB_Obj1(nId, pConnDB);

	return NULL;
}

 /**
 *	Fills *szQuery with the query needed to get all the object's attributes
 */
void DBItem::FormLoadQuery(char **szQuery)
{
	string stempQuery;

	stempQuery = "SELECT * FROM ";
	stempQuery += ds.sTableName;
	stempQuery += " WHERE ";
	stempQuery += ds.sIdField;
	stempQuery += "=";
	stempQuery += ToString(nIid);

	*szQuery = (char *) malloc(stempQuery.length() + 1);
	if (*szQuery == NULL)
	{
		
	}
	else
	{
		memset(*szQuery, 0, stempQuery.length() + 1);
		memcpy(*szQuery, stempQuery.c_str(), stempQuery.length());
	}
}

 /**
 *	Fills *szQuery with the query needed to get all the current class' instance IDs
 */
void DBItem::FormGetIDsQuery(char **szQuery)
{
	string stempQuery;

	stempQuery = "SELECT "
	stempQuery += ds.sIdField;
	stempQuery += " FROM ";
	stempQuery += ds.sTableName;

	*szQuery = (char *) malloc(stempQuery.length() + 1);
	if (*szQuery == NULL)
	{
		
	}
	else
	{
		memset(*szQuery, 0, stempQuery.length() + 1);
		memcpy(*szQuery, stempQuery.c_str(), stempQuery.length());
	}
}

 /**
 *	Converts input int to string representation
 */
string DBItem::ToString(int nConvertable)
{
	string stempConvert;
	char *sztempConvert;

	sztempConvert = (char *) malloc(16);
	memset(sztempConvert, 0, 16);

	_itoa(nConvertable, sztempConvert, 10);

	stempConvert = sztempConvert;
	free(sztempConvert);

	return stempConvert;
}

 /**
 *	Converts input long to string representation
 */
string DBItem::ToString(long nConvertable)
{
	string stempConvert;
	char *sztempConvert;

	sztempConvert = (char *) malloc(16);
	memset(sztempConvert, 0, 16);

	_ltoa(nConvertable, sztempConvert, 10);

	stempConvert = sztempConvert;
	free(sztempConvert);

	return stempConvert;
}
</code>

HRESULT SetToNaturalSize(LONG w) {
  HDC hdc = ::GetDC(parent_window_);
  LONG x_per_inch = GetDeviceCaps(hdc, LOGPIXELSX);
  LONG y_per_inch = GetDeviceCaps(hdc, LOGPIXELSY);

  LONG width = (w * HIMETRIC_PER_INCH + x_per_inch - 1) / x_per_inch;
  LONG height = LONG_MAX;
  SIZEL sizel = { LONG_MAX, LONG_MAX };

  SetMapMode(hdc, MM_ANISOTROPIC);
  SetWindowExtEx(hdc, HIMETRIC_PER_INCH, HIMETRIC_PER_INCH, NULL);
  SetViewportExtEx(hdc, x_per_inch, y_per_inch, NULL);

  HRESULT hr = text_services_->TxGetNaturalSize(DVASPECT_CONTENT, hdc, NULL,
      NULL, TXTNS_FITTOCONTENT, &sizel, &width, &height);

  SetMapMode(hdc, MM_TEXT);
  ::ReleaseDC(parent_window_, hdc);

  if (SUCCEEDED(hr)) {
    width = (width * x_per_inch + HIMETRIC_PER_INCH - 1) / HIMETRIC_PER_INCH;
    height = (height * y_per_inch + HIMETRIC_PER_INCH - 1) / HIMETRIC_PER_INCH;

    text_rc_.left = 0;
    text_rc_.right = width;
    text_rc_.top = 0;
    text_rc_.bottom = height;
  }

  return hr;
}

HRESULT SetToNaturalSize(LONG w) {
  HDC hdc = ::GetDC(parent_window_);
  long width;
  long height;
  width = w;
  height = 1;
  SIZEL sz;
  sz.cx = width;
  sz.cy = height;

  HRESULT hr = text_services_->TxGetNaturalSize(DVASPECT_CONTENT, hdc, NULL, NULL,
                                                TXTNS_FITTOCONTENT, &sz, &width, &height);

  ::ReleaseDC(parent_window_, hdc);

  if (SUCCEDED(hr)) {
    text_rc_.SetRectEmpty();
    text_rc_.right = width;
    text_rc_.bottom = height;
  }

  return hr;
}

The application must call the DrawMenuBar function whenever a menu changes, whether or not the menu is in a displayed window.