Das Bitmap heist Makro (siehe Bild) was ich schon erstellt habe
http://img150.imagevenue.com/loc178/th_78146_makro_rsource.JPG

Und es sollte in dieses MOdul Auswahlfenster (siehe Bild)
http://img109.imagevenue.com/loc199/th_78141_hauptfenster_makro.JPG

So nun habe ich versuche den quellcode von den anderen Bitmaps zu übernehmen für mein Makro.bmp aber leider sehe ich mein Bitmap dann immernoch nicht in der Auswahlleiste.

Deswegen wollte ich fragen ob ich den quellcode hier posten darf dies sind aber ca 1200 Zeilen quellcode und das bei 5 verschiedenen cpp dateien.

Deswegen wollte ich erstmaöl fragen ob ich dies darf oder wie man sich sonst irgendwie man mir bei meinene Projekt helfen kann

ok folgender code der blockgrafik.cpp

#define Test

#include <afxext.h>
#include <windows.h>
#include "AllgDekla.h"
#include "BlockGrafik.h"
#include "resource.h"

bool erstelleStandardAbbildung(HBITMAP *ZBild, BlockSpeicherFeld *ModulDaten,ProgrammInformation *info);
bool Negierung_in_Bitmap_Zeichen(HDC *Abbhdc,HBITMAP *Abbildung,BlockSpeicherFeld *ModulDaten,ProgrammInformation *info);
bool kopiereBlock(BlockSpeicherFeld *LokZeiger, BlockSpeicherFeld *hZeiger);

bool liefereAbbildung  (HDC *Abbhdc, HBITMAP *Abbildung , BlockSpeicherFeld *ModulDaten, ProgrammInformation *info);
bool TextEinfuegen     (HDC *Abbhdc, HBITMAP *AbbBild   , BlockSpeicherFeld *ModulDaten,ProgrammInformation *info);
bool Bitmap_ins_Fenster(HDC *Abbhdc, HBITMAP *Abbildung , BlockSpeicherFeld *ModulDaten, HWND handle, WListe ListeTyp,	ProgrammInformation *info);
bool zeichneaktiviert  (HDC *Abbhdc, HBITMAP *Abbildung);

bool BlockDatenHolen(  ProgrammInformation *info,HGLOBAL SpeicherHandle
                     , HWND handle,bool Lokale,BlockSpeicherFeld *LokVar
                     , BlockSpeicherFeld *aktuellerBlock);

bool HindergrundHolen (HDC *Hghdc, HBITMAP *HinterBild, BlockSpeicherFeld *aktuellerBlock, ProgrammInformation *info);

////////////////////////////////////////////////////////////
//				'InitSchrift'							                      //
//														                            //
// Beim Start werden Schriften einmal initiert. Dabei gibt//
// es einmal eine Schrift für die Pin-Beschriftung und    //
// einmal eine Schrift für die selbst eingetragene Beschr.// 
//														                            //
////////////////////////////////////////////////////////////
//														                            //	
//	erstellt am     : 02.03.2001						              //	
//														                            //	
//	letzte Änderung : 15.01.2002						              //	
//														                            //	

//														                            //	
////////////////////////////////////////////////////////////
extern bool InitSchrift (ProgrammInformation *info)
{
	LOGFONT EigenFont;
	//Erste Schrift, zum reizeichnen in die Blöcke
	EigenFont.lfHeight = INT(info->Raster);
	EigenFont.lfWidth = INT((info->Raster / 2)) ;
	EigenFont.lfEscapement = 0;
	EigenFont.lfOrientation = 0;
	EigenFont.lfWeight = 400;
	EigenFont.lfItalic = FALSE;
	EigenFont.lfUnderline = FALSE;
	EigenFont.lfStrikeOut = FALSE;
	EigenFont.lfCharSet = ANSI_CHARSET;
	EigenFont.lfOutPrecision = OUT_DEFAULT_PRECIS;
	EigenFont.lfClipPrecision = CLIP_DEFAULT_PRECIS;
	EigenFont.lfQuality = DEFAULT_QUALITY;
	EigenFont.lfPitchAndFamily = DEFAULT_PITCH;
	info->Schrift.Schrift1 = CreateFontIndirect (&EigenFont);
	// Zweite Schrift für die individuelle Bezeichnung
	EigenFont.lfHeight = INT(1.5 *  info->Raster);
	EigenFont.lfWidth = INT((1.5 * (info->Raster / 2)) + 1);
	info->Schrift.Schrift2 = CreateFontIndirect (&EigenFont);
  // Dritte und feste Schrift jk 15.01.03
  EigenFont.lfHeight = INT(1 * RasterMass);
	EigenFont.lfWidth = INT((1 * (RasterMass / 2)) + 1);
	info->Schrift.Schrift = CreateFontIndirect (&EigenFont);

	return TRUE;
};

////////////////////////////////////////////////////////////
//				'KillSchrift'					                    		  //
//													                          	  //
// Die Schriften müsse für Windows wieder freigegeben     //
// werden.												                        //
//														                            //
////////////////////////////////////////////////////////////
//														                            //	
//	erstellt am     : 02.03.2001			              		  //	
//													                              //	
//	letzte Änderung : 02.03.2001			            			  //	
//														                            //	
//	von			    : Jan Karstens (Diplom, FH Westküste)     //	
//														                            //	
//	betreut von     : Prof. Christian Siemers			        //	
//														                            //	
////////////////////////////////////////////////////////////
extern bool	KillSchrift(ProgrammInformation *info)
{
	// Löschen der verwendeten Schriften !
	DeleteObject(info->Schrift.Schrift1);
	DeleteObject(info->Schrift.Schrift2);
	DeleteObject(info->Schrift.Schrift );
	return TRUE;
};

