Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » VC++ / MFC » brauche dringend hilfe bei beweglichen items

Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
17.06.2003, 11:38 Uhr
~willi808
Gast


hallo,

und zwar habe ich ein grosses problem.
in einem projekt werden waehrend der laufzeit ellipsen erstellt.
und diese soll ich bewglich machen.
ich habe aber keinen plan wie ich das anstellen soll oder wie das geht...
vielleicht koennt ihr mir weiterhelfen

danke
willi808
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
17.06.2003, 13:08 Uhr
Uwe
C/C++ Master
(Administrator)


Hallo Willi,
kommt darauf an wie die Bewegung ausgelöst werden soll (Maus, Timer usw.). Ellipse zeichnen, gültiges Rechteck ermitteln, aktuelle Position mit Move verschieben, Bereich neu zeichnen lassen.
--
"Es ist schwierig, ein Programm wirklich idiotensicher zu machen, weil Idioten so genial sind."

Bis dann...
Uwe
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
17.06.2003, 13:19 Uhr
~willi808
Gast


hi uwe,

und zwar wird am anfang eine ellipse gezeichnet und mit festen integerwerten in den dialog gesetzt.
nach dem start des programmes soll ich per mausklick die ellipse in dem dialog verschieben koennen. (wie aufm desktop).

hier 'n auszug von dem was mir bereits vorliegt:

C++:
void ellipse::init (RECT rc, bool _isGreen, const char *_str)
{
    rect = rc;
    isGreen = _isGreen;
    str = _str;
}


void ellipse::draw (CPaintDC *dc)
{
    COLORREF col = RGB (255,128,128);
    if (isGreen) col = RGB (128,255,128);

    // draw ellipse
    CPen pen (PS_SOLID, 1, col);
    CBrush brush;
    brush.CreateSolidBrush (col);
    CBrush *oldBrush = dc->SelectObject (&brush);
    CPen *pOldPen = dc->SelectObject (&pen);
    dc->Ellipse(rect.left, rect.top, rect.right, rect.bottom);
    dc->SelectObject (pOldPen);
    dc->SelectObject (oldBrush);

    // draw text
    CFont font;
    font.CreatePointFont (150, "Times New Roman");
    CFont *oldFont = dc->SelectObject (&font);
    dc->SetBkMode (TRANSPARENT);
    dc->SetTextColor (RGB (80, 80, 80));
    dc->DrawText (str, &rect, DT_CENTER |  DT_SINGLELINE | DT_VCENTER);
    dc->SelectObject (oldFont);

    // draw connections
    COLORREF colL = RGB(0,0,0);
    CPen penL (PS_SOLID, 2, colL);
    CBrush brushL;
    brushL.CreateSolidBrush (colL);
    CBrush *oldBrushL = dc->SelectObject (&brushL);
    CPen *pOldPenL = dc->SelectObject (&penL);
    dc->MoveTo(CPoint((rect.left-rect.right)/2, (rect.bottom-rect.top)/2));
    dc->LineTo(CPoint((rect.left-rect.right)/2, (rect.bottom-rect.top)/2));
    dc->SelectObject (pOldPenL);
    dc->SelectObject (oldBrushL);
    
}


bool ellipse::isHit (CPoint *point)
{

    double a = (rect.right - rect.left) / 2;
    double b = (rect.bottom - rect.top) / 2;

    // Determine x, y
    double x = point->x - (rect.left + rect.right) / 2;
    double y = point->y - (rect.top + rect.bottom) / 2;

    // Apply ellipse formula
    return ((x * x) / (a * a) + (y * y) / (b * b) <= 1);
}


BEGIN_MESSAGE_MAP (Ansicht, CWnd)
    ON_WM_PAINT()
    ON_WM_LBUTTONDOWN()
END_MESSAGE_MAP()



BOOL Ansicht::PreCreateWindow (CREATESTRUCT &cs)
{
    
    
    ellipse *el = new ellipse();
    el->init (CRect (250, 10, 430, 100), true, "Test1");
    ellis.AddTail (el);
    

    el = new ellipse();    
    el->init (CRect (30, 160, 210, 250), false, "Test3");    
    ellis.AddTail (el);

    el = new ellipse();
    el->init (CRect (470, 160, 650, 250), false, "Test2 ");
    ellis.AddTail (el);


    return CWnd::PreCreateWindow (cs);
}


void Ansicht::OnPaint (void)
{
    CPaintDC dc(this);

    POSITION pos = ellis.GetHeadPosition();
    for (int i = 0; i < ellis.GetCount(); i ++) {
        ellis.GetNext(pos)->draw (&dc);
    }
}


