Wxwidget Programm ohne Gui - Console



  • Hi,
    ich habe vor kurzem angefangen ein wenig zu programmieren. Und Zwar handelt es sich bei meinem Programm um ein Tool um Eine Server Client anwendung mit der man am Seriellen Port verschieden Pins schalten kann welche bei mir an eine Selbstgebaute Relaiskarte gehen.

    Ich habe es soweit hinbekommen das ich mt hilfe von WxWidget eine Server Anwendung und eine Client anwendung Programmiert habe mit der ich alles was ich vor hatte verwirklicht habe. ( Mit hilfe einiger beispiel programme und anleitungen)

    Doch da ich den "server" auch gerne auf einem kleinen Linux PC ohne gui Laufen lassen möchte habe ich nun ein problem. Denn ich habe keine Ahnung wie ich wx dazu bewege auf der gui zu bleiben.

    Es ist mit Sicherheit nicht die Sauberste art zu Programmieren^^ aber es hat soweit alles geklappt.

    Evtl. könnte mal jemand drübersehen und mir einen tip geben wie die geschichte auf Console bannen kann.

    Ich währe euch sehr dankbar

    mfg klagges

    /***************************************************************
     * Name:      WX_ServerMain.cpp
     * Purpose:   Code for Application Frame
     * Author:    Neo ()
     * Created:   2010-02-15
     * Copyright: Neo ()
     * License:
     **************************************************************/
    
    // --------------------------------------------------------------------------
    // headers
    // --------------------------------------------------------------------------
    
    // For compilers that support precompilation, includes "wx/wx.h".
    #include "wx/wxprec.h"
    #include "parapin.h"        // Klasse für die Verarbeitung der Paralellports
    
    #ifdef __BORLANDC__
    #  pragma hdrstop
    #endif
    
    // for all others, include the necessary headers
    #ifndef WX_PRECOMP
    #  include "wx/wx.h"
    #endif
    
    #include "wx/socket.h"
    using namespace std;
    
    int a=0, b=0, c=0, d=0, e=0, f=0, g=0, h=0;     // Variablen die den Zustand Speichern sollen.
    
        char bfpin1[] ="pin1";  // Setze vergleichswerte für den Empfangsbuffe
        char bfpin2[] ="pin2";
        char bfpin3[] ="pin3";
        char bfpin4[] ="pin4";
        char bfpin5[] ="pin5";
        char bfpin6[] ="pin6";
        char bfpin7[] ="pin7";
        char bfpin8[] ="pin8";
    
    // --------------------------------------------------------------------------
    // resources
    // --------------------------------------------------------------------------
    
    // the application icon
    //#if defined(__WXGTK__) || defined(__WXX11__) || defined(__WXMOTIF__) || defined(__WXMAC__)
    //#  include "mondrian.xpm"
    //#endif
    
    // --------------------------------------------------------------------------
    // classes
    // --------------------------------------------------------------------------
    
    // Define a new application type
    class MyApp : public wxApp
    {
    public:
      virtual bool OnInit();
    };
    
    // Define a new frame type: this is going to be our main frame
    class MyFrame : public wxFrame
    {
    public:
      MyFrame();
      ~MyFrame();
    
      // event handlers (these functions should _not_ be virtual)
      void OnQuit(wxCommandEvent& event);
      void OnAbout(wxCommandEvent& event);
      void OnServerEvent(wxSocketEvent& event);
      void OnSocketEvent(wxSocketEvent& event);
    
      void Pin1(wxSocketBase *sock);
      void Pin2(wxSocketBase *sock);
      void Pin3(wxSocketBase *sock);
      void Pin4(wxSocketBase *sock);
      void Pin5(wxSocketBase *sock);
      void Pin6(wxSocketBase *sock);
      void Pin7(wxSocketBase *sock);
      void Pin8(wxSocketBase *sock);
    
      // convenience functions
      void UpdateStatusBar();
    
    private:
      wxSocketServer *m_server;
      wxTextCtrl     *m_text;
      wxMenu         *m_menuFile;
      wxMenuBar      *m_menuBar;
      bool            m_busy;
      int             m_numClients;
    
      // any class wishing to process wxWidgets events must use this macro
      DECLARE_EVENT_TABLE()
    };
    
    // --------------------------------------------------------------------------
    // constants
    // --------------------------------------------------------------------------
    
    // IDs for the controls and the menu commands
    enum
    {
      // menu items
      SERVER_QUIT = wxID_EXIT,
      SERVER_ABOUT = wxID_ABOUT,
    
      // id for sockets
      SERVER_ID = 100,
      SOCKET_ID
    };
    
    // --------------------------------------------------------------------------
    // event tables and other macros for wxWidgets
    // --------------------------------------------------------------------------
    
    BEGIN_EVENT_TABLE(MyFrame, wxFrame)
      EVT_MENU(SERVER_QUIT,  MyFrame::OnQuit)
      EVT_MENU(SERVER_ABOUT, MyFrame::OnAbout)
      EVT_SOCKET(SERVER_ID,  MyFrame::OnServerEvent)
      EVT_SOCKET(SOCKET_ID,  MyFrame::OnSocketEvent)
    END_EVENT_TABLE()
    
    IMPLEMENT_APP(MyApp)
    
    // ==========================================================================
    // implementation
    // ==========================================================================
    
    // --------------------------------------------------------------------------
    // the application class
    // --------------------------------------------------------------------------
    
    bool MyApp::OnInit()
    {
      // Create the main application window
      MyFrame *frame = new MyFrame();
    
      // Show it and tell the application that it's our main window
      frame->Show(true);
      SetTopWindow(frame);
      // Success
      return true;
    }
    
    // --------------------------------------------------------------------------
    // main frame
    // --------------------------------------------------------------------------
    
    // frame constructor
    
    MyFrame::MyFrame() : wxFrame((wxFrame *)NULL, wxID_ANY,
                                 _("SwitchMe Server 1.0"),
                                 wxDefaultPosition, wxSize(300, 200))
    {
      // Give the frame an icon
    //  SetIcon(wxICON(mondrian));
    
    //  if (pin_init_user(LPT1) < 0)
    //    exit(0);
    
      // Make menus
      m_menuFile = new wxMenu();
      m_menuFile->Append(SERVER_ABOUT, _("&About...\tCtrl-A"), _("Show about dialog"));
      m_menuFile->AppendSeparator();
      m_menuFile->Append(SERVER_QUIT, _("E&xit\tAlt-X"), _("Quit server"));
    
      // Append menus to the menubar
      m_menuBar = new wxMenuBar();
      m_menuBar->Append(m_menuFile, _("&File"));
      SetMenuBar(m_menuBar);
    
    #if wxUSE_STATUSBAR
      // Status bar
      CreateStatusBar(2);
    #endif // wxUSE_STATUSBAR
    
      // Make a textctrl for logging
      m_text  = new wxTextCtrl(this, wxID_ANY,
                               _("Willkommen zum SwitchMe Server 1.0\n"),
                               wxDefaultPosition, wxDefaultSize,
                               wxTE_MULTILINE | wxTE_READONLY);
    
                                if (pin_init_user(LPT1) < 0)
                                m_text->AppendText(_("!! Fehler !!\n Programm muss als Root Gestartet werden !\n Programm muss als Root gestartet werden")),
                                printf("Programm muss als root ausgeführt werden.");
                               pin_output_mode(LP_PIN01| LP_DATA_PINS | LP_SWITCHABLE_PINS);
    
        void set_pin(int pins);
        void clear_pin(int pins);
        void change_pin(int pins, int state);
        int pin_is_set(int pins);
            clear_pin(LP_PIN01);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN02);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN03);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN04);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN05);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN06);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN07);    // Alle Pins zum start ausschalten
            clear_pin(LP_PIN08);    // Alle Pins zum start ausschalten
    
      // Create the address - defaults to localhost:0 initially
      wxIPV4address addr;
      addr.Service(3000);
    
      // Create the socket
      m_server = new wxSocketServer(addr);
    
      // We use Ok() here to see if the server is really listening
      if (! m_server->Ok())
      {
        m_text->AppendText(_("Could not listen at the specified port !\n\n"));
        return;
      }
      else
      {
        m_text->AppendText(_("Server listening.\n\n"));
      }
    
      // Setup the event handler and subscribe to connection events
      m_server->SetEventHandler(*this, SERVER_ID);
      m_server->SetNotify(wxSOCKET_CONNECTION_FLAG);
      m_server->Notify(true);
    
      m_busy = false;
      m_numClients = 0;
      UpdateStatusBar();
    }
    
    MyFrame::~MyFrame()
    {
      // No delayed deletion here, as the frame is dying anyway
      delete m_server;
    }
    
    // event handlers
    
    void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
    {
      // true is to force the frame to close
      Close(true);
    }
    
    void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
    {
      wxMessageBox(_("SwitchMe Server 1.0\n(c) 2010 by Neo\n von \n www.Computer-hoelle.de"),
                   _("About Server"),
                   wxOK | wxICON_INFORMATION, this);
    }
    
    void MyFrame::Pin1(wxSocketBase *sock)
    {
      unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 1 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (a== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 1 Ist Off und wird On geschaltet\n"));
                        a++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN01);
                        }
                    else if (a==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 1 Ist On und wird Off geschaltet\n\n"));
                        a--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN01);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 1 wurde geschalten\n\n"));
    }
    
    void MyFrame::Pin2(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 2 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (b== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 2 Ist Off und wird On geschaltet\n"));
                        b++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN02);
                        }
                    else if (b==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 2 Ist On und wird Off geschaltet\n\n"));
                        b--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN02);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 2 wurde geschalten\n\n"));
    }
    void MyFrame::Pin3(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 3 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if ( c== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 3 Ist Off und wird On geschaltet\n"));
                        c++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN03);
                        }
                    else if (c==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 3 Ist On und wird Off geschaltet\n\n"));
                        c--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN03);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 3 wurde geschalten\n\n"));
    }
    void MyFrame::Pin4(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 4 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (d== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 4 Ist Off und wird On geschaltet\n"));
                        d++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN04);
                        }
                    else if (d==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 4 Ist On und wird Off geschaltet\n\n"));
                        d--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN04);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 4 wurde geschalten\n\n"));
    }
    void MyFrame::Pin5(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 5 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (e== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 5 Ist Off und wird On geschaltet\n"));
                        e++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN05);
                        }
                    else if (e==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 5 Ist On und wird Off geschaltet\n\n"));
                        e--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN05);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 5 wurde geschalten\n\n"));
    }
    void MyFrame::Pin6(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 6 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (f== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 6 Ist Off und wird On geschaltet\n"));
                        f++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN06);
                        }
                    else if (f==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 6 Ist On und wird Off geschaltet\n\n"));
                        f--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN06);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 6 wurde geschalten\n\n"));
    }
    void MyFrame::Pin7(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 7 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (g== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 7 Ist Off und wird On geschaltet\n"));
                        g++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN07);
                        }
                    else if (g==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 7 Ist On und wird Off geschaltet\n\n"));
                        g--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN07);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 7 wurde geschalten\n\n"));
    }
    void MyFrame::Pin8(wxSocketBase *sock)
    {
         unsigned char len;
      char *buf;
      m_text->AppendText(_("Pin 8 wird geschalten\n\n"));
      sock->SetFlags(wxSOCKET_WAITALL);
      // Read the size
      sock->Read(&len, 1);
      buf = new char[len];
      // Read the data
      sock->Read(buf, len);
      m_text->AppendText(_("Daten wurden Empfangen und zur Kontrolle zurück gesendet.\n"));
      // PARAPIN code hierrein
                    if (h== 0)                {                            // Prüfe den Status des ersten Pins
                        m_text->AppendText(_("Pin 8 Ist Off und wird On geschaltet\n"));
                        h++ ;                                               // Pin wird geschaltet und variable bekommt 1
                        set_pin(LP_PIN08);
                        }
                    else if (h==1)  {                                       // Pin hat Status 1
                        m_text->AppendText(_("Pin 8 Ist On und wird Off geschaltet\n\n"));
                        h--;                                                // und bekommt Status 0
                        clear_pin(LP_PIN08);
                        }
      // Parapin code end
        // Write it back
      sock->Write(buf, len);
      delete[] buf;
      m_text->AppendText(_("Pin 8 wurde geschalten\n\n"));
        }
    
    void MyFrame::OnServerEvent(wxSocketEvent& event)
    {
    
       //     if (pin_init_user(LPT1) < 0)                                // prüfen ob der LPT1 vorhanden wenn nein error
       // exit(0);
    
      wxString s = _("OnServerEvent: ");
      wxSocketBase *sock;
    
      switch(event.GetSocketEvent())
      {
        case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION\n")); break;
        default                  : s.Append(_("Unexpected event !\n")); break;
      }
    
      m_text->AppendText(s);
    
      // Accept new connection if there is one in the pending
      // connections queue, else exit. We use Accept(false) for
      // non-blocking accept (although if we got here, there
      // should ALWAYS be a pending connection).
    
      sock = m_server->Accept(false);
    
      if (sock)
      {
        m_text->AppendText(_("New client connection accepted\n\n"));
      }
      else
      {
        m_text->AppendText(_("Error: couldn't accept a new connection\n\n"));
        return;
      }
    
      sock->SetEventHandler(*this, SOCKET_ID);
      sock->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG);
      sock->Notify(true);
    
      m_numClients++;
      UpdateStatusBar();
    }
    
    void MyFrame::OnSocketEvent(wxSocketEvent& event)
    {
      wxString s = _("OnSocketEvent: ");
      wxSocketBase *sock = event.GetSocket();
    
      // First, print a message
      switch(event.GetSocketEvent())
      {
        case wxSOCKET_INPUT : s.Append(_("wxSOCKET_INPUT\n")); break;
        case wxSOCKET_LOST  : s.Append(_("wxSOCKET_LOST\n")); break;
        default             : s.Append(_("Unexpected event !\n")); break;
      }
    
      m_text->AppendText(s);
    
      // Now we process the event
      switch(event.GetSocketEvent())
      {
        case wxSOCKET_INPUT:
        {
          // We disable input events, so that the test doesn't trigger
          // wxSocketEvent again.
          sock->SetNotify(wxSOCKET_LOST_FLAG);
    
          // Which test are we going to run?
          unsigned char c;
          sock->Read(&c, 1);
    
          switch (c)
          {
            case 0xAE: Pin1(sock); break;
            case 0xBE: Pin2(sock); break;
            case 0xCE: Pin3(sock); break;
            case 0xDE: Pin4(sock); break;
            case 0xEE: Pin5(sock); break;
            case 0xFE: Pin6(sock); break;
            case 0xFF: Pin7(sock); break;
            case 0xFA: Pin8(sock); break;
            default:
              m_text->AppendText(_("Unknown id received from client\n\n"));
          }
    
          // Enable input events again.
          sock->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
          break;
        }
        case wxSOCKET_LOST:
        {
          m_numClients--;
    
          m_text->AppendText(_("Deleting socket.\n\n"));
          sock->Destroy();
          break;
        }
        default: ;
      }
    
      UpdateStatusBar();
    }
    
    // convenience functions
    
    void MyFrame::UpdateStatusBar()
    {
    #if wxUSE_STATUSBAR
      wxString s;
      s.Printf(_("%d clients connected"), m_numClients);
      SetStatusText(s, 1);
    #endif // wxUSE_STATUSBAR
    }
    


  • Einfach von wxAppConsole ableiten und IMPLEMENT_APP_CONSOLE verwenden. Dann kann man auch eine Konsolenanwendung schreiben. Darfst dann halt keine GUI-Elemente verwenden. Am besten wäre es du würdest das ganze pin-zeug in eine DLL auslagern und die GUI bzw Konsolenanwendungen etra schreiben.
    rya.,



  • Dann gibt's doch noch dieses Flag wxUSE_GUI, mit dem du das glaube ich kompilieren solltest. Und dann einfach nur gegen wxbase linken.



  • wxSkip schrieb:

    Dann gibt's doch noch dieses Flag wxUSE_GUI, mit dem du das glaube ich kompilieren solltest. Und dann einfach nur gegen wxbase linken.



  • Scorcher24 schrieb:

    wxSkip schrieb:

    Dann gibt's doch noch dieses Flag wxUSE_GUI, mit dem du das glaube ich kompilieren solltest. Und dann einfach nur gegen wxbase linken.

    Wieso nö? Er hat doch recht, oder?
    Also man sollte das Flag wxUSE_GUI eben auf 0 setzen in der setup.h denke ich...



  • daersc schrieb:

    Scorcher24 schrieb:

    wxSkip schrieb:

    Dann gibt's doch noch dieses Flag wxUSE_GUI, mit dem du das glaube ich kompilieren solltest. Und dann einfach nur gegen wxbase linken.

    Wieso nö? Er hat doch recht, oder?
    Also man sollte das Flag wxUSE_GUI eben auf 0 setzen in der setup.h denke ich...

    Nein, wieso? oO
    Die setup.h setzt man zur compilezeit von wxWidgets wie man es braucht.
    Man muss eben nur beim programmieren der app darauf achten dass man von wxAppConsole ableitet und IMPLEMENT_APP_CONSOLE verwendet. Kein Grund in der Setup.h rumzufummeln oder mit Flags um sich zu werfen. Man könnte natürlich

    #undef wxUSE_GUI 
    #define wxUSE_GUI 0
    

    machen, aber ich seh da keinen Sinn darin. Der Linker sollte nur linken was er auch braucht. Ich gebe meinem Linker immer alle .libs in die Settings die wxWidgets hat und brauch am Ende doch nur nen Bruchteil der .dlls....
    rya.



  • Vielen Dank für die Antworten. Ich habe es jetzt gelöst, habe erst ein Hallo Welt für die Console mit WXWidget erstellt und dann nach und nach den rest übernommen und alles was mit gui zu tun hatte weggelassen und die text ausgabe befehle durch cout ersetzt.
    So funktioniert das ganze jetzt auf jedenfall.
    Und wenn ich mal noch genügend muse habe schreibe ich es (falls möglich ) so um das es per /gui /nogui einfach beides kann. 🙂

    Vielen dank

    Klagges



  • Mmh, mach ne proxy-app die dann je nach switch das korrekte Programm startet. 🙂
    Also eine binary die die parameter annimmt und für die Konsole und GUI Version je eine Binary.. wäre auch ne Lösung.


Log in to reply