////////////////////////////////////////////////////////////
//				'InitBilder'							  //
//														  //
// Die Bitmap aus der resource.h werden in Variablen      //
// geladen.												  //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 03.03.2001						  //	
//														  //	
//	letzte Änderung : 04.08.2001						  //	
//														  //	
/
//														  //	
////////////////////////////////////////////////////////////
extern bool InitBilder(ProgrammInformation *info)
{
	(*info).Bilder.Leer				= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_LEER));
	(*info).Bilder.Eingang			= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_EINGANG));
	(*info).Bilder.Ausgang			= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_AUSGANG));
	(*info).Bilder.Merker_Ausgang	= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_MERKER_AUSGANG));
	(*info).Bilder.Merker_Eingang	= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_MERKER_EINGANG));
	(*info).Bilder.Register_Ausgang = LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_REGISTER_AUSGANG));
	(*info).Bilder.Register_Merker  = LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_REGISTER_MERKER));
	(*info).Bilder.Timer			= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_TIMER));
	(*info).Bilder.Verknuepft		= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_VERKNUEPFT));
	(*info).Bilder.HIGH				= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_HIGH));
	(*info).Bilder.Negiert			= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_NEGIERT));
	//makro eingefügt
	(*info).Bilder.MAKRO			= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_MAKRO));
	// neue Module
	(*info).Bilder.R_Ausgang		= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_R_AUSGANG));
	(*info).Bilder.EA_Ausgang		= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_EA_AUS));
	(*info).Bilder.EA_Eingang		= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_EA_EIN));
	//04_08_01 POR hinzugefügt
	(*info).Bilder.POR				= LoadBitmap((*info).hInstance,MAKEINTRESOURCE(ID_PowerOnReset));
	HintergrungFarbe.Eingang = CreateSolidBrush(RGB(213,234,138));	// pastell gruen
	HintergrungFarbe.Ausgang = CreateSolidBrush(RGB(249,188,179));	// pastell rot
	HintergrungFarbe.Merker  = CreateSolidBrush(RGB(136,209,244));	 // pastell blau
	HintergrungFarbe.Bloecke = CreateSolidBrush(RGB(252,251,220));	// pastell gelb	
	HintergrungFarbe.Timer   = CreateSolidBrush(RGB(237,211,231));	//	grau
	return TRUE;
};

////////////////////////////////////////////////////////////
//				'KillBilder'							  //
//														  //
// Die Bitmap müssen beim Programmende wieder freigegeben //
// werden.												  //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 03.03.2001						  //	
//														  //	
//	letzte Änderung : 04.08.2001						  //	
//														  //	
						  //	
////////////////////////////////////////////////////////////
extern bool KillBilder (ProgrammInformation *info)
{
	DeleteObject((*info).Bilder.Leer);
	DeleteObject((*info).Bilder.Ausgang);
	DeleteObject((*info).Bilder.Eingang);
	DeleteObject((*info).Bilder.Merker_Ausgang);
	DeleteObject((*info).Bilder.Merker_Eingang);
	DeleteObject((*info).Bilder.Register_Ausgang);
	DeleteObject((*info).Bilder.Register_Merker);
	DeleteObject((*info).Bilder.Timer);
	DeleteObject((*info).Bilder.Verknuepft);
	DeleteObject((*info).Bilder.HIGH);
	DeleteObject((*info).Bilder.Negiert);
	DeleteObject((*info).Bilder.R_Ausgang);
	DeleteObject((*info).Bilder.EA_Ausgang);
	DeleteObject((*info).Bilder.EA_Eingang);
	DeleteObject((*info).Bilder.MAKRO);
	//04_08_01 POR hinzugefügt
	DeleteObject((*info).Bilder.POR);
	return TRUE;
};

////////////////////////////////////////////////////////////
//				'BlockEinreihen'						  //
//														  //
// Beim erstellen der Module für die Modulauswahl müssen  //
// angereiht werden. Dabei wird einfach das letzte		  //
// gespeicherte Modul genommen un daraus die neuen		  //
// Koordinaten ermittelt und eingetragen.				  //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 26.02.2001						  //	
//														  //	
//	letzte Änderung : 04.08.2001						  //	
//												  //	
//														  //	
////////////////////////////////////////////////////////////
extern bool BlockEinreihen(ProgrammInformation *info,HGLOBAL SpeicherHandle,int pos,HWND handle)
{
	BlockSpeicherFeld *Zeiger;
	int a,b,i;
	RECT rect;
	Zeiger = (BlockSpeicherFeld *) GlobalLock(SpeicherHandle);
	(*(Zeiger + pos)).BausteinHandle = handle;
	// Die dazugehörigen Informationen raussuchen
	for (i = 1; handle != (*(Zeiger + i)).BausteinHandle;i++);
		if(i > 1)
			{
			GetClientRect((*(Zeiger + i - 1)).BausteinHandle,&rect);
			(*(Zeiger + i )).yPosition = INT((rect.bottom + ((*(Zeiger +i -1)).yPosition * ((*info).Raster / 2)) + 10) 
											/ ((*info).Raster / 2));
			}
		else (*(Zeiger + i)).yPosition = INT(10  / ((*info).Raster / 2));

		//Die Modulgroesse anpassen
		switch ((*(Zeiger + i)).Bausteintyp)
			{
			case Eingang :
			case Ausgang :
			case R_Ausgang :
			case Merker_Eingang :
			case Merker_Ausgang :
				{
				a = 7; // Die grösse des Bildes im Rastermass
				b = 2;
				break;
				};
			case Register_Merker :
			case Register_Ausgang :
				{
				a =  9;
				b = 10;
				break;
				};
			case Timer :
				{
				a = 7;
				b = 4;
				break;
				};
			case XOR :
			case Und :
			case Oder :
			case MAKRO :
				{
				a = 7;
				b = 7;
				break;
				};
			case High	:
			case POR	:	//04_08_01 POR hinzugefügt
				{
				a = 2;
				b = 2;
				break;
				};
			case EA_Eingang:
				{
				// Abfrage, da dieser Port nur bei Speedy vorhanden ist
				if ((*info).SPS_Typ == SPEEDY)
					{
					a = 7;
					b = 2;
					}
				else
					{
					a = 0;
					b = 0;
					};
				break;
				};
			case EA_Ausgang:
				{
				// Abfrage, da dieser Port nur bei Speedy vorhanden ist
				if ((*info).SPS_Typ == SPEEDY)
					{
					a = 5;
					b = 7;
					}
				else
					{
					a = 0;
					b = 0;
					};
				break;
				};
			default :
				{
				a = 0;
				b = 0;
				break;
				};
			};
		// Koordinaten festlegen
	MoveWindow(	handle,	((*(Zeiger + i)).xPosition * (*info).Raster),
						((*(Zeiger + i)).yPosition * (*info).Raster / 2),
						a * (*info).Raster,
						b * (*info).Raster,
						TRUE);
	GetClientRect(handle,&rect);
	GlobalUnlock(SpeicherHandle);
	return TRUE;
};