void Ansicht::OnLButtonDown (UINT nFlags, CPoint point)
{
    //TRACE ("OnLButtonDown %d-%d (%x)  ", point.x, point.y, nFlags);
    POSITION pos = ellis.GetHeadPosition();
    for (int n = 0; n < ellis.GetCount(); n++) {
        ellipse *el = ellis.GetNext(pos);
        if (el->isHit (&point)) {
            TRACE ("%s wurde getroffen\n", *el->getStr());
            dlg->setAlgoData (*el->getStr());
            break;
        }
    }
}


-Bitte Code-Tag nutzen-

Dieser Post wurde am 17.06.2003 um 17:51 Uhr von Uwe editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
17.06.2003, 17:53 Uhr
Uwe
C/C++ Master
(Administrator)


Hallo

Zitat:
~willi808 postete


C++:
    ellis.GetNext(pos)->draw (&dc);




Wer oder was ist Alice (ellis)?
--
"Es ist schwierig, ein Programm wirklich idiotensicher zu machen, weil Idioten so genial sind."

Bis dann...
Uwe

Dieser Post wurde am 17.06.2003 um 17:53 Uhr von Uwe editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
18.06.2003, 06:41 Uhr
~willi808
Gast


Das ist Alice :-)
--
CList<ellipse*,ellipse*> ellis;
--
bes dann...
willi
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
19.06.2003, 07:48 Uhr
Uwe
C/C++ Master
(Administrator)


Hallo Willi,
sorry für die späte Antwort, bin im Moment dienstl. unterwegs.
Entweder ich hab was in Deinem Quellcode etwas übersehen, aber wieso kann ellis die Methode draw nutzen?
Wie auch immer, ich schau mir (falls noch Bedarf) das heute Abend genauer an.
--
"Es ist schwierig, ein Programm wirklich idiotensicher zu machen, weil Idioten so genial sind."

Bis dann...
Uwe
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
19.06.2003, 22:08 Uhr
Uwe
C/C++ Master
(Administrator)


Hallo,
Die Zuordnung in Deine Liste kannst Du selbst noch implementieren.

C++:
public:
    afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
    afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
    afx_msg void OnMouseMove(UINT nFlags, CPoint point);
private:
    CPoint   m_pointTopLeftC1, m_pointTopLeftC2, m_pointTopLeftC3;
    const CSize m_sizeEllipse1, m_sizeEllipse2, m_sizeEllipse3;
    bool m_bCircle1, m_bCircle2, m_bCircle3;
    CSize    m_sizeOffset;



C++:
CAnsichtDlg::CAnsichtDlg(CWnd* pParent /*=NULL*/)
: CDialog(CAnsichtDlg::IDD, pParent), m_sizeEllipse1(100, 100),
                            m_sizeEllipse2(80,80),
                            m_sizeEllipse3(170, 170),
                            m_pointTopLeftC1(10, 10),
                            m_pointTopLeftC2(100, 100),
                            m_pointTopLeftC3(150, 150),
                            m_sizeOffset(0, 0)
{
    m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
    m_bCircle1 = FALSE;
    m_bCircle2 = FALSE;
    m_bCircle3 = FALSE;
}
...........
...........
void CAnsichtDlg::OnPaint()
{
    if (IsIconic())
    {
        CPaintDC dc(this); // Gerätekontext zum Zeichnen

        SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

        // Symbol in Client-Rechteck zentrieren
        int cxIcon = GetSystemMetrics(SM_CXICON);
        int cyIcon = GetSystemMetrics(SM_CYICON);
        CRect rect;
        GetClientRect(&rect);
        int x = (rect.Width() - cxIcon + 1) / 2;
        int y = (rect.Height() - cyIcon + 1) / 2;

        // Symbol zeichnen
        dc.DrawIcon(x, y, m_hIcon);
    }
    else
    {
        CBrush *pBrushBlank[3];
        CPaintDC dc(this); // device context for painting
        pBrushBlank[0] = new CBrush(RGB(255,0,0));
        pBrushBlank[1] = new CBrush(RGB(0,255,0));
        pBrushBlank[2] = new CBrush(RGB(0,0,255));

        dc.SelectObject(pBrushBlank[0]);
        dc.Ellipse(CRect(m_pointTopLeftC1, m_sizeEllipse1));
        dc.SelectObject(pBrushBlank[1]);
        dc.Ellipse(CRect(m_pointTopLeftC2, m_sizeEllipse2));
        dc.SelectObject(pBrushBlank[2]);
        dc.Ellipse(CRect(m_pointTopLeftC3, m_sizeEllipse3));

        for(int i = 0; i<=2; i++)
        delete pBrushBlank[i];

        CDialog::OnPaint();
    }
}

