Ich würde ganz gerne eine Standardklasse für Controls entwerfen. Konkret geht es erst mal darum, in die Klasse ein statisches CToolTipControl einzubinden. Die Controls sollen dann über eigene Methoden verfügen ihren Tooltiptext zu setzen.
Das Problem ist jetzt, dass man ja eine Klasse dazwischen schieben muss. Der einzige Weg der mir einfällt, um nicht jede bestehende Controlklasse zu verändern, sind Templates. Also in etwa so:

//ctrlBase.h:
template<class T> class CCtrl : public T
{
...
private:
    static CToolTipCtrl m_tt;
}

//irgendeine Dialogimplementierung:

//Vom Assistenten erzeugtes CEdit
CEdit m_edit
// wird zu:
CCtrl<CMyEdit> m_edit;

Meine Fragen wären jetzt, geht das überhaupt (T als Basis) und gibt es Besonderheiten bei statischen Variablen innerhalb von Templates zu beachten?
Und das spannendste: Gibts noch einen anderen, besseren Weg?

Viele Grüße,

connan.

//ctrl.h
#pragma once

#include <afxcmn.h>

template<class T> class CCtrl : public T
{
public:	
	CCtrl();
	virtual ~CCtrl();

public:
	void SetToolText(LPCTSTR lpszText);

protected:
	virtual BOOL PreTranslateMessage(MSG* pMsg);
	virtual void PreSubclassWindow();

private:
	static CToolTipCtrl m_tt;	

};

template<class T>
CCtrl<T>::CCtrl()
{
	static bool bOnce = true;
	if(bOnce)
	{
		if (!m_tt.Create(this,TTS_ALWAYSTIP))
		{
			TRACE("Unable To create ToolTip\n");           
      		}
		else
		{
			m_tt.Activate(true);			
		}
	}
	bOnce=false;
}

template<class T>
CCtrl<T>::~CCtrl()
{
}

template<class T>
void CCtrl<T>::SetToolText(LPCTSTR lpszText)
{
	m_tt.UpdateTipText(lpszText,this);
}

template<class T>
void CCtrl<T>::PreSubclassWindow()
{
	if(!m_tt.AddTool(this,"ToolTip Not Set"))
	{
		TRACE("Unable To Add ToolTip\n");
	}
         T::PreSublassWindow();
}

template<class T>
BOOL CCtrl<T>::PreTranslateMessage(MSG* pMsg)
{
	m_tt.RelayEvent(pMsg);
	return T::PreTranslateMessage(pMsg);
}

template<class T>
CToolTipCtrl CCtrl<T>::m_tt;

In einem Dialog muss dann nur folgendes stehen:
.h:

CCtrl<CEdit> m_edit;

.cpp (z.B.OnInitDialog oder DoDataExchange):

m_edit.SetToolText("Hallo");

das wars.

Aber nur für Controls verwenden

Mehr dazu siehe MSDN
Artikel 188317 und 140595!

btw.: Das ToolTipControl existiert doch nur einmal, ist doch statisch.
EDIT: Das Control existiert für jede Klasse T einmal!

btww.: Wie sucht man in der MSDN nach Artikelnummern

Zudem werden die Daten doch abgefragt. Sicherlich sind die interaktiv zu ändern. Denn gefüllt werden diese ja auf Anfrage!

Kann man vieleicht einem Template irgendwie beibringen, das es die statische Variable wirklich nur einmal geben soll, und nicht für jede class T eine?

EDIT: Zum vorherigen Post: es zeigt, trotzdem nur 5 ToolTipCtrls existeren, jedes der 40 Controls einen (teilweise dynamischen) ToolTip an! (Nur um Unklarheiten zu beseitigen.)

class CStaticToolTip
{
public:
    static CToolTipCtrl m_tt;
}

template <class T> CCtrl : public T, public CStaticToolTip
{
...
}

Damit sollte m_tt nur noch einmal exisitieren. Sieht aber irgendwie nicht schön aus

Implementierung der Klasse für das statische TTCtrl:
StaticToolTip.h:

#pragma once

class CToolTipCtrl;
class CStaticToolTip
{
public:
	CStaticToolTip(CWnd* pWnd);
protected:
	static CToolTipCtrl m_tt;

};

StaticToolTip.cpp:

#include "StdAfx.h"
#include "StaticToolTip.h"
#include <afxcmn.h>

CToolTipCtrl CStaticToolTip::m_tt;

CStaticToolTip::CStaticToolTip(CWnd* pWnd)
{
	static bool bOnce = true;    //m_tt.Create darf nur einmal aufgerufen werden!
	if(bOnce)
	{
		if (!m_tt.Create(pWnd,TTS_ALWAYSTIP))
		{
			TRACE("Unable To create ToolTip\n");           
    	}
		else
		{
			m_tt.Activate(true);			
		}
	}
	bOnce=false;
}

Und zu guter Letzt, das Template:
Ctrl.h

#pragma once

#include "statictooltip.h"

template<class T> class CCtrl : public T, public CStaticToolTip
{
public:	
	CCtrl();
	virtual ~CCtrl();

public:
	void SetToolText(LPCTSTR lpszText);          //Setzen des ToolTextes

protected:
	virtual BOOL PreTranslateMessage(MSG* pMsg); // weiterleiten der Messages an m_tt.RelayEvent
	virtual void PreSubclassWindow();            // Initialisierung des ToolTips bei der Erzeugung des Controls
};

template<class T>
CCtrl<T>::CCtrl() : CStaticToolTip(this)
{
}

template<class T>
CCtrl<T>::~CCtrl()
{
}

template<class T>
void CCtrl<T>::SetToolText(LPCTSTR lpszText)
{
	CStaticToolTip::m_tt.UpdateTipText(lpszText,this);
}

template<class T>
void CCtrl<T>::PreSubclassWindow()
{
	if(!CStaticToolTip::m_tt.AddTool((T*)this,"ToolTip Not Set"))
	{
		TRACE("Unable To Add ToolTip\n");
	}
	T::PreSubclassWindow();
}

template<class T>
BOOL CCtrl<T>::PreTranslateMessage(MSG* pMsg)
{
	CStaticToolTip::m_tt.RelayEvent(pMsg);
	return T::PreTranslateMessage(pMsg);
}

Bsp. zur Benutzung:

CMyDialog.h:

#include "ctrl.h"
class CMyDialog ...
{
    ...
    CCtrl<CEdit> m_edit; //beliebiges control, vorher CEdit m_edit
    ...
}

CMyDialog.cpp:

//z.B. in:
CMyDialog::DoDataExchange(CDataExchange* pDX)
{
    DDX,DDV Aufrufe;
    CString str;
    m_edit.GetWindowText(str);
    m_edit.SetToolText(str); //Dadurch wird der Inhalt des Edits in den ToolTip geschrieben
                      //was auch während dessen Anzeige funktioniert
}

Na was sagst Du jetzt?

Danke Dir, hab wieder viel gelernt.

template<class T> class CCtrl : public T, public CStaticToolTip

auflösen kann?