wx widget refresh()


#1
Hallo liebe User,

Bin Anfänger ind C++ und probier gerade ein GUI mit wxwidget zu implementieren.
Soweit so gut, funktioniert auch alles wie gewünscht, allerdings werden mir bei der Refresh() Methode alle Elemente die nicht gezeichnet sind, enthalten. Sprich alle Buttons, Textfelder usw. sind weg. Warum? Ich bitte um Hilfe.

C++:
#include <wx/panel.h>
#include <wx/stattext.h>
#include <wx/radiobut.h>
#include <wx/statbox.h>
#include <wx/menu.h>
#include <wx/statbmp.h>
#include <wx/textdlg.h>

#include "wx/wx.h"
#include "wx/sizer.h"

#define __MAINFRM_H__

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include <wx/wx.h>
    #include <wx/frame.h>
#else
    #include <wx/wxprec.h>
#endif

#undef mainFrm_STYLE
#define mainFrm_STYLE wxCAPTION | wxSYSTEM_MENU | wxMINIMIZE_BOX | wxCLOSE_BOX


int calc1();
int calc2();
int calc3();

int XZahl = 245;



class mainFrm : public wxFrame
{
    private:
        DECLARE_EVENT_TABLE();
       
    public:
        mainFrm(wxWindow *parent, wxWindowID id = 1, const wxString &title = wxT("main"), const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = mainFrm_STYLE);
        virtual ~mainFrm();
        void WxToggleButton1Click(wxCommandEvent& event);
        void WxButton1Click(wxCommandEvent& event);
        void rb_kastenholmClick(wxCommandEvent& event);
        void rb_iholmClick(wxCommandEvent& event);
        void rb_kreisholmClick(wxCommandEvent& event);
        void WxPanel1UpdateUI(wxUpdateUIEvent& event);
       
        void Mnuabout1002Click(wxCommandEvent& event);
        void Mnuexit1003Click(wxCommandEvent& event);
       
        void WxEdit1Updated(wxCommandEvent& event);
       
               
    private:
       
        wxStaticText *l_erg;
        wxStaticText *erg_out;
        wxRadioButton *rb_kreisholm;
        wxRadioButton *rb_iholm;
        wxRadioButton *rb_kastenholm;
        wxStaticBox *Holmgeometrie;
        wxStaticBox *Holmkraefte;
        wxMenuBar *WxMenuBar1;
        wxMessageDialog *WxMessageDialog1;
        wxTextCtrl *WxEdit1;
        wxButton *WxButton1;
       


        enum
        {

           
            ////GUI Enum Control ID Start
            ID_MNU_MEN__1001 = 1051,
            ID_MNU_ABOUT_1002 = 1002,
            ID_MNU_EXIT_1003 = 1003,
           
            ID_WXBUTTON1 = 1049,
            ID_WXEDIT1 = 1001,
           
            ID_L_ERG = 1026,
            ID_ERG_OUT = 1025,
            ID_RB_KREISHOLM = 1024,
            ID_RB_IHOLM = 1023,
            ID_RB_KASTENHOLM = 1022,
            ID_HOLMGEOMETRIE = 1011,
            ID_HOLMKRAEFTE = 1010,
            ////GUI Enum Control ID End
            ID_DUMMY_VALUE_ //don't remove this value unless you have other enum values
        };

        void OnClose(wxCloseEvent& event);
        void CreateGUIControls();

};



BEGIN_EVENT_TABLE(mainFrm,wxFrame)   
    EVT_CLOSE(mainFrm::OnClose)
    EVT_RADIOBUTTON(ID_RB_KREISHOLM,mainFrm::rb_kreisholmClick)
    EVT_RADIOBUTTON(ID_RB_IHOLM,mainFrm::rb_iholmClick)
    EVT_RADIOBUTTON(ID_RB_KASTENHOLM,mainFrm::rb_kastenholmClick)
   
    EVT_TEXT(ID_WXEDIT1,mainFrm::WxEdit1Updated)

    EVT_MENU(ID_MNU_ABOUT_1002, mainFrm::Mnuabout1002Click)
    EVT_MENU(ID_MNU_EXIT_1003, mainFrm::Mnuexit1003Click)
   
    EVT_BUTTON(ID_WXBUTTON1,mainFrm::WxButton1Click)