////////////////////////////////////////////////////////////
//				'BlockSichtbarImFenster'				  //
//														  //
// Diese Funktion diente ebenfalls zum abgrenzen von      //
// Blöcken, Jedoch wegen Problem mit dem Handling der     //
// Handles, wurde diese nicht weiter verfolgt.			  //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 27.02.2001						  //	
//														  //	
//	letzte Änderung : 27.03.2001						  //	
//														  //	
							  //	
////////////////////////////////////////////////////////////
extern bool BlockSichtbarImFenster(ProgrammInformation *info,HGLOBAL SpeicherHandle,HWND handle)
{
	RECT rect,gueltiges_rect,Modul_rect;
	int i;

	BlockSpeicherFeld *Zeiger;
	Zeiger = (BlockSpeicherFeld *) GlobalLock(SpeicherHandle);
	// überprüfen, ob vorhanden und die eigene Position
	for ( i = 1; ((i < (*Zeiger).Bausteinnummer) && (handle != (*(Zeiger + i)).BausteinHandle)); i++);
	if ( i == (*Zeiger).Bausteinnummer)
		{
		GlobalUnlock(SpeicherHandle);
		return FALSE;
		}
	int zwischen;
	// Grenzbereich festlegen
	GetClientRect((*info).handles.Zeichnenfenster,&rect);
	GetClientRect(handle,&Modul_rect);
	zwischen = INT(Modul_rect.bottom * 2 / (*info).Raster);
	gueltiges_rect.top		=	(*info).Zeichenblatt.VertPos - 
								zwischen;
	zwischen = 0;//INT(rect.bottom * 2/ (*info).Raster);	
	gueltiges_rect.bottom	=	(*info).Zeichenblatt.VertPos + 
								zwischen;
	zwischen = INT(Modul_rect.right / (*info).Raster);
	gueltiges_rect.left		=	(*info).Zeichenblatt.HorzPos -
								zwischen;
	zwischen = 0;//INT(rect.right / (*info).Raster);
	gueltiges_rect.right	=	(*info).Zeichenblatt.HorzPos + 
								zwischen;
	// Abfrage ob dieser im erlaubten Bereich liegt
	if (((*(Zeiger +i)).xPosition > gueltiges_rect.left   ) &&
		((*(Zeiger +i)).yPosition > gueltiges_rect.top    ) &&
		((*(Zeiger +i)).xPosition < gueltiges_rect.right  ) &&
		((*(Zeiger +i)).yPosition < gueltiges_rect.bottom ) )
	{
		GlobalUnlock(SpeicherHandle);
		return TRUE;
	}
	else
	{
		GlobalUnlock(SpeicherHandle);
		return FALSE;
	}
	GlobalUnlock(SpeicherHandle);
	return FALSE;
};

////////////////////////////////////////////////////////////
//				'BlockZeichnen'							  //
//														  //
// Kommt vom Hauptprogramm die Message zum Neuzeichnen,   //
// hat man zuerst nur den Handle. Dieser wird dann aus der//
// Liste herausgesucht und eintsprechend dem Typ neugezei.//
// Die LokVar hat nur am Anfang eine Sonderbehandlung	  //
// wegen dem aktiviert zeichnen und weil nicht die Werte  //
// aus dem Speicher genommen werden.					  //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 01.03.2001						  //	
//														  //	
//	letzte Änderung : 04.08.2001						  //	
//														  //	

//														  //	
////////////////////////////////////////////////////////////
extern bool BlockZeichnen(ProgrammInformation *info,HGLOBAL SpeicherHandle,
						  HWND handle,WListe ListeTyp,bool Lokale,BlockSpeicherFeld *LokVar)
{

  HDC               Abbhdc;
	HBITMAP	          Abbildung;
  BlockSpeicherFeld aktuellerBlock;

  if (!BlockDatenHolen(  info, SpeicherHandle, handle, Lokale, LokVar, &aktuellerBlock))
    return FALSE;
  // Erstellen der Bitmap
  liefereAbbildung           (&Abbhdc, &Abbildung, &aktuellerBlock, info);
  // Negierung in das Bitmap Zeichnen
  Negierung_in_Bitmap_Zeichen(&Abbhdc, &Abbildung, &aktuellerBlock, info);
  // Evt. Texte einfuegen
  TextEinfuegen              (&Abbhdc, &Abbildung, &aktuellerBlock, info);
  // Aktivierung Zeichnen
  if (aktuellerBlock.aktiviert)
    zeichneaktiviert(&Abbhdc, &Abbildung);
  // Und Bitmap ins Fenster Zeichnen!!
  Bitmap_ins_Fenster         (&Abbhdc, &Abbildung, &aktuellerBlock,handle,ListeTyp,info);

  // Objekte loeschen, da diese sonst ihre Gueltigkeit verlieren
  DeleteObject(Abbildung);
  DeleteDC(Abbhdc);
	return TRUE;
};

bool BlockDatenHolen(  ProgrammInformation *info,HGLOBAL SpeicherHandle
                     , HWND handle,bool Lokale,BlockSpeicherFeld *LokVar
                     , BlockSpeicherFeld *aktuellerBlock)
{

 	int i = 1, AnzElement;
	BlockSpeicherFeld *Zeiger;
	if (Lokale)
	{
		kopiereBlock(aktuellerBlock,LokVar);
	}
	else
	{
		Zeiger = (BlockSpeicherFeld *) GlobalLock(SpeicherHandle);
    AnzElement = Zeiger->Bausteinnummer; 
    Zeiger ++;  // Um einen erhoehen, weil an der ersten Stelle Array Infos stehen!
		// Die dazugehörigen Informationen raussuchen
		for (i = 1; (handle != Zeiger->BausteinHandle) ;i++, Zeiger++)
			if(i >= AnzElement)
				return FALSE;
		kopiereBlock(aktuellerBlock,Zeiger );
		GlobalUnlock(SpeicherHandle);
	};
  return TRUE;
}

bool Bitmap_ins_Fenster(HDC *Abbhdc, HBITMAP	*Abbildung, BlockSpeicherFeld *ModulDaten, HWND handle, WListe ListeTyp,	ProgrammInformation *info)
{
  HDC hdc;
 	RECT rect;
	PAINTSTRUCT ps;
	BITMAP bm;
  RECT ModulRect;
  // Variablen um Hintergrund zu ermitteln
  HBITMAP ModulHintergrund;
  HDC     ZeichenflaechHdc, HintergrundHdc;
  BITMAP  Modul_size;

  int i;
  int vertikal= 0; // Verschiebung in er Modulauswahl

  //Zeichnen-Konstukt fürs Modulfenster
	hdc = BeginPaint(handle,&ps);

  SetROP2(hdc,R2_XORPEN);

	//Grösse der vorhandenen Abbildung ermitteln
	GetObject(*Abbildung,sizeof(BITMAP), &bm);							
	//Wenn die Zeile gescrollt wurde (Gilt nur fuer die Modulauswahl)
	if(ListeTyp == Auswahl)
	{
		vertikal = info->AuswahlLeiste.VertPos;
	}
  ModulRect.left   = ModulDaten->xPosition * info->Raster;
  ModulRect.top    = (ModulDaten->yPosition - vertikal) * info->Raster / 2;
  ModulRect.right  = INT(bm.bmWidth * info->Zoom);
  ModulRect.bottom = INT(bm.bmHeight * info->Zoom);

	MoveWindow(	handle
            ,	ModulRect.left
            ,	ModulRect.top
            ,	ModulRect.right
            ,	ModulRect.bottom
            ,	TRUE
            );
	GetClientRect(handle,&rect);
  //Bild Infos holen
 	if(ListeTyp != Auswahl)
  {
 	  GetObject(*Abbildung,sizeof(BITMAP), &Modul_size);							
    // Groesse Aendern
    Modul_size.bmWidth = ModulRect.right  - ModulRect.left;
    Modul_size.bmHeight= ModulRect.bottom - ModulRect.top ;
    // Bitmap Generieren
    ModulHintergrund = CreateBitmapIndirect(&Modul_size);
    HintergrundHdc   = CreateCompatibleDC(NULL);
    SelectObject(HintergrundHdc, ModulHintergrund);
    ZeichenflaechHdc = GetDC(info->handles.Zeichenblatt);
   BitBlt( HintergrundHdc
          , ModulRect.left, ModulRect.top
          , ModulRect.right - ModulRect.left, ModulRect.bottom - ModulRect.top
          , ZeichenflaechHdc
          , ModulDaten->xPosition, ModulDaten->yPosition
          , SRCAND
          );
    ReleaseDC(info->handles.Zeichenblatt,ZeichenflaechHdc);
  //Neues Bild einfügen und evt. erweitern
  // Zuerst den Hintergrund!
  //SetBkMode(*Abbhdc,TRANSPARENT);
  //  SetBkMode(hdc,TRANSPARENT);
  /*  StretchBlt(	hdc		
              , 0,0,rect.right,rect.bottom
              ,	HintergrundHdc
              , 0,0,rect.right,rect.bottom
              , SRCCOPY
              );*/
/*    BitBlt( hdc
          , 0, 0
          , rect.right, rect.bottom
          , ZeichenflaechHdc
          , 0, 0
          , SRCCOPY
          );*/
 /*   BitBlt( hdc
          , 0, 0
          , rect.right, rect.bottom
          , ZeichenflaechHdc
          , 0, 0
          , SRCCOPY
          );*/
/*  StretchBlt(	ZeichenflaechHdc		
            , 0,0,rect.right,rect.bottom
            ,	*Abbhdc	
            , 0,0,bm.bmWidth,bm.bmHeight
            , SRCAND
            );*/

  }
  if(ListeTyp != Auswahl)
  StretchBlt(	hdc		
            , 0,0,rect.right,rect.bottom
            ,	*Abbhdc
            , 0,0,bm.bmWidth,bm.bmHeight
            , SRCCOPY
            );
//  i=i;
  else
    StretchBlt(	hdc		
              , 0,0,rect.right,rect.bottom
              ,	*Abbhdc	
              , 0,0,bm.bmWidth,bm.bmHeight
              , SRCCOPY
              );

//  DeleteObject(ModulHintergrund);
  DeleteDC(HintergrundHdc);

	EndPaint(handle,&ps);
	UpdateWindow(handle);
  return TRUE;
}

bool erstelleStandardAbbildung(HBITMAP *ZBild, BlockSpeicherFeld *ModulDaten,ProgrammInformation *info)
{
  HDC hdc, hdcAbb;

	RECT AbBild_rect, Kasten, hilfsrect;

	int i;

	int Hoch,Breit;

	int BreiteMax = 112;

	hdc = GetDC(NULL);
	hdcAbb = CreateCompatibleDC(hdc);
  *ZBild = CreateCompatibleBitmap(	hdc
																	, INT(RasterMass * 7)
																	, INT(((RasterMass * 3 * (ModulDaten->AnzEingaenge - 1)) + (RasterMass * 4)))
				              					 );
  SelectObject(hdcAbb , *ZBild);

  AbBild_rect.left   = 0;
	AbBild_rect.top    = 0;
	Hoch =
	AbBild_rect.bottom = INT(((RasterMass * 3 * (ModulDaten->AnzEingaenge - 1)) + (RasterMass * 4)));
	Breit =
	AbBild_rect.right  = INT(RasterMass * 7);

	FillRect(hdcAbb,&AbBild_rect,(HBRUSH) GetStockObject (WHITE_BRUSH));

	// Der Rahmen
	Rectangle(hdcAbb,INT(RasterMass * 2),0,INT(RasterMass * 5),AbBild_rect.bottom);
	// Den Rahmen versärken
	Rectangle(hdcAbb,INT(RasterMass * 2) + 1,1,INT(RasterMass * 5) - 1,AbBild_rect.bottom - 1);

	// Die Füllfarbe
	Kasten.top = 0 + 2;
	Kasten.left = (INT(RasterMass * 2) + 2);
	Kasten.right =(INT(RasterMass * 5) - 2);
	Kasten.bottom = (AbBild_rect.bottom - 2);
  FillRect(hdcAbb,&Kasten,HintergrungFarbe.Bloecke);
	// Die Eingangspins
	for(i=0; i < ModulDaten->AnzEingaenge; i++)
	{
		hilfsrect.top    = INT(((RasterMass * 2) + (RasterMass * 3 * i) - 1));
		hilfsrect.left   = 0;
		hilfsrect.right = INT((RasterMass * 2));
		hilfsrect.bottom  = INT(((RasterMass * 2) + (RasterMass * 3 * i) + 1));
		FillRect(hdcAbb,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));
	};

	// Der Ausgangspin
	hilfsrect.top    = INT(((RasterMass * 3.5) - 1));
	hilfsrect.left   = INT(RasterMass * 5);
	hilfsrect.right =  INT(RasterMass * 7);
	hilfsrect.bottom  = INT(((RasterMass * 3.5) + 1));
	FillRect(hdcAbb,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));
	//Schrift wählen
	SelectObject (hdcAbb,info->Schrift.Schrift);
	SetBkMode(hdcAbb,TRANSPARENT);
	TextOut(hdcAbb,INT(RasterMass * 2) + 1,INT(RasterMass * 3),ModulDaten->Pin,3);

  DeleteDC(hdc);
	DeleteDC(hdcAbb);

	return TRUE;
}

bool TextEinfuegen(HDC *Abbhdc, HBITMAP *AbbBild, BlockSpeicherFeld *ModulDaten,ProgrammInformation *info)
{
 	KOORDINATE	TextPos;
  BITMAP bmrect;

  switch(ModulDaten->Bausteintyp)
  { //Zuerst die Festen Abbildungen
 		case Eingang :
    case Merker_Eingang :
    case R_Ausgang :
    {
			TextPos.x = INT( (RasterMass + 2)) - 1;
			TextPos.y = INT( (RasterMass / 2));
      break;
    }
    case Ausgang :
    case Merker_Ausgang :
    {
			TextPos.x = INT(((RasterMass * 3)) + 1);    
			TextPos.y = INT( (RasterMass / 2));
      break;
    }
    case Register_Merker :
    case Register_Ausgang :
    {
			TextPos.x = INT(((RasterMass * 5) + 2));
			TextPos.y = INT(((RasterMass * 4.5)));
      break;
    }
    case Timer :
    {
 			TextPos.x = INT((RasterMass * 2) + 4);
			TextPos.y = INT(((RasterMass * 2) + 1));
      break;
    }
    case EA_Eingang :
    {
			TextPos.x = INT( (RasterMass + 2)) - 2;
			TextPos.y = INT( (RasterMass / 2));
      break;
    }
    case EA_Ausgang :
    {
			TextPos.x = INT(((RasterMass * 2)) + 1);    
			TextPos.y = INT( (RasterMass * 1.5));
      break;
    }
    default :
    { 
      return TRUE;
      break;
    }
  };

	SetBkMode(*Abbhdc,TRANSPARENT);

	TextOut(*Abbhdc,TextPos.x,TextPos.y,ModulDaten->Pin,strlen(ModulDaten->Pin));	

  // Den Zusaetzlichen Text ausgeben!
  if(ModulDaten->TextDarstellen)
  { 
    RECT AbBild_rect;
 		GetObject(*AbbBild,sizeof(BITMAP), &bmrect);				//Mass bestimmen			
    SelectObject (*Abbhdc,info->Schrift.Schrift);           //Schrift neu setzen
    // Flaeche vorher einweissen
    AbBild_rect.left   = 0;
    AbBild_rect.top    = bmrect.bmHeight - 2 * RasterMass;
    AbBild_rect.bottom = bmrect.bmHeight;
    AbBild_rect.right  = bmrect.bmWidth;
   	FillRect(*Abbhdc,&AbBild_rect,(HBRUSH) GetStockObject (WHITE_BRUSH));

    TextOut(*Abbhdc,0,INT(bmrect.bmHeight - 1.5 * RasterMass),ModulDaten->Bezeichnung,strlen(ModulDaten->Bezeichnung));
  }

  return TRUE;

};

bool liefereAbbildung( HDC *Abbhdc, HBITMAP *Abbildung, BlockSpeicherFeld *ModulDaten, ProgrammInformation *info)
{
  HDC hdc, Bildhdc;
  BITMAP  bm_size;
  HBITMAP ZBild;  //Zichablage fuer ein Bitmap
  bool    zBild_loeschen=FALSE;
  //AllgemeinerZeichenHandel
  hdc = GetDC(info->handles.Zeichnenfenster);
  //Zeichenhandle fuers Bild erstellen
  *Abbhdc = CreateCompatibleDC(NULL);
  Bildhdc = CreateCompatibleDC(NULL);
  //Bitmap erstellen
  switch(ModulDaten->Bausteintyp)
  { //Zuerst die Festen Abbildungen
 		case Eingang :
    {
      GetObject(info->Bilder.Eingang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Eingang);
      break;
    }
    case Ausgang :
    {
      GetObject(info->Bilder.Ausgang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Ausgang);
      break;
    }
    case Merker_Ausgang :
    {
      GetObject(info->Bilder.Merker_Ausgang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Merker_Ausgang);
      break;
    }
    case Merker_Eingang :
    {
      GetObject(info->Bilder.Merker_Eingang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Merker_Eingang);
      break;
    }
    case Register_Merker :
    {
      GetObject(info->Bilder.Register_Merker,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Register_Merker);
      break;
    }
    case Register_Ausgang :
    {
      GetObject(info->Bilder.Register_Ausgang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Register_Ausgang);
      break;
    }
    case Timer :
    {
      GetObject(info->Bilder.Timer,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Timer);
      break;
    }
    case High :
    {
      GetObject(info->Bilder.HIGH,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.HIGH);
      break;
    }
    case R_Ausgang :
    {
      GetObject(info->Bilder.R_Ausgang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.R_Ausgang);
      break;
    }
    case EA_Eingang :
    {
      GetObject(info->Bilder.EA_Eingang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.EA_Eingang);
      break;
    }
    case EA_Ausgang :
    {
      GetObject(info->Bilder.EA_Ausgang,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.EA_Ausgang);
      break;
    }
//Makro
    case MAKRO :
    {
      GetObject(info->Bilder.MAKRO,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.MAKRO);
      break;
    }
    case POR :
    {
      GetObject(info->Bilder.POR,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.POR);
      break;
    }
    case Und :
    case Oder :
    case XOR :
    {
      erstelleStandardAbbildung(&ZBild,ModulDaten,info);
      GetObject(ZBild,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, ZBild);
      zBild_loeschen = TRUE;
      break;
    }
    default :
      {  
      GetObject(info->Bilder.Leer,sizeof(BITMAP), &bm_size);
      SelectObject(Bildhdc, info->Bilder.Leer);
      break;
    }
  };

  if(ModulDaten->TextDarstellen)
    bm_size.bmHeight += (2 * RasterMass);

  *Abbildung = CreateBitmapIndirect(&bm_size);
  SelectObject(*Abbhdc, *Abbildung);

  BitBlt(*Abbhdc,0,0,bm_size.bmWidth,bm_size.bmHeight,Bildhdc,0,0,SRCCOPY);
  DeleteDC(Bildhdc);
  if(zBild_loeschen)
    DeleteObject(ZBild);
  return TRUE;
};

////////////////////////////////////////////////////////////
//				'NegierungZeichen'						  //
//														  //
// Hier wird für jeden ModulTyp die Negierung, wenn		  //
// vorhanden, gezeichnet.						          //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 18.04.2001						  //	
//														  //	
//	letzte Änderung : 20.06.2001						  //	
//														  //	
							  //	
////////////////////////////////////////////////////////////
bool NegierungZeichen(HDC hdc,BlockSpeicherFeld *BlockZeiger,ProgrammInformation *info)
{
	int i;
	RECT BlockRect,hilfsrect;
	GetClientRect((*BlockZeiger).BausteinHandle,&BlockRect);
	// Zuerst die Eingänge. Da die Lage unterschiedlich muss hier differentiert werden
	switch ((*BlockZeiger).Bausteintyp)
		{
		case Ausgang			:		
		case Merker_Ausgang		:
			{
			if((*BlockZeiger).NegEingang[0])
				{
				SelectObject(hdc,GetStockObject(BLACK_PEN));
				hilfsrect.top     = (*info).Raster - ((*info).Raster / 2);
				hilfsrect.bottom  = (*info).Raster + ((*info).Raster / 2);
				hilfsrect.left    = (*info).Raster;
				hilfsrect.right   = (*info).Raster * 2;
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};
			break;
			};
		case Timer				:
			{
			if((*BlockZeiger).NegEingang[0])
				{
				SelectObject(hdc,GetStockObject(BLACK_PEN));
				hilfsrect.top     = (2 * (*info).Raster) - ((*info).Raster / 2);
				hilfsrect.bottom  = (2 * (*info).Raster) + ((*info).Raster / 2);
				hilfsrect.left    = (*info).Raster;
				hilfsrect.right   = (*info).Raster * 2;
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};
			break;
			};
		case Register_Merker	:
		case Register_Ausgang	:
			{
			for (i = 0; i < (*BlockZeiger).AnzEingaenge; i++)
				if((*BlockZeiger).NegEingang[i])
				{
				SelectObject(hdc,GetStockObject(BLACK_PEN));					
				hilfsrect.top     = INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) - ((*info).Raster / 2)));
				hilfsrect.left    = (*info).Raster;
				hilfsrect.right   = (*info).Raster * 2;
				hilfsrect.bottom  = INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) + ((*info).Raster / 2)));
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};
			break;
			};
		case Oder				:
		case XOR				:
		case Und				:
		{
			for (i = 0; i < (*BlockZeiger).AnzEingaenge; i++)
			{
				if((*BlockZeiger).NegEingang[i])
				{
  				// Die Negierung
					hilfsrect.top     = (INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) - ((*info).Raster / 2))));
					hilfsrect.left    = (*info).Raster;
					hilfsrect.right   = (*info).Raster * 2;
					hilfsrect.bottom  = (INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) + ((*info).Raster / 2))));
          FillRect(hdc,&hilfsrect,(HBRUSH) GetStockObject (WHITE_BRUSH));
					//SelectObject(hdc,GetStockObject(BLACK_PEN));					
					Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};
			};
			break;
		};
		case EA_Ausgang			:
			{
			for (i = 0; i < (*BlockZeiger).AnzEingaenge; i++)
				{
				if((*BlockZeiger).NegEingang[i])
					{
					SelectObject(hdc,GetStockObject(BLACK_PEN));					
					}
				else
					SelectObject(hdc,GetStockObject(WHITE_PEN));
				// Die Negierung
				hilfsrect.top     = INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) - ((*info).Raster / 2)));
				hilfsrect.left    = (*info).Raster;
				hilfsrect.right   = (*info).Raster * 2;
				hilfsrect.bottom  = INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) + ((*info).Raster / 2)));
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);

				// Den Anschluss nachzeichnen
				hilfsrect.top    = INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) - (2 * (*info).Zoom)));
				hilfsrect.left   = (*info).Raster;
				hilfsrect.right = INT(((*info).Raster * 2));
				hilfsrect.bottom  = INT((((*info).Raster * 2) + ((*info).Raster * 3 * i) + (2 * (*info).Zoom)));
				if(!(*BlockZeiger).NegEingang[i])
					FillRect(hdc,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));	
				};
			break;

			};
		};
	// Dann die Ausgänge !! Da die Ausgänge teilweise verschieden liegen, muss hier differentiert werden.
	switch ((*BlockZeiger).Bausteintyp)
		{
		case Eingang		:
		case Merker_Eingang	:
		case High			:
		case R_Ausgang		:
		case EA_Eingang		:
		case MAKRO          :
		case POR			:	//04_08_01 POR hinzugefügt
			{
			if((*BlockZeiger).NegAusgang[0])
				{
				SelectObject(hdc,GetStockObject(BLACK_PEN));
				hilfsrect.top     = (*info).Raster - ((*info).Raster / 2);
				hilfsrect.bottom  = (*info).Raster + ((*info).Raster / 2);
				hilfsrect.left    = BlockRect.right - (2 *(*info).Raster);
				hilfsrect.right   = BlockRect.right - (*info).Raster;
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};	
			break;
			};
		case Timer			:
			{
			if((*BlockZeiger).NegAusgang[0])
				{
				SelectObject(hdc,GetStockObject(BLACK_PEN));
				hilfsrect.top     = (2 * (*info).Raster) - ((*info).Raster / 2);
				hilfsrect.bottom  = (2 * (*info).Raster) + ((*info).Raster / 2);
				hilfsrect.left    = BlockRect.right - (2 *(*info).Raster);
				hilfsrect.right   = BlockRect.right - (*info).Raster;
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};	
			break;
			};
		case Oder			:
		case XOR			:
		case Und			:
		{
			if((*BlockZeiger).NegAusgang[0])
			{
				SelectObject(hdc,GetStockObject(BLACK_PEN));					
				hilfsrect.top     = 3 * (*info).Raster;
				hilfsrect.left    = BlockRect.right - (2 *(*info).Raster);
				hilfsrect.right   = BlockRect.right - (*info).Raster;
				hilfsrect.bottom  = 4 * (*info).Raster;
				Ellipse(hdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
			};
				break;
		};
		};
	return TRUE;
};

