MFG
Prim3

Du machst einen Zählervariable und zähst die hoch.
Wenn sie 20 erreicht hat dann machst du eben was du dann machen möchtest.

Oder meinst Du wie man eine Grafik bewegt?

Danke

Anfänger

Danke

Besten Dank

Bis morgen

Prim3

int x = 0;

void func()
{
  x++;
}

void funcz()
{

for(int i = 0;i<= 100;++i)
{
func();

// Schauen ob x bereits 50 ist und dann die Schleife abbrechen
if(x == 50) break;
}

}

// VisuView.cpp : Implementierung der Klasse CVisuView
//

#include "stdafx.h"
#include "Visu.h"

#include "VisuDoc.h"
#include "VisuView.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CVisuView

IMPLEMENT_DYNCREATE(CVisuView, CView)

BEGIN_MESSAGE_MAP(CVisuView, CView)
	//{{AFX_MSG_MAP(CVisuView)
	ON_WM_TIMER()
	ON_WM_CREATE()
	ON_WM_LBUTTONDOWN()
	ON_WM_RBUTTONDOWN()
	ON_WM_MOVE()
	//}}AFX_MSG_MAP
	// Standard-Druckbefehle
	ON_COMMAND(ID_FILE_PRINT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_DIRECT, CView::OnFilePrint)
	ON_COMMAND(ID_FILE_PRINT_PREVIEW, CView::OnFilePrintPreview)
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CVisuView Konstruktion/Destruktion

CVisuView::CVisuView()
{		
	m_XRect=0;
	// ZU ERLEDIGEN: Hier Code zur Konstruktion einfügen,

}

CVisuView::~CVisuView()
{
}

BOOL CVisuView::PreCreateWindow(CREATESTRUCT& cs)
{
	// ZU ERLEDIGEN: Ändern Sie hier die Fensterklasse oder das Erscheinungsbild, indem Sie
	//  CREATESTRUCT cs modifizieren.

	return CView::PreCreateWindow(cs);
}

/////////////////////////////////////////////////////////////////////////////
// CVisuView Zeichnen