END_EVENT_TABLE()




mainFrm::mainFrm(wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &position, const wxSize& size, long style)
: wxFrame(parent, id, title, position, size, style)
{
    CreateGUIControls();
}

mainFrm::~mainFrm()
{
}

void mainFrm::CreateGUIControls()
{

    Holmkraefte = new wxStaticBox(this, ID_HOLMKRAEFTE, _("Holmmomente"), wxPoint(10, 10), wxSize(575, 405));
    Holmgeometrie = new wxStaticBox(this, ID_HOLMGEOMETRIE, _("Holmgeometrie"), wxPoint(10, 420), wxSize(575, 150));


    rb_kastenholm = new wxRadioButton(this, ID_RB_KASTENHOLM, _("Kastenholm"), wxPoint(70, 455), wxSize(144, 26), 0, wxDefaultValidator, _("rb_kastenholm"));
    rb_iholm = new wxRadioButton(this, ID_RB_IHOLM, _("I- Holm"), wxPoint(70, 490), wxSize(144, 26), 0, wxDefaultValidator, _("rb_iholm"));
    rb_kreisholm = new wxRadioButton(this, ID_RB_KREISHOLM, _("Kreisholm"), wxPoint(70, 525), wxSize(144, 26), 0, wxDefaultValidator, _("rb_kreisholm"));
   
   
    erg_out = new wxStaticText(this, ID_ERG_OUT, _("Ergebniss"), wxPoint(285, 492), wxDefaultSize, 0, _("erg_out"));
    l_erg = new wxStaticText(this, ID_L_ERG, _("Ergebniss der Berechnung"), wxPoint(285, 464), wxDefaultSize, 0, _("l_erg"));

    WxMessageDialog1 =  new wxMessageDialog(this, _("Informatik Projekt 2014 - Dimensioning of an UAV wing main spar\nLAV13\nLukas Grabner, Philipp Strobl, David Hasko, Karl Pichler"), _("About"));
   
    WxEdit1 = new wxTextCtrl(this, ID_WXEDIT1, _(""), wxPoint(20, 375), wxSize(150, 30), 0, wxDefaultValidator, _("WxEdit1"));

    WxButton1 = new wxButton(this, ID_WXBUTTON1, _("WxButton1"), wxPoint(190, 375), wxSize(150, 30), 0, wxDefaultValidator, _("WxButton1"));


    WxMenuBar1 = new wxMenuBar();
    wxMenu *ID_MNU_MEN__1001_Mnu_Obj = new wxMenu();
    ID_MNU_MEN__1001_Mnu_Obj->Append(ID_MNU_ABOUT_1002, _("About"), _(""), wxITEM_NORMAL);
    ID_MNU_MEN__1001_Mnu_Obj->Append(ID_MNU_EXIT_1003, _("Exit"), _(""), wxITEM_NORMAL);
    WxMenuBar1->Append(ID_MNU_MEN__1001_Mnu_Obj, _("Menü"));
    SetMenuBar(WxMenuBar1);

    SetTitle(_("Informatik Projekt 2014"));
    SetBackgroundColour(wxColor(198, 198, 198));
    SetSize(8,8,600,630);
    Center();
   
}

void mainFrm::OnClose(wxCloseEvent& event)
{
    Destroy();
}


class BasicDrawPane : public wxPanel
{
    public:
        BasicDrawPane(wxFrame* parent);
    
        void paintEvent(wxPaintEvent & evt);
        void paintNow();
    