bool Negierung_in_Bitmap_Zeichen(HDC *Abbhdc,HBITMAP *AbbBild,BlockSpeicherFeld *ModulDaten,ProgrammInformation *info)
{

  RECT hilfsrect;

  int i;
  BITMAP bm_size;

	SelectObject(*Abbhdc,GetStockObject(BLACK_PEN));
  SetBkMode(*Abbhdc,TRANSPARENT);

  //Zuerts die Eingaenge
  switch (ModulDaten->Bausteintyp)
	{
    case Oder				:
    case XOR				:
		case Und				:
		case Register_Merker	:
		case Register_Ausgang	:
 		case EA_Ausgang			:
		{
			for (i = 0; i < ModulDaten->AnzEingaenge; i++)
			{
				if(ModulDaten->NegEingang[i])
				{
  				// Die Negierung
					hilfsrect.top     = (INT(((RasterMass * 2) + (RasterMass * 3 * i) - (RasterMass / 2))));
					hilfsrect.left    = RasterMass;
					hilfsrect.right   = RasterMass * 2;
					hilfsrect.bottom  = (INT(((RasterMass * 2) + (RasterMass * 3 * i) + (RasterMass / 2))));
					Ellipse(*Abbhdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};
			};
			break;
		}
 		case Ausgang			:		
		case Merker_Ausgang		:
		{
			if(ModulDaten->NegEingang[0])
			{
				hilfsrect.top     = RasterMass - (RasterMass / 2);
				hilfsrect.bottom  = RasterMass + (RasterMass / 2);
				hilfsrect.left    = RasterMass;
				hilfsrect.right   = RasterMass * 2;
				Ellipse(*Abbhdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};
			break;
			};
		case Timer				:
		{
			if(ModulDaten->NegEingang[0])
			{
				hilfsrect.top     = (2 * RasterMass) - (RasterMass / 2);
				hilfsrect.bottom  = (2 * RasterMass) + (RasterMass / 2);
				hilfsrect.left    = RasterMass;
				hilfsrect.right   = RasterMass * 2;
				Ellipse(*Abbhdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
			};
			break;
		};
  };

	// Dann die Ausgänge !! Da die Ausgänge teilweise verschieden liegen, muss hier differentiert werden.
	switch (ModulDaten->Bausteintyp)
	{
		case Eingang		:
		case Merker_Eingang	:
		case High			:
		case R_Ausgang		:
		case EA_Eingang		:
		case MAKRO          ://nachträglich makro eingefügt
		case POR			:	//04_08_01 POR hinzugefügt
		{
			if(ModulDaten->NegAusgang[0])
			{
        GetObject(*AbbBild,sizeof(BITMAP), &bm_size);
				hilfsrect.top     = INT(RasterMass * 0.5);
				hilfsrect.bottom  = INT(RasterMass * 1.5);
				hilfsrect.left    = bm_size.bmWidth - (2 * RasterMass);
				hilfsrect.right   = bm_size.bmWidth - RasterMass;
				Ellipse(*Abbhdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
			};	
			break;
		};
		case Timer			:
		{
			if(ModulDaten->NegAusgang[0])
			{
        GetObject(*AbbBild,sizeof(BITMAP), &bm_size);
				hilfsrect.top     = INT(1.5 * RasterMass);
				hilfsrect.bottom  = INT(2.5 * RasterMass);
				hilfsrect.left    = bm_size.bmWidth - (2 * RasterMass);
				hilfsrect.right   = bm_size.bmWidth - RasterMass;
				Ellipse(*Abbhdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
				};	
			break;
		};
		case Oder			:
		case XOR			:
		case Und			:
		{
			if(ModulDaten->NegAusgang[0])
			{
        GetObject(*AbbBild,sizeof(BITMAP), &bm_size);
				hilfsrect.top     = 3 * RasterMass;
				hilfsrect.left    = bm_size.bmWidth - (2 * RasterMass);
				hilfsrect.right   = bm_size.bmWidth - RasterMass;
				hilfsrect.bottom  = 4 * RasterMass;
				Ellipse(*Abbhdc,hilfsrect.left,hilfsrect.top,hilfsrect.right,hilfsrect.bottom);
			};
				break;
		};
  };
	return TRUE;
};

////////////////////////////////////////////////////////////
//				'zeichneaktiviert'						  //
//														  //
// Die Module in der lokalen Variable müssen aktiv		  //
// gezeichnet werden.								      //
//														  //
////////////////////////////////////////////////////////////
//														  //	
//	erstellt am     : 07.03.2001						  //	
//														  //	
//	letzte Änderung : 12.03.2001						  //	
//														  //	

//														  //	
////////////////////////////////////////////////////////////
bool zeichneaktiviert(HDC *Abbhdc, HBITMAP *Abbildung)

{
	RECT hilfsrect;
  BITMAP bm_size;
	int groesse = 4;
	GetObject(*Abbildung,sizeof(BITMAP), &bm_size);
	// Oben links
	hilfsrect.top    = 0;
	hilfsrect.left   = 0;
	hilfsrect.right  = groesse;
	hilfsrect.bottom = groesse;
	FillRect(*Abbhdc,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));
	// Oben rechts
	hilfsrect.left  = bm_size.bmWidth - groesse;
	hilfsrect.right = bm_size.bmWidth;
	FillRect(*Abbhdc,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));
	// unten rechts
	hilfsrect.top    = bm_size.bmHeight - groesse;
	hilfsrect.bottom = bm_size.bmHeight;
	FillRect(*Abbhdc,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));
	// unten links
	hilfsrect.left  = 0;
	hilfsrect.right = groesse;
	FillRect(*Abbhdc,&hilfsrect,(HBRUSH) GetStockObject (BLACK_BRUSH));
	return TRUE;
}

////////////////////////////////////////////////////////////
//				'kopiereBlock'							                    //
//														                            //
// Die ist nur eine Unterfunktion, um alle Element aus dem//
// Speicher in ein lokaleVariable zum Weiterverarbeiten   //
// umzukopieren.                                          //
//														                            //
////////////////////////////////////////////////////////////
//														                            //	
//	erstellt am     : 08.06.2001						              //	
//														                            //	
//	letzte Änderung : 08.06.2001						              //	
//														                            //	

//														                            //	
////////////////////////////////////////////////////////////
bool kopiereBlock(BlockSpeicherFeld *LokZeiger, BlockSpeicherFeld *hZeiger)
{
	int i;
	(*LokZeiger).aktiviert		= (*hZeiger).aktiviert;
	(*LokZeiger).AnzEingaenge	= (*hZeiger).AnzEingaenge;
	(*LokZeiger).BausteinHandle = (*hZeiger).BausteinHandle;
	(*LokZeiger).Bausteinnummer = (*hZeiger).Bausteinnummer;
	(*LokZeiger).Bausteintyp	= (*hZeiger).Bausteintyp;
	strcpy((*LokZeiger).Bezeichnung,(*hZeiger).Bezeichnung);
	for (i = 0; i < 8; i++)
		{
		(*LokZeiger).NegAusgang[i] = (*hZeiger).NegAusgang[i];
		(*LokZeiger).NegEingang[i] = (*hZeiger).NegEingang[i];
		};
	strcpy((*LokZeiger).Pin, (*hZeiger).Pin);
	(*LokZeiger).TextDarstellen = (*hZeiger).TextDarstellen;
	(*LokZeiger).xPosition = (*hZeiger).xPosition;
	(*LokZeiger).yPosition = (*hZeiger).yPosition;
	return TRUE;
};

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

PS: Und ohne wenigstens ein paar Code-Segmente zu sehen, kann dir hier wohl niemand wirklich helfen. Deine Oberfläche sieht stark nach "selbstgebaut" aus, und meine Kristallkugel ist immer noch in Reparatur (die Werkstatt findet den Fehler einfach nicht), also hast DU höhere Chancen, die richtige Stelle zu erraten als jeder andere.

was mach ich nun
der quellcode geht weiter