void CVisuView::OnDraw(CDC* pDC)
{	int Wert; 
	int cx,cy;

	CPen GruenStift, *pOldPen;
	GruenStift.CreatePen(PS_SOLID,2,RGB(0,0,0));

	CBrush GruenBrush, *pOldBrush;
	GruenBrush.CreateSolidBrush(RGB(0,255,0));

	CBrush RotBrush, *pNewBrush;
	RotBrush.CreateSolidBrush(RGB(255,0,0));

	CBrush GelbBrush, *pNew1Brush;
	GelbBrush.CreateSolidBrush(RGB(255,255,0));

	CBrush OrangeBrush, *pNew2Brush;
	OrangeBrush.CreateSolidBrush(RGB(255,165,0));

	CBrush SteelBlueBrush, *pNew3Brush;
	SteelBlueBrush.CreateSolidBrush(RGB(70,130,180));

	CBrush SpringGreenBrush, *pNew4Brush;
	SpringGreenBrush.CreateSolidBrush(RGB(250,145,0));

	CBrush ForestBrush, *pNew5Brush;
	ForestBrush.CreateSolidBrush(RGB(34,139,34));

	CBrush PinkBrush, *pNew6Brush;
	PinkBrush.CreateSolidBrush(RGB(255,20,147));

	CBrush VioletBrush, *pNew7Brush;
	VioletBrush.CreateSolidBrush(RGB(148,0,211));

	CBrush LavenderBrush, *pNew8Brush;
	LavenderBrush.CreateSolidBrush(RGB(230,230,250));

	Wert=50;

	CString str;

		CRect rectclient,rectRahmen,rectSchlitten,rect1,rect2,rect3,rect4,rect5,rect6,rect7;

	GetClientRect(&rectclient);

                          //Deklaration Rechteckclient//

	str.Format("Wert=%d",rectclient.bottom);           
	cx=rectclient.right;
	cy=rectclient.bottom;

	rect1.top=cy*0.05;
	rect1.bottom=cy*0.95;

	rect1.right=cx*0.95;
	rect1.left=cx*0.9;

	rect2.top=cy*0.05;
	rect2.bottom=cy*0.15;

	rect2.right=cx*0.9;
	rect2.left=cx*0.6;

	rect3.top=cy*0.05;
	rect3.bottom=cy*0.95;

	rect3.right=cx*0.6;
	rect3.left=cx*0.55;

	rect4.top=cy*0.85;
	rect4.bottom=cy*0.95;

	rect4.right=cx*0.9;
	rect4.left=cx*0.6;

	rect5.top=cy*0.2;
	rect5.bottom=cy*0.3;

	rect5.right=cx*0.55;
	rect5.left=cx*0.3;

	rect6.top=cy*0.3;
	rect6.bottom=cy*0.65;

	rect6.right=cx*0.35;
	rect6.left=cx*0.3;

	rect7.top=cy*0.65;
	rect7.bottom=cy*0.75;

	rect7.right=cx*0.55;
	rect7.left=cx*0.3;

	rectRahmen.top=cy*0.98;
	rectRahmen.bottom=cy*0.02;

	rectRahmen.right=cx*0.98;
	rectRahmen.left=cx*0.02;

	rectSchlitten.top=cy*0.5-m_XRect;          ///Ausführung Verschieben////
	rectSchlitten.bottom=cy*0.4-m_XRect;

	rectSchlitten.right=cx*0.95;
	rectSchlitten.left=cx*0.9;

	pNew8Brush=pDC->SelectObject(&LavenderBrush);

	pDC->Rectangle(&rectRahmen);

    pNewBrush=pDC->SelectObject(&RotBrush);   

	pDC->Rectangle(&rect1);                   //Ausführungsbefehle//

	pNew1Brush=pDC->SelectObject(&GelbBrush); 

	pDC->Rectangle(&rect2);

	pNew2Brush=pDC->SelectObject(&OrangeBrush); 

	pDC->Rectangle(&rect3);

	pNew3Brush=pDC->SelectObject(&SteelBlueBrush); 

	pDC->Rectangle(&rect4);

	pNew4Brush=pDC->SelectObject(&SpringGreenBrush); 

	pDC->Rectangle(&rect5);

	pNew5Brush=pDC->SelectObject(&ForestBrush); 

	pDC->Rectangle(&rect5);

	pNew6Brush=pDC->SelectObject(&PinkBrush); 

	pDC->Rectangle(&rect6);

	pNew7Brush=pDC->SelectObject(&VioletBrush); 

	pDC->Rectangle(&rect7);

	pDC->TextOut(250,20,"Visualisierung einer Fertigungs-Strasse");

	pOldPen=pDC->SelectObject(&GruenStift);

	pOldBrush=pDC->SelectObject(&GruenBrush);

	pDC->Rectangle(&rectSchlitten);

	str.Format("Wert=%d",rectclient.right);           ///Rahmen Abmessung/////

	pDC->TextOut (100,50,str);

	str.Format("Wert=%d",rectclient.bottom);

	pDC->TextOut (170,50,str);

	pDC->SelectObject(pOldPen);

	pDC->SelectObject(pOldBrush);

	CVisuDoc* pDoc = GetDocument();
	ASSERT_VALID(pDoc);
	// ZU ERLEDIGEN: Hier Code zum Zeichnen der ursprünglichen Daten hinzufügen
}

/////////////////////////////////////////////////////////////////////////////
// CVisuView Drucken

BOOL CVisuView::OnPreparePrinting(CPrintInfo* pInfo)
{
	// Standardvorbereitung
	return DoPreparePrinting(pInfo);
}

void CVisuView::OnBeginPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// ZU ERLEDIGEN: Zusätzliche Initialisierung vor dem Drucken hier einfügen
}

void CVisuView::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
	// ZU ERLEDIGEN: Hier Bereinigungsarbeiten nach dem Drucken einfügen
}

/////////////////////////////////////////////////////////////////////////////
// CVisuView Diagnose

#ifdef _DEBUG
void CVisuView::AssertValid() const
{
	CView::AssertValid();
}

void CVisuView::Dump(CDumpContext& dc) const
{
	CView::Dump(dc);
}

CVisuDoc* CVisuView::GetDocument() // Die endgültige (nicht zur Fehlersuche kompilierte) Version ist Inline
{
	ASSERT(m_pDocument->IsKindOf(RUNTIME_CLASS(CVisuDoc)));
	return (CVisuDoc*)m_pDocument;
}
#endif //_DEBUG

/////////////////////////////////////////////////////////////////////////////
// CVisuView Nachrichten-Handler

void CVisuView::OnTimer(UINT nIDEvent) 
{
	Beep(750,100);
	m_XRect=m_XRect+5;                                         //Deklaration Verschieben//
	Invalidate();	                                       		//Deklaration Neuzeichnen//
	CView::OnTimer(nIDEvent);
}