void CAnsichtDlg::OnLButtonDown(UINT nFlags, CPoint point)
{
    CRect rectEllipse1(m_pointTopLeftC1, m_sizeEllipse1);
    CRgn  Circle1;
    CRect rectEllipse2(m_pointTopLeftC2, m_sizeEllipse2);
    CRgn  Circle2;
    CRect rectEllipse3(m_pointTopLeftC3, m_sizeEllipse3);
    CRgn  Circle3;

    CClientDC dc(this);
    dc.LPtoDP(rectEllipse1);
    Circle1.CreateEllipticRgnIndirect(rectEllipse1);
    if (Circle1.PtInRegion(point)){
        SetCapture();
        m_bCircle1 = TRUE;
        CPoint pointTopLeft1(m_pointTopLeftC1);
        dc.LPtoDP(&pointTopLeft1);
        m_sizeOffset = point - pointTopLeft1;
    }

    dc.LPtoDP(rectEllipse2);
    Circle2.CreateEllipticRgnIndirect(rectEllipse2);
    if (Circle2.PtInRegion(point)){
        SetCapture();
        m_bCircle2 = TRUE;
        CPoint pointTopLeft2(m_pointTopLeftC2);
        dc.LPtoDP(&pointTopLeft2);
        m_sizeOffset = point - pointTopLeft2;
    }

    dc.LPtoDP(rectEllipse3);
    Circle3.CreateEllipticRgnIndirect(rectEllipse3);
    if (Circle3.PtInRegion(point)){
        SetCapture();
        m_bCircle3 = TRUE;
        CPoint pointTopLeft3(m_pointTopLeftC3);
        dc.LPtoDP(&pointTopLeft3);
        m_sizeOffset = point - pointTopLeft3;
    }

    CDialog::OnLButtonDown(nFlags, point);
}

void CAnsichtDlg::OnLButtonUp(UINT nFlags, CPoint point)
{
    if (m_bCircle1){
        ::ReleaseCapture();
        m_bCircle1 = FALSE;
    }

    if (m_bCircle2){
        ::ReleaseCapture();
        m_bCircle2 = FALSE;
    }

    if (m_bCircle3){
        ::ReleaseCapture();
        m_bCircle3 = FALSE;
    }
    CDialog::OnLButtonUp(nFlags, point);
}

void CAnsichtDlg::OnMouseMove(UINT nFlags, CPoint point)
{
    if (m_bCircle1){
        CClientDC dc(this);
        CRect rectOld(m_pointTopLeftC1, m_sizeEllipse1);
        dc.LPtoDP(rectOld);
        InvalidateRect(rectOld, TRUE);
        m_pointTopLeftC1 = point - m_sizeOffset;
        dc.DPtoLP(&m_pointTopLeftC1);
        CRect rectNew(m_pointTopLeftC1, m_sizeEllipse1);
        dc.LPtoDP(rectNew);
        InvalidateRect(rectNew, TRUE);
    }

    if (m_bCircle2){
        CClientDC dc(this);
        CRect rectOld(m_pointTopLeftC2, m_sizeEllipse2);
        dc.LPtoDP(rectOld);
        InvalidateRect(rectOld, TRUE);
        m_pointTopLeftC2 = point - m_sizeOffset;
        dc.DPtoLP(&m_pointTopLeftC2);
        CRect rectNew(m_pointTopLeftC2, m_sizeEllipse2);
        dc.LPtoDP(rectNew);
        InvalidateRect(rectNew, TRUE);
    }

    if (m_bCircle3){
        CClientDC dc(this);
        CRect rectOld(m_pointTopLeftC3, m_sizeEllipse3);
        dc.LPtoDP(rectOld);
        InvalidateRect(rectOld, TRUE);
        m_pointTopLeftC3 = point - m_sizeOffset;
        dc.DPtoLP(&m_pointTopLeftC3);
        CRect rectNew(m_pointTopLeftC3, m_sizeEllipse3);
        dc.LPtoDP(rectNew);
        InvalidateRect(rectNew, TRUE);
    }

    CDialog::OnMouseMove(nFlags, point);
}


--
"Es ist schwierig, ein Programm wirklich idiotensicher zu machen, weil Idioten so genial sind."

Bis dann...
Uwe
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ VC++ / MFC ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: