//Prozedur für das Hauptfenster
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
     .
     .
     .
   case WM_CREATE:
        {
	 hChild = CreateWindowEx(WS_EX_CLIENTEDGE,
			                 lpszChildName, 
			                 NULL, 
			                 WS_CHILD,
			                 500,30,300,300,
			                 hWnd,
			                 NULL,
			                 NULL,
			                 NULL);
        }
   case WM_COMMAND:
        {
            if(lParam == (LPARAM)hButtonStart)
                if(HIWORD(wParam) == BN_CLICKED)
                {
                                        //startet die eigentliche Berechnung
                                          start();
                }
        }
     .
     .
     .
   return 0;
}
//Prozedur für das Ausgabefenster   (hChild)
LRESULT CALLBACK ChildProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch(message)
         {
         case WM_IRGENDWAS:
              {
                   //hier steht dann Ausgabeanweisung...
              }
            .
            .
            .
         }
         return DefWindowProc(hWnd, message, wParam, lParam);
}
//Die Berechnung
//Der Code ist unwesentlich, wichtig ist nur, dass die Nachricht aus einer
//For-Schleife gesendet werden soll...
int start() 
{
       register int t,s;

       char   tmp[5];
       double Energy;

       Mesh();
       Time();
       Initialisation();
       TemperatureCoefficients();

       for (t=1; t<=N5; t++) 
       { 
              IntensityDistribution(t);
              ComputeEnergy(t);

              s=Temperature();
              //hier soll jedesmal die bewusste
              //Nachricht gesendet werden:
              SendMessage(hChild, WM_IRGENDWAS,0,0);

              sprintf(tmp,"%d",t);
              string number=tmp;
              if(!SaveData("./data/main"+number+".dat"))
              return -1;
       }
       video();
       return 0;
}

Vielleicht kann mir ja jemand weiterhelfen. Ich bin gespannt

hat mich jetzt so stark interessiert das ich schnell was geschrieben habe.
denk dran quick&dirty, nicht optimiert, usw usw ist nur zur verdeutlichung.

class windowsguilogstream : public std::streambuf
{
	public:
		explicit windowsguilogstream(HWND hwnd)
		:	m_hWnd(hwnd)
		{ }

		virtual ~windowsguilogstream()		{ sync(); }

	protected:
		int overflow(int c)
		{
			if(!traits_type::eq_int_type(c, traits_type::eof()))
			{
				if(pbase() == epptr())
                       m_strBuffer += c;
				else
					sputc(c);
			}

			return traits_type::not_eof(c);
		}

		int sync()
		{
			int nLen = (SendMessage(m_hWnd, WM_GETTEXTLENGTH, 0, 0)) + 1;

			char *pszTemp = new char[nLen + m_strBuffer.size()];

			SendMessage(m_hWnd, WM_GETTEXT, (WPARAM)nLen, (LPARAM)pszTemp);

			strncat(pszTemp, m_strBuffer.c_str(), m_strBuffer.size());

			SendMessage(m_hWnd, WM_SETTEXT, 0, (LPARAM)pszTemp);

			delete [] pszTemp;
			m_strBuffer.clear();

			return 0;
		}

	private:
		HWND			m_hWnd;
		std::string     m_strBuffer;
};

// ---------
case WM_CREATE:
    hEdit1 = CreateWindow("edit", // ...

    // ich weis memleak, hier bietet sich nen smartpointer an
    std::cout.rdbuf(new util::windowsguilogstream(hEdit1));

Frage an die, die etwas mehr Ahnung haben als ich: gibt es etwas dagegen einzuwenden, der Funktion start beim Aufruf das Handle auf das entsprechende Fenster zu übergeben?

keine einwände

BeNNeR schrieb:

Kann man sich ein Handle genauso wie eine beliebige Variable vorstellen?

ja

BeNNeR schrieb:

Oder wo ist der Unterschied?

gibt in der regel keinen

ps: vergiss meinen obrigen code und mache es so, habe zu kompliziert gedacht