int CVisuView::OnCreate(LPCREATESTRUCT lpCreateStruct) 
{
	if (CView::OnCreate(lpCreateStruct) == -1)
		return -1;

	return 0;
}

void CVisuView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	SetTimer(1,300,NULL);	
	CView::OnLButtonDown(nFlags, point);
}

void CVisuView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	KillTimer(1);	
	CView::OnRButtonDown(nFlags, point);
}

void CVisuView::OnMove(int x, int y) 
{
	CView::OnMove(x, y);

	// TODO: Code für die Behandlungsroutine für Nachrichten hier einfügen

}

Habe hier eine Grafik die ich mit einem Timer auf der X-Achse nach Oben bewege. Diese möchte ich nun nach dem 20sten Takt auf die Y-Achse umsteuern und nach links laufen lassen.

Du hast X und Y getauscht!
X ist rechts-links und Y ist hoch-runter.
Ich habe es so angewendet, wie man es in Mathe lernt.

Ich kürze mal, damit du die Änderungen auch findest.

/////////////////////////////////////////////////////////////////////////////
// CVisuView Nachrichten-Handler

void CVisuView::OnTimer(UINT nIDEvent) 
{
	if (m_nY < 20)
		m_nY++; // runter bewegen
	else
		m_nX++; // Seitlich bewegen
	Beep(750,100);
	m_XRect=m_XRect+5;                                         //Deklaration Verschieben//
	Invalidate();	                                       		//Deklaration Neuzeichnen//
	CView::OnTimer(nIDEvent);
}

void CVisuView::OnLButtonDown(UINT nFlags, CPoint point) 
{
	SetTimer(1,300,NULL);	
	m_nX = 0; // Reset, los gehts
	m_nY = 0; // Reset, los gehts
	CView::OnLButtonDown(nFlags, point);
}

void CVisuView::OnRButtonDown(UINT nFlags, CPoint point) 
{
	KillTimer(1);	
	CView::OnRButtonDown(nFlags, point);
}

Jetzt musst du m_nX und m_nY noch in OnDraw auswerten. Ich vermute, das gehört in diese Zeilen:

rectSchlitten.top=cy*0.5-m_XRect;          ///Ausführung Verschieben////
    rectSchlitten.bottom=cy*0.4-m_XRect;

    rectSchlitten.right=cx*0.95;
    rectSchlitten.left=cx*0.9;

Nur wie du da was rechnen muss kriege ich ohne Kenntnis deiner Rechnung (und der Idee dahinter) grade nicht hin.

Danke

Prim3

Aber ich würde für die 4 Richtungen 2 Boolsche variablen anlegen die man dann kombinieren kann.

nennen wir wie mal

BOOL A;
BOOL B;

dann wäre:

A=0 und B=0 -> bewegung nach oben
A=0 und B=1 -> Bewegung nach rechts
A=1 und B=0 -> Bewegung nach unten
A=1 und B=1 -> Bewegung nach links

Wenn du jetzt festlegst, ab wann die Bewegung zu ende wäre, dann kannst du die Variablen setzen.

Z.B.

//Nach RECHTS
if((A == 0) && (B == 1))
{
 for(int i=0; i<=20; i++)
 { 
  //20schritte
  //Deine Funktionen

  if(i==20)
  {
    A = 0; //TRUE
    B = 0; //FALSE
  }
 }
}

//Nach OBEN
if((A == 0) && (B == 0))
{
 for(int j=0; j<=30; j++)
 { 
  //30 schritte
  //Deine Funktionen

  if(i==30)
  {
    A = 1; //TRUE
    B = 1; //FALSE
  }
 }
}

//USW

Ist recht pirmitiv, aber mit dem Prinzip kannst du deine Grafik theoretisch in alle ecken schubsen.

Die Varaiblen BOOL A & B was ist das für nen Typ mit int habe ich das probiert. Oder wie lege ich das an damit der nicht mekert?

BOOL ist ein Boolscher Wert, der "TRUE" (wahr) und "FALSE" (unwar / falsch) sein kann. Hat nichts mit Integer zu tun. Mit Integer das zu relisieren, was ich da gepostet hab ist umständlich und inffizient. ich glaiub man kann BOOL auch klein schreiben, also "bool". Sollte aber eigenlich keinen unterschied machen. VS kennt beide varianten.

BOOL ist ein Boolscher Wert, der "TRUE" (wahr) und "FALSE" (unwar / falsch) sein kann. Hat nichts mit Integer zu tun. Mit Integer das zu relisieren, was ich da gepostet hab ist umständlich und inffizient. ich glaiub man kann BOOL auch klein schreiben, also "bool". Sollte aber eigenlich keinen unterschied machen. VS kennt beide varianten.