        void render(wxDC& dc);
    
       
    
        DECLARE_EVENT_TABLE()
       
};
class MyApp: public wxApp
{
    bool OnInit();

    mainFrm *frame;
    BasicDrawPane * drawPane;
};
IMPLEMENT_APP(MyApp)
bool MyApp::OnInit()
{

    wxBoxSizer* sizer = new wxBoxSizer(wxHORIZONTAL);
    frame = new mainFrm(NULL);
    drawPane = new BasicDrawPane( (mainFrm*) frame );
    sizer->Add(drawPane, 1, wxEXPAND);
    frame->SetSizer(sizer);
    frame->SetAutoLayout(true);
    frame->Show();
    return true;
}
BEGIN_EVENT_TABLE(BasicDrawPane, wxPanel)
    EVT_PAINT(BasicDrawPane::paintEvent)
END_EVENT_TABLE()

BasicDrawPane::BasicDrawPane(wxFrame* parent) :
wxPanel(parent)
{
}
void BasicDrawPane::paintEvent(wxPaintEvent & evt)
{
    wxPaintDC dc(this);
    render(dc);
}
void BasicDrawPane::paintNow()
{
    wxClientDC dc(this);
    render(dc);
}




void BasicDrawPane::render(wxDC&  dc)
{

    int w1, w2, w3;
   
    int xb= 20;
    int yb= 29;
   
    w1 = calc1();
    w2 = calc2();
    w3 = calc3();
   
   
    wxPoint points[10];
    wxPoint pointsA[3];
    wxPoint pointsIHolm[13];
   
    // ---------------------------------------------------------------------------------------------------------------------
    // draw background
    // ---------------------------------------------------------------------------------------------------------------------
    dc.SetBrush(*wxWHITE_BRUSH);
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
    dc.DrawRectangle( 20, 30, 555, 340 );

    dc.SetBrush(*wxWHITE_BRUSH);
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
    dc.DrawRectangle( 30, 453, 30, 30 );
   
    dc.SetBrush(*wxWHITE_BRUSH);
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
    dc.DrawRectangle( 30, 488, 30, 30 );
   
    dc.SetBrush(*wxWHITE_BRUSH);
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
    dc.DrawRectangle( 30, 523, 30, 30 );   
   
    // ---------------------------------------------------------------------------------------------------------------------
    // draw coordinat system
    // ---------------------------------------------------------------------------------------------------------------------



    dc.SetPen( wxPen( wxColor(224,238,238), 1 ) );
   
    for(int iz = 0; iz < 4; iz++)
    {
        dc.DrawLine( (xb+ 65), (yb+198-(32*iz)), (xb+ 500), (yb+198-(32*iz)));
    }
   
    for(int iz2 = 0; iz2 < 13; iz2++)
    {
        dc.DrawLine( (xb+ 97 +(32*iz2)), (yb+230), (xb+ 97+(32*iz2)), (yb+80));
    }
   
   
    dc.SetPen( wxPen( wxColor(131,139,139), 1 ) );
    dc.DrawLine( (xb+ 65), (yb+230), (xb+ 520), (yb+230));
    dc.DrawLine( (xb+ 65), (yb+230), (xb+ 65), (yb+70));
   
    int xbp1 = (xb+ 65);
    int ybp1 = (yb+70);
   
   
    pointsA[0].x = xbp1-4;  pointsA[0].y = ybp1+15;
    pointsA[1].x = xbp1+4;  pointsA[1].y =ybp1+15;
    pointsA[2].x = xbp1+0;  pointsA[2].y = ybp1+0;
    pointsA[3].x = xbp1-4;  pointsA[3].y = ybp1+15;
   
    dc.DrawPolygon(4, pointsA);    
   
   
    xbp1 = (xb+ 520);
    ybp1 = (yb+230);
   
    pointsA[0].x = xbp1;  pointsA[0].y = ybp1;
    pointsA[1].x = xbp1-15;  pointsA[1].y =ybp1+4;
    pointsA[2].x = xbp1-15;  pointsA[2].y = ybp1-4;
    pointsA[3].x = xbp1;  pointsA[3].y = ybp1;
   
    dc.DrawPolygon(4, pointsA);      
   
   
    // ---------------------------------------------------------------------------------------------------------------------
    // draw lines
    // ---------------------------------------------------------------------------------------------------------------------
   
   
    int xbrl = (xb+ 65);
    int ybrl = (yb+230);
   
   
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
    dc.DrawLine( xbrl, ybrl, xbrl, (ybrl-w1));
   
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
    dc.DrawLine( (xbrl+430), ybrl, (xbrl+430), (ybrl-w2) );

    dc.SetPen( wxPen( wxColor(190, 24, 17), 1 ) );
    dc.DrawLine( XZahl, ybrl, XZahl, (ybrl-w3) );

    dc.SetPen( wxPen( wxColor(0,0,0), 4 ) );
    dc.DrawLine( xbrl, (ybrl-w1), XZahl, (ybrl-w3) );
   
    dc.SetPen( wxPen( wxColor(0,0,0), 4 ) );
    dc.DrawLine( XZahl, (ybrl-w3), (xbrl+430), (ybrl-w2) );
   
   
   
    // ---------------------------------------------------------------------------------------------------------------------
    // draw plane
    // ---------------------------------------------------------------------------------------------------------------------


    dc.SetBrush (wxBrush(wxColor(209,238,238)) );
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );

    points[0].x = xb;  points[0].y = (yb+20);
    points[1].x = (xb+ 80);   points[1].y =(yb+20);
    points[2].x = (xb+ 80);  points[2].y = (yb+45);
    points[3].x = (xb+ 20);   points[3].y = (yb+65);
    points[4].x = (xb+ 60);  points[4].y = (yb+240);
   
    points[5].x = (xb+ 500);  points[5].y = (yb+240);
    points[6].x = (xb+ 500);  points[6].y = (yb+300);
    points[7].x = (xb+ 60);   points[7].y = (yb+300);
    points[8].x = (xb+ 40);  points[8].y = (yb+340);
    points[9].x = xb;  points[9].y = (yb+340);

    dc.DrawPolygon(10, points);


    // ---------------------------------------------------------------------------------------------------------------------
    // draw holm shapes
    // ---------------------------------------------------------------------------------------------------------------------

    dc.SetBrush (wxBrush(wxColor(209,238,238)) );
    dc.SetPen( wxPen( wxColor(0,0,0), 1 ) );
   
    dc.DrawRectangle( 33, 456, 24, 24 );


    pointsIHolm[0].x = 33;  pointsIHolm[0].y = 461+30;
    pointsIHolm[1].x = 56;  pointsIHolm[1].y = 461+30;
    pointsIHolm[2].x = 56;  pointsIHolm[2].y = 465+30;
    pointsIHolm[3].x = 48;  pointsIHolm[3].y = 465+30;
    pointsIHolm[4].x = 48;  pointsIHolm[4].y = 480+30;
    pointsIHolm[5].x = 56;  pointsIHolm[5].y = 480+30;
    pointsIHolm[6].x = 56;  pointsIHolm[6].y = 484+30;
    pointsIHolm[7].x = 33;  pointsIHolm[7].y = 484+30;
    pointsIHolm[8].x = 33;  pointsIHolm[8].y = 480+30;
    pointsIHolm[9].x = 41;  pointsIHolm[9].y = 480+30;
    pointsIHolm[10].x = 41;  pointsIHolm[10].y = 465+30;
    pointsIHolm[11].x = 33;  pointsIHolm[11].y = 465+30;
    pointsIHolm[12].x = 33;  pointsIHolm[12].y = 461+30;
   
    dc.DrawPolygon(13, pointsIHolm);  
   
    dc.DrawCircle(45,538,11);
}

// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
//  events
// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------

/*
* rb_kastenholmClick
*/
void mainFrm::rb_kastenholmClick(wxCommandEvent& event)
{
    erg_out->SetLabel("Wahl1");
}

/*
* rb_iholmClick
*/
void mainFrm::rb_iholmClick(wxCommandEvent& event)
{
    erg_out->SetLabel("Wahl2");
}

/*
* rb_kreisholmClick
*/
void mainFrm::rb_kreisholmClick(wxCommandEvent& event)
{
    erg_out->SetLabel("Wahl3");
}

/*
* Mnuabout1002Click
*/
void mainFrm::Mnuabout1002Click(wxCommandEvent& event)
{
    this->WxMessageDialog1->ShowModal();
}

/*
* Mnuexit1003Click
*/
void mainFrm::Mnuexit1003Click(wxCommandEvent& event)
{
    Close(true);
    Destroy();
}

void mainFrm::WxEdit1Updated(wxCommandEvent& event)
{
    wxString cad;
    cad = WxEdit1->GetValue();
   
    XZahl = atoi(cad);
    //XZahl = 100;
    erg_out->SetLabel(cad);

}

void mainFrm::WxButton1Click(wxCommandEvent& event)
{
      Refresh();
      //CreateGUIControls();   
}

// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
// end events
// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------


// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
// calculation functions
// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
int calc1()
{
    int i1 = 100;
    return i1;    
}

int calc2()
{
    int i1 = 20;
    return i1;    
}

int calc3()
{
    int i1 = 50;
    return i1;    
}

// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
// end calculation functions
// ---------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------
Oder hat jemand vl. ein schönes template wo ein Zeichenpanel und Buttons usw. enthalten sind?

Danke für eure hilfe.
LG
 

ComFreek

Mod | @comfreek
Moderator
#2
Hallo,

ich habe schon eine lange Zeit wxWidgets nicht mehr genutzt. Aber was soll denn das Refresh() bewirken? Wozu rufst du es auf?

Kennst du wxFormBuilder oder vergleichbare GUI-Designer für wxWidgets? Die ersparen dir eine Menge Handarbeit.
 
#3
Das Refresh sollte die Zeichengrafik aktualisieren. Sprich wenn ich einen Wert ändere sollte sich auch die Grafik verändern.
Nach dem ein neuer Wert eingegeben wurde und der Button geklickt wurde wird das Refresh ausgeführt welches mir das ganze fenster neu zeichnet oder?
Es wird auch neu gezeichnet allerdings fehlen dann die Buttons, Textfelder, usw. und ich habe keine Erklärung.

Ja ich habe es auch mit dem GUI Designer von WexDev probiert, allerdings hab ich da keine Ahnung wie ich in eine Paint Methode komme!
Hast du da vl. ein Beispiel?
 

ComFreek

Mod | @comfreek
Moderator
#4
Das Problem ist, dass du mit Refresh() die Methode von mainfrm aufrufst und nicht die von deinem BasicDrawPane.

1. Probiere, eine entsprechende Methode für dein BasicDrawPane aufzurufen, z. B. paintNow()

2. Allerdings befürchte ich, dass dies nicht so gut ist, weil wxWidgets selbst eine Message Queue für Paint-Ereignisse hat, soweit ich weiß. Vielleicht hilft dir der Aufruf Update() nach Refresh() weiter, siehe hier.

Ein Beispiel habe ich nicht parat, wie gesagt, programmiere ich nicht mehr mit wxWidgets (allerdings nicht aus dem Grund, weil es schlecht ist o. ä.)
 
#5
nope funktioniert nicht. Anderer Lösungsvorschlag? Wenn ich CreateGUIControl() ausführe zeichnet er das ganze Fenster neu, allerdings hüpft dieses herum.
 

Neue Beiträge