Du irrst schwer.
BOOL (großgeschrieben) ist ein int und kann jeden Wert eines int annehmen (auch -1, oder 4711). Deshalb sollte man eine BOOL Variable nicht mit TRUE vergleichen!

bool (kleingeschrieben) kann dagegen wirklich nur die Werte true (1) und false(0) (kleingeschrieben annehmen).

Ich verwende wo es geht nur bool!

Deshalb sollte man eine BOOL Variable nicht mit TRUE vergleichen!

Womit dann?

bool (kleingeschrieben) kann dagegen wirklich nur die Werte true (1) und false(0) (kleingeschrieben annehmen).

Ich verwende wo es geht nur bool!

Genau, aber sobald man eine GUI dabei hat, wird es bunt gemischt.

Martin Richter schrieb:

Deshalb sollte man eine BOOL Variable nicht mit TRUE vergleichen!

Womit dann?
[quote="estartu"]

Meistens kann man sich einen Vergleich sparen. In einem if und while genügt es einfach die Variable zu schreiben ohne == oder !=.

Ansonsten ist nur der Vergleich zu FALSE sicher.

BOOL bMyState = 56; // Das geht!

if (bMyState) // OK
...
if (!bMyState) // OK
...
if (bMyState==FALSE) // OK
...
if (bMyState!=FALSE) // OK
...
if (bMyState==TRUE) // FAAAAALSCH!!!!!!
...
if (bMyState!=TRUE) // FAAAAALSCH!!!!!!
...

Ich verwendenur die Varianten 1 und 2!
Ein BOOL wir durch den Vergleich !=0 (!=FALSE) korrekt in einen bool gewandelt.

bool (kleingeschrieben) kann dagegen wirklich nur die Werte true (1) und false(0) (kleingeschrieben annehmen).

Ich verwende wo es geht nur bool!

Genau, aber sobald man eine GUI dabei hat, wird es bunt gemischt.

Aber das stört doch keinen. ein bool kann immer für ein BOOL herhalten!
Also bervorzuge ich grundsätzlich bool. Sag mir mal wo Du BOOL wirklich brauchst?

Alleine für die Wandlung BOOL nach bool mache ich das unzählige Male.

Kannst du das mit dem TRUE begründen?
Ich vergleiche tendenziell eher mit TRUE und habe noch keine direkten Nebenwirkungen bemerkt.

Vergelichst Du Variant-Bolls auch mit TRUE!? Dann machst Du aber was falsch... denn dort gibt es "VARIANT_TRUE"

FALSE ist eigentlich immer "0"! TRUE kann sich je nach (ungeschicktem) Define entweder 1 oder -1 sein...
Deswegen: Immer mit "FALSE" vergleichen und *nie* mit "TRUE"!

Kannst du das mit dem TRUE begründen?
Ich vergleiche tendenziell eher mit TRUE und habe noch keine direkten Nebenwirkungen bemerkt.

Alleine für die Wandlung BOOL nach bool mache ich das unzählige Male.

Horror!

Mein Beispiel, warum man es nie machen sollte:

BOOL bValue = 56; 
// Legaler Code und kann ein legaler return 
// wert einer SDK Funktion sein (dort steht nur !=0 bei success z.B.)

// boolValue ist nun false
bool boolValue = bValue==TRUE;

Martin Richter schrieb:

Mein Beispiel, warum man es nie machen sollte:

BOOL bValue = 56; 
// Legaler Code und kann ein legaler return 
// wert einer SDK Funktion sein (dort steht nur !=0 bei success z.B.)

// boolValue ist nun false
bool boolValue = bValue==TRUE;

Okay, wenn da "!=0 bei success" steht dann vergleiche ich auch auf 0.

Okay, also ich verwende es eigentlich nur im Zusammenhang mit Checkboxen.
Da sollte es ja nicht so schlimm sein.

Was prüfst Du da? Den Status?
Nur als Anmerkung: Auch hier sollte man vorsichtig sein. Eine Tristate-Checkbox kennt 0,1,2 und da 2!=TRUE ist, liegt hier mindestens auch solch ein Problem.
Du baust also die UI um und schon wirds lustig...

Man sollte ==TRUE niemals nicht und überhaupt nicht verwenden!

Hmm, viel zu viele Fallen für einen eigentlich so einfach scheinenden Datentyp.

Die Falle ist immer der == Operator!

Man sollte ==TRUE niemals nicht und überhaupt nicht verwenden!

ACK!