options_dialog.cpp

Go to the documentation of this file.

/*
 *  Copyright (C) Massimo Cora' 2005-2006 <maxcvs@email.it>
 *  Copyright (C) Fabio Zecchini 2005 <zio.zec@gmail.com>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

#if defined(__GNUG__) && !defined(__APPLE__)
#pragma implementation "options_dialog.h"
#endif

// For compilers that support precompilation, includes "wx/wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/wx.h"
#endif


#include "options_dialog.h"
#include <wx/socket.h>


#include "main_frame.h"



IMPLEMENT_DYNAMIC_CLASS( DialogOptions, wxDialog )


BEGIN_EVENT_TABLE( DialogOptions, wxDialog )

    EVT_BUTTON( ID_BUTTON2, DialogOptions::OnButton3Click )

    EVT_COMBOBOX( ID_COMBOBOX, DialogOptions::OnComboboxSelected )

    EVT_BUTTON( ID_BUTTON1, DialogOptions::OnButton1Click )

    EVT_CHECKBOX( ID_CHECK_XML1, DialogOptions::OnCheckboxXmlFile1 )

    EVT_BUTTON( ID_BUTTON, DialogOptions::OnButton2Click )

    EVT_CHECKBOX( ID_CHECK_XML2, DialogOptions::OnCheckboxXmlFile2 )

    EVT_CHECKBOX( ID_CHECKBOX3, DialogOptions::OnGcardUseClick )

    EVT_BUTTON( ID_OPTIONS_BUTTON_CANCEL, DialogOptions::OnOptionsButtonCancelClick )

    EVT_BUTTON( ID_OPTIONS_BUTTON_OK, DialogOptions::OnOptionsButtonOkClick )


END_EVENT_TABLE()

DialogOptions::DialogOptions( )
{
}

DialogOptions::DialogOptions( wxWindow* parent, StreamerCtrlThread *streamer_thread, 
                                                         ReceiverCtrlThread *receiver_thread,
                                                         MainFrame *mainframe_pointer,
                                                         wxWindowID id, const wxString& caption, const wxPoint& pos, 
                                                         const wxSize& size, long style )
{

        // set up our threads pointers
        m_streamer_thread = streamer_thread;
        m_receiver_thread = receiver_thread;

        // and the mainframe class pointer [useful for callback purposes]
        m_mainframe_pointer = mainframe_pointer;

    Create(parent, id, caption, pos, size, style);
}

bool DialogOptions::Create( wxWindow* parent, wxWindowID id, const wxString& caption, 
                                                   const wxPoint& pos, const wxSize& size, long style )
{
    m_panel_streamer = NULL;
    m_rtsp_stream_text = NULL;
    m_start_rtsp_check = NULL;
    m_rtsp_port_text = NULL;
    m_rtsp_fps_text = NULL;
    m_proto_choose = NULL;
    m_multi_face_stream_check = NULL;
    m_multi_face_stream_text = NULL;
    m_grab_video_check = NULL;
    m_grab_video_text = NULL;
    m_grab_file_check = NULL;
    m_grab_file_text = NULL;
    m_grab_audio_check = NULL;
    m_grab_audio_text = NULL;
    m_uni_setting = NULL;
    m_stream_receive_iface_text = NULL;
    m_stream_send_iface_text = NULL;
    m_panel_client = NULL;
    m_receive_stream_text = NULL;
    m_receive_stream_check = NULL;
    m_receive_audio_check = NULL;
    m_panel_preferences = NULL;
    m_face_tracking_check = NULL;
    m_algorithm_choose = NULL;
    m_flipped_mode_check = NULL;
    m_xml_file_1 = NULL;
    xml_button_1 = NULL;
    m_xml_enable_1 = NULL;
    m_xml_file_2 = NULL;
    xml_button_2 = NULL;
    m_xml_enable_2 = NULL;
    m_freeze_time = NULL;
    m_hitrate = NULL;
    m_gcard_use_check = NULL;
    m_radius_min = NULL;
    m_radius_max = NULL;
    m_center_x = NULL;
    m_center_y = NULL;

    SetExtraStyle(GetExtraStyle()|wxWS_EX_BLOCK_EVENTS);
    wxDialog::Create( parent, id, caption, pos, size, style );

    CreateControls();
    GetSizer()->Fit(this);
    GetSizer()->SetSizeHints(this);
    Centre();


        // try to set the checks buttons to a disable-mode
        if ( m_streamer_thread->isStreaming() ) {
                m_start_rtsp_check->SetValue( true );
                m_start_rtsp_check->Enable( false );

                // FIXME: disable client/preferences panel.
                m_panel_client->Enable( false );
                m_panel_preferences->Enable( false );
        }

        if ( m_receiver_thread->isReceiving() ) {
                m_receive_stream_check->SetValue( true );
                m_receive_stream_check->Enable( false );

                // FIXME
                m_panel_streamer->Enable( false );
        }


    return TRUE;
}

void DialogOptions::CreateControls()
{    
    DialogOptions* itemDialog1 = this;

    wxBoxSizer* itemBoxSizer2 = new wxBoxSizer(wxVERTICAL);
    itemDialog1->SetSizer(itemBoxSizer2);

    wxBoxSizer* itemBoxSizer3 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer2->Add(itemBoxSizer3, 0, wxALIGN_CENTER_HORIZONTAL|wxALL, 5);

    wxNotebook* itemNotebook4 = new wxNotebook( itemDialog1, ID_NOTEBOOK, wxDefaultPosition, wxDefaultSize, wxNB_TOP );

    m_panel_streamer = new wxPanel( itemNotebook4, ID_PANEL_STREAMER, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
    wxBoxSizer* itemBoxSizer6 = new wxBoxSizer(wxVERTICAL);
    m_panel_streamer->SetSizer(itemBoxSizer6);

    wxStaticBox* itemStaticBoxSizer7Static = new wxStaticBox(m_panel_streamer, wxID_ANY, _("General server setting :"));
    wxStaticBoxSizer* itemStaticBoxSizer7 = new wxStaticBoxSizer(itemStaticBoxSizer7Static, wxVERTICAL);
    itemBoxSizer6->Add(itemStaticBoxSizer7, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer8 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer7->Add(itemBoxSizer8, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText9 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Stream subsession"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer8->Add(itemStaticText9, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer8->Add(14, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_rtsp_stream_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL8, _("testStream"), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        m_rtsp_stream_text->SetToolTip(_("To receive the stream the client side must set a rtsp path like \"rtsp://12.34.56.78/testStream\". This is the subsession \"/testStream\" part."));
    itemBoxSizer8->Add(m_rtsp_stream_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer8->Add(5, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_start_rtsp_check = new wxCheckBox( m_panel_streamer, ID_CHECKBOX6, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_start_rtsp_check->SetValue(FALSE);
    itemBoxSizer8->Add(m_start_rtsp_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer14 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer7->Add(itemBoxSizer14, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText15 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("RTSP Port (TCP) :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer14->Add(itemStaticText15, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer14->Add(15, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_rtsp_port_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL5, _("8554"), wxDefaultPosition, wxSize(40, -1), 0 );
    if (ShowToolTips())
        m_rtsp_port_text->SetToolTip(_("the port the RTSPServer wll listen to"));
    itemBoxSizer14->Add(m_rtsp_port_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer18 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer7->Add(itemBoxSizer18, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText19 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("FPS :"), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        itemStaticText19->SetToolTip(_("Frames per second"));
    itemBoxSizer18->Add(itemStaticText19, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer18->Add(75, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_rtsp_fps_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL, _("25"), wxDefaultPosition, wxSize(40, -1), 0 );
    if (ShowToolTips())
        m_rtsp_fps_text->SetToolTip(_("Frames per second"));
    itemBoxSizer18->Add(m_rtsp_fps_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer22 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer7->Add(itemBoxSizer22, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText23 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Protocol"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer22->Add(itemStaticText23, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer22->Add(61, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxString m_proto_chooseStrings[] = {
        _("H263+"),
        _("MJPEG")
    };
    m_proto_choose = new wxComboBox( m_panel_streamer, ID_COMBOBOX1, _("H263+"), wxDefaultPosition, wxDefaultSize, 2, m_proto_chooseStrings, wxCB_READONLY );
    m_proto_choose->SetStringSelection(_("H263+"));
    if (ShowToolTips())
        m_proto_choose->SetToolTip(_("choose the protocol you want to stream with"));
    itemBoxSizer22->Add(m_proto_choose, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer26Static = new wxStaticBox(m_panel_streamer, wxID_ANY, _("Serverside computing [needs OmniStuff preferences]"));
    wxStaticBoxSizer* itemStaticBoxSizer26 = new wxStaticBoxSizer(itemStaticBoxSizer26Static, wxVERTICAL);
    itemBoxSizer6->Add(itemStaticBoxSizer26, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer27 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer26->Add(itemBoxSizer27, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText28 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Multi face stream"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer27->Add(itemStaticText28, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer27->Add(20, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_multi_face_stream_check = new wxCheckBox( m_panel_streamer, ID_CHECKBOX1, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_multi_face_stream_check->SetValue(FALSE);
    if (ShowToolTips())
        m_multi_face_stream_check->SetToolTip(_("Enabling this option will assure that all the face detecting/tracking/etc computing is done on server. Client will then receive only the detected faces"));
    itemBoxSizer27->Add(m_multi_face_stream_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer27->Add(10, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText32 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Max streams"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer27->Add(itemStaticText32, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer27->Add(10, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_multi_face_stream_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL3, _("5"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer27->Add(m_multi_face_stream_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer35Static = new wxStaticBox(m_panel_streamer, wxID_ANY, _("Video"));
    wxStaticBoxSizer* itemStaticBoxSizer35 = new wxStaticBoxSizer(itemStaticBoxSizer35Static, wxVERTICAL);
    itemBoxSizer6->Add(itemStaticBoxSizer35, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer36 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer35->Add(itemBoxSizer36, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText37 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Grab webcam"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer36->Add(itemStaticText37, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer36->Add(32, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_grab_video_check = new wxCheckBox( m_panel_streamer, ID_CHECKBOX7, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_grab_video_check->SetValue(TRUE);
    itemBoxSizer36->Add(m_grab_video_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer36->Add(10, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText41 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Input port"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer36->Add(itemStaticText41, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer36->Add(25, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_grab_video_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL6, _("0"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer36->Add(m_grab_video_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticLine* itemStaticLine44 = new wxStaticLine( m_panel_streamer, wxID_STATIC, wxDefaultPosition, wxDefaultSize, wxLI_VERTICAL );
    itemStaticBoxSizer35->Add(itemStaticLine44, 0, wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer45 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer35->Add(itemBoxSizer45, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText46 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Grab from file"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer45->Add(itemStaticText46, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer45->Add(35, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_grab_file_check = new wxCheckBox( m_panel_streamer, ID_CHECKBOX8, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_grab_file_check->SetValue(FALSE);
    itemBoxSizer45->Add(m_grab_file_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer49 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer35->Add(itemBoxSizer49, 0, wxGROW|wxALL, 5);
    m_grab_file_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL7, _T(""), wxDefaultPosition, wxSize(230, -1), 0 );
    itemBoxSizer49->Add(m_grab_file_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton51 = new wxButton( m_panel_streamer, ID_BUTTON2, _("Path..."), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer49->Add(itemButton51, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer52Static = new wxStaticBox(m_panel_streamer, wxID_ANY, _("Audio"));
    wxStaticBoxSizer* itemStaticBoxSizer52 = new wxStaticBoxSizer(itemStaticBoxSizer52Static, wxVERTICAL);
    itemBoxSizer6->Add(itemStaticBoxSizer52, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer53 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer52->Add(itemBoxSizer53, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText54 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Grab audio"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer53->Add(itemStaticText54, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer53->Add(47, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_grab_audio_check = new wxCheckBox( m_panel_streamer, ID_CHECKBOX5, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_grab_audio_check->SetValue(FALSE);
    itemBoxSizer53->Add(m_grab_audio_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer53->Add(10, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText58 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Input port"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer53->Add(itemStaticText58, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer53->Add(25, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_grab_audio_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL4, _("0"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer53->Add(m_grab_audio_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_uni_setting = new wxStaticBox(m_panel_streamer, wxID_ANY, _("Unicast setting : "));
    wxStaticBoxSizer* itemStaticBoxSizer61 = new wxStaticBoxSizer(m_uni_setting, wxVERTICAL);
    itemBoxSizer6->Add(itemStaticBoxSizer61, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer62 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer61->Add(itemBoxSizer62, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText63 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Receiving interface ip :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer62->Add(itemStaticText63, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    m_stream_receive_iface_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL2, _("0.0.0.0"), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        m_stream_receive_iface_text->SetToolTip(_("Enter the ip address of the interface you want to receive to"));
    itemBoxSizer62->Add(m_stream_receive_iface_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer65 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer61->Add(itemBoxSizer65, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText66 = new wxStaticText( m_panel_streamer, wxID_STATIC, _("Sending interface ip:    "), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer65->Add(itemStaticText66, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    m_stream_send_iface_text = new wxTextCtrl( m_panel_streamer, ID_TEXTCTRL1, _("0.0.0.0"), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        m_stream_send_iface_text->SetToolTip(_("Enter the ip address of the interface you want to stream from"));
    itemBoxSizer65->Add(m_stream_send_iface_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemNotebook4->AddPage(m_panel_streamer, _("RTSP Server"));

    m_panel_client = new wxPanel( itemNotebook4, ID_PANEL_CLIENT_STREAM, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
    wxBoxSizer* itemBoxSizer69 = new wxBoxSizer(wxVERTICAL);
    m_panel_client->SetSizer(itemBoxSizer69);

    wxStaticBox* itemStaticBoxSizer70Static = new wxStaticBox(m_panel_client, wxID_ANY, _("Client setting :"));
    wxStaticBoxSizer* itemStaticBoxSizer70 = new wxStaticBoxSizer(itemStaticBoxSizer70Static, wxVERTICAL);
    itemBoxSizer69->Add(itemStaticBoxSizer70, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer71 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer70->Add(itemBoxSizer71, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText72 = new wxStaticText( m_panel_client, wxID_STATIC, _("RTSP address: "), wxDefaultPosition, wxDefaultSize, 0 );
    if (ShowToolTips())
        itemStaticText72->SetToolTip(_("Should be an address like rtsp://82.83.84.1/testStream"));
    itemBoxSizer71->Add(itemStaticText72, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer71->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_receive_stream_text = new wxTextCtrl( m_panel_client, ID_TEXTCTRL10, _("rtsp://192.168.2.2:8554/testStream"), wxDefaultPosition, wxSize(200, -1), 0 );
    if (ShowToolTips())
        m_receive_stream_text->SetToolTip(_("rtsp://host[:port]/streamPath"));
    itemBoxSizer71->Add(m_receive_stream_text, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer71->Add(5, 5, 0, wxGROW|wxALL, 5);

    wxBoxSizer* itemBoxSizer76 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer70->Add(itemBoxSizer76, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText77 = new wxStaticText( m_panel_client, wxID_STATIC, _("Connect and receive stream(s)"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer76->Add(itemStaticText77, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer76->Add(5, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_receive_stream_check = new wxCheckBox( m_panel_client, ID_CHECKBOX2, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_receive_stream_check->SetValue(FALSE);
    if (ShowToolTips())
        m_receive_stream_check->SetToolTip(_("Connect to the specified address and receive the video stream, displaying it.\nIf the omnidirectional-face tracking is checked the program will try to find human faces and it will display them separately. In this version you can only run a receiver or exclusively a streamer per Omnimeeting instance.  Will be fixed in next version."));
    itemBoxSizer76->Add(m_receive_stream_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer80Static = new wxStaticBox(m_panel_client, wxID_ANY, _("Audio"));
    wxStaticBoxSizer* itemStaticBoxSizer80 = new wxStaticBoxSizer(itemStaticBoxSizer80Static, wxVERTICAL);
    itemBoxSizer69->Add(itemStaticBoxSizer80, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer81 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer80->Add(itemBoxSizer81, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText82 = new wxStaticText( m_panel_client, wxID_STATIC, _("Receive and playback MP3 audio stream (if available)"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer81->Add(itemStaticText82, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer81->Add(5, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_receive_audio_check = new wxCheckBox( m_panel_client, ID_CHECKBOX4, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_receive_audio_check->SetValue(TRUE);
    if (ShowToolTips())
        m_receive_audio_check->SetToolTip(_("If audio is streamed by server we will receive and play it."));
    itemBoxSizer81->Add(m_receive_audio_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemNotebook4->AddPage(m_panel_client, _("Client Stream"));

    m_panel_preferences = new wxPanel( itemNotebook4, ID_PANEL_PREFERENCES, wxDefaultPosition, wxDefaultSize, wxSUNKEN_BORDER|wxTAB_TRAVERSAL );
    wxBoxSizer* itemBoxSizer86 = new wxBoxSizer(wxVERTICAL);
    m_panel_preferences->SetSizer(itemBoxSizer86);

    wxStaticBox* itemStaticBoxSizer87Static = new wxStaticBox(m_panel_preferences, wxID_ANY, _("Omnidirectional Face Detecting and Tracking"));
    wxStaticBoxSizer* itemStaticBoxSizer87 = new wxStaticBoxSizer(itemStaticBoxSizer87Static, wxVERTICAL);
    itemBoxSizer86->Add(itemStaticBoxSizer87, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer88 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer87->Add(itemBoxSizer88, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText89 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("Face detecting/tracking"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer88->Add(itemStaticText89, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer88->Add(5, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_face_tracking_check = new wxCheckBox( m_panel_preferences, ID_CHECKBOX, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_face_tracking_check->SetValue(FALSE);
    if (ShowToolTips())
        m_face_tracking_check->SetToolTip(_("Face tracking feature, works ONLY with an omnidirectional stream!"));
    itemBoxSizer88->Add(m_face_tracking_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer92 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer87->Add(itemBoxSizer92, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText93 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("Detection Algorithm"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer92->Add(itemStaticText93, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer92->Add(5, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxString m_algorithm_chooseStrings[] = {
        _("SimpleDetection"),
        _("VRFilterDetection")
    };
    m_algorithm_choose = new wxComboBox( m_panel_preferences, ID_COMBOBOX, _("SimpleDetection"), wxDefaultPosition, wxDefaultSize, 2, m_algorithm_chooseStrings, wxCB_READONLY );
    m_algorithm_choose->SetStringSelection(_("SimpleDetection"));
    itemBoxSizer92->Add(m_algorithm_choose, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer96 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer87->Add(itemBoxSizer96, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText97 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("Flipped mode"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer96->Add(itemStaticText97, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer96->Add(5, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_flipped_mode_check = new wxCheckBox( m_panel_preferences, ID_CHECKBOX9, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_flipped_mode_check->SetValue(FALSE);
    itemBoxSizer96->Add(m_flipped_mode_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer100Static = new wxStaticBox(m_panel_preferences, wxID_ANY, _("Haarcascades [only SimpleDetection]"));
    wxStaticBoxSizer* itemStaticBoxSizer100 = new wxStaticBoxSizer(itemStaticBoxSizer100Static, wxVERTICAL);
    itemBoxSizer86->Add(itemStaticBoxSizer100, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer101 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer100->Add(itemBoxSizer101, 0, wxGROW|wxALL, 5);
    m_xml_file_1 = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL11, _T(""), wxDefaultPosition, wxSize(200, -1), 0 );
    if (ShowToolTips())
        m_xml_file_1->SetToolTip(_("Insert an Haar Cascade xml file [you can find them into OpenCv distribution] or provide one made by yourself"));
    itemBoxSizer101->Add(m_xml_file_1, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    xml_button_1 = new wxButton( m_panel_preferences, ID_BUTTON1, _("Path..."), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer101->Add(xml_button_1, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_xml_enable_1 = new wxCheckBox( m_panel_preferences, ID_CHECK_XML1, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_xml_enable_1->SetValue(FALSE);
    itemBoxSizer101->Add(m_xml_enable_1, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer105 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer100->Add(itemBoxSizer105, 0, wxGROW|wxALL, 5);
    m_xml_file_2 = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL9, _T(""), wxDefaultPosition, wxSize(200, -1), 0 );
    if (ShowToolTips())
        m_xml_file_2->SetToolTip(_("Insert an Haar Cascade xml file [you can find them into OpenCv distribution] or provide one made by yourself"));
    itemBoxSizer105->Add(m_xml_file_2, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    xml_button_2 = new wxButton( m_panel_preferences, ID_BUTTON, _("Path..."), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer105->Add(xml_button_2, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_xml_enable_2 = new wxCheckBox( m_panel_preferences, ID_CHECK_XML2, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_xml_enable_2->SetValue(FALSE);
    itemBoxSizer105->Add(m_xml_enable_2, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer109 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer100->Add(itemBoxSizer109, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText110 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("Freeze time :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer109->Add(itemStaticText110, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    m_freeze_time = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL13, _("20"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer109->Add(m_freeze_time, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer109->Add(50, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText113 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("Track window hitrate :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer109->Add(itemStaticText113, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    m_hitrate = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL14, _("0.80"), wxDefaultPosition, wxSize(40, -1), 0 );
    itemBoxSizer109->Add(m_hitrate, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer115Static = new wxStaticBox(m_panel_preferences, wxID_ANY, _("Hardware options"));
    wxStaticBoxSizer* itemStaticBoxSizer115 = new wxStaticBoxSizer(itemStaticBoxSizer115Static, wxVERTICAL);
    itemBoxSizer86->Add(itemStaticBoxSizer115, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer116 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer115->Add(itemBoxSizer116, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText117 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("Use hardware 3d graphic card acceleration"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer116->Add(itemStaticText117, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer116->Add(12, 5, 2, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_gcard_use_check = new wxCheckBox( m_panel_preferences, ID_CHECKBOX3, _("Enable"), wxDefaultPosition, wxDefaultSize, wxCHK_2STATE );
    m_gcard_use_check->SetValue(FALSE);
    if (ShowToolTips())
        m_gcard_use_check->SetToolTip(_("Enabling this there will be a check if your card support pixel and vertex shaders. The hardware acceleration is used to convert from Omnidirectional Images to Panoramic ones."));
    itemBoxSizer116->Add(m_gcard_use_check, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticBox* itemStaticBoxSizer120Static = new wxStaticBox(m_panel_preferences, wxID_ANY, _("Omnidirectional Options :"));
    wxStaticBoxSizer* itemStaticBoxSizer120 = new wxStaticBoxSizer(itemStaticBoxSizer120Static, wxVERTICAL);
    itemBoxSizer86->Add(itemStaticBoxSizer120, 0, wxGROW|wxALL, 5);
    wxBoxSizer* itemBoxSizer121 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer120->Add(itemBoxSizer121, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText122 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("RAY MIN :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer121->Add(itemStaticText122, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer121->Add(12, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_radius_min = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL15, _("40"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer121->Add(m_radius_min, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer121->Add(65, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText126 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("RAY MAX :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer121->Add(itemStaticText126, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer121->Add(8, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_radius_max = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL16, _("220"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer121->Add(m_radius_max, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxBoxSizer* itemBoxSizer129 = new wxBoxSizer(wxHORIZONTAL);
    itemStaticBoxSizer120->Add(itemBoxSizer129, 0, wxGROW|wxALL, 5);
    wxStaticText* itemStaticText130 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("CENTER X :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer129->Add(itemStaticText130, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer129->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_center_x = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL17, _("326"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer129->Add(m_center_x, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemBoxSizer129->Add(65, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxStaticText* itemStaticText134 = new wxStaticText( m_panel_preferences, wxID_STATIC, _("CENTER Y :"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer129->Add(itemStaticText134, 0, wxALIGN_CENTER_VERTICAL|wxALL|wxADJUST_MINSIZE, 5);

    itemBoxSizer129->Add(5, 5, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    m_center_y = new wxTextCtrl( m_panel_preferences, ID_TEXTCTRL18, _("250"), wxDefaultPosition, wxSize(30, -1), 0 );
    itemBoxSizer129->Add(m_center_y, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    itemNotebook4->AddPage(m_panel_preferences, _("Omnistuff preferences"));

    itemBoxSizer3->Add(itemNotebook4, 0, wxALIGN_CENTER_VERTICAL|wxALL, 2);

    wxBoxSizer* itemBoxSizer137 = new wxBoxSizer(wxHORIZONTAL);
    itemBoxSizer2->Add(itemBoxSizer137, 0, wxALIGN_RIGHT|wxALL, 5);

    wxButton* itemButton138 = new wxButton( itemDialog1, ID_OPTIONS_BUTTON_CANCEL, _("Cancel"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer137->Add(itemButton138, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);

    wxButton* itemButton139 = new wxButton( itemDialog1, ID_OPTIONS_BUTTON_OK, _("OK"), wxDefaultPosition, wxDefaultSize, 0 );
    itemBoxSizer137->Add(itemButton139, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5);



        m_xml_file_2->Disable();
        xml_button_2->Disable();

}

bool DialogOptions::ShowToolTips()
{
    return TRUE;
}

wxBitmap DialogOptions::GetBitmapResource( const wxString& name )
{
    // Bitmap retrieval
    return wxNullBitmap;
}

wxIcon DialogOptions::GetIconResource( const wxString& name )
{
    // Icon retrieval
    return wxNullIcon;
}
void DialogOptions::OnOptionsButtonCancelClick( wxCommandEvent& event )
{
    // Before editing this code, remove the block markers.
    Destroy();
}


void DialogOptions::OnOptionsButtonOkClick( wxCommandEvent& event )
{
        // we must parse the options given by the user.
        
        //
        //
        //              S T R E A M I N G
        //
        //

        // first of all check the rtsp server status and its mode [on/off]
        if ( m_start_rtsp_check->IsChecked() && m_start_rtsp_check->IsEnabled() ) {
                // check if thread is running. If it is simply return
                if ( m_streamer_thread->isStreaming() ) {
                        wxMessageDialog dlg1( this, wxT( "RTSP Server is already running!" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                wxString rtsp_stream_str = m_rtsp_stream_text->GetValue();
                if ( rtsp_stream_str.IsEmpty() ) {
                        wxMessageDialog dlg1( this, wxT( "Please fill in a Stream value!" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                wxString rtsp_port = m_rtsp_port_text->GetValue();
                if ( rtsp_port.IsEmpty() || !rtsp_port.IsNumber() ) {
                        wxMessageDialog dlg1( this, wxT( "Please fill in a correct port number value!" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                wxString rtsp_fps = m_rtsp_fps_text->GetValue();
                if ( rtsp_fps.IsEmpty() || !rtsp_fps.IsNumber() ) {
                        wxMessageDialog dlg1( this, wxT( "Please fill in a correct FPS value!" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                // is webcam/file both disabled? then we cannot start server
                if ( !m_grab_video_check->IsChecked() && !m_grab_file_check->IsChecked() && 
                        !m_grab_audio_check->IsChecked() ) {
                        wxMessageDialog dlg1( this, wxT( "Please choose where to grab from: webcam or file of microphone!" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                wxString rtsp_webcam_port;
                wxString file_path;

                // webcam will be the default, even if file_grab is enabled.
                if ( m_grab_video_check->IsChecked() ) {
                        m_grab_video_text->GetValue();
                } 
                else {          // file stuff
                        if ( m_grab_file_text->GetValue().IsEmpty() ) {
                                wxMessageDialog dlg1( this, wxT( "Please choose file path!" ), wxT( "Info" ), wxOK );
                                dlg1.ShowModal();
                                return;
                        }
                        file_path = m_grab_file_text->GetValue();
                }

                // choose proto
                wxString rtsp_proto = m_proto_choose->GetValue();

                // number of streams
                long num_of_streams;
                if ( !m_multi_face_stream_check->IsChecked () ) {
                        num_of_streams = 1;
                }
                else {
                        if ( !m_face_tracking_check->IsChecked() ) {
                                wxMessageDialog dlg1( this, 
                                        wxT( "Please fill up the Omnistuff options, then enable this option" ), 
                                        wxT( "Info" ), wxOK );
                                dlg1.ShowModal();
                                return;
                        }
                        else {          // set the omnistuff values for MULTISTREAM

                                wxString n_streams = m_multi_face_stream_text->GetValue ();
                
                                // get the number of streams
                                if ( n_streams.IsEmpty () || !n_streams.IsNumber () ) {
                                        num_of_streams = 1;
                                }
                                else {
                                        n_streams.ToLong( &num_of_streams );
                                }

                                // and th eomnidirectional stuff options
                                wxArrayString *c_array = new wxArrayString();

                                int cascade_count = 0;

                                if ( m_xml_enable_1->IsChecked() ) { 
                                        wxString str = m_xml_file_1->GetValue();
                                        if ( !str.IsEmpty() ) {
                                                c_array->Add(str);
                                                cascade_count++;
                                        }
                                }

                                if ( m_xml_enable_2->IsChecked() ) {
                                        wxString str = m_xml_file_2->GetValue();
                                        if ( !str.IsEmpty() ) {
                                                c_array->Add(str);
                                                cascade_count++;
                                        }
                                }

                                wxString algorithm_str = m_algorithm_choose->GetValue();
                                bool algo_simple;

                                if ( algorithm_str.CompareTo( wxT("SimpleDetection") ) == 0 ){
                                        algo_simple = true;
                                }
                                else {
                                        algo_simple = false;
                                }

                                // get radius_max, min and center_x, y 
                                long max_, min_, x = 0, y = 0;
                                long freeze;
                                double hitrate;

                                (m_radius_max->GetValue()).ToLong(&max_);
                                (m_radius_min->GetValue()).ToLong(&min_);
                                (m_center_x->GetValue()).ToLong(&x);
                                (m_center_y->GetValue()).ToLong(&y);
                                (m_freeze_time->GetValue()).ToLong(&freeze);
                                (m_hitrate->GetValue()).ToDouble(&hitrate);
                        
                                // setFacetrackOptions
                                m_mainframe_pointer->SetFacetrackOptions( c_array, cascade_count, (int)min_,
                                         (int)max_, (int)x, (int)y, (int)freeze, hitrate, 
                                         m_gcard_use_check->IsChecked (), m_flipped_mode_check->IsChecked(), num_of_streams, algo_simple );
                        }                       
                }

                long audio_port;
                if ( !m_grab_audio_check->IsChecked () ) {
                        audio_port = -1;
                }
                else {
                        wxString g_audio = m_grab_audio_text->GetValue ();

                        if ( g_audio.IsEmpty () || !g_audio.IsNumber () ) {
                                audio_port = -1;
                        }
                        else {
                                g_audio.ToLong( &audio_port );
                        }
                }


                // last conversions
                long rtsp_port_int, rtsp_fps_int, rtsp_webcam_port_int;
                
                rtsp_port.ToLong( &rtsp_port_int );
                rtsp_fps.ToLong( &rtsp_fps_int );
                rtsp_webcam_port.ToLong( &rtsp_webcam_port_int );


                // last check: should we use audio or video?
                if ( !m_multi_face_stream_check->IsChecked() && !m_grab_video_check->IsChecked() 
                        && !m_grab_file_check->IsChecked() ) {

                        // we will run only with audio stream...
                        rtsp_proto = wxString(wxT(""));;
                }


                //
                // create the thread object and run it
                //


                m_streamer_thread->Create( m_gcard_use_check->GetValue(), rtsp_proto, 
                        file_path, rtsp_webcam_port_int, (unsigned int)num_of_streams, (unsigned int)audio_port,
                        rtsp_stream_str, (unsigned short)rtsp_port_int, 
                         rtsp_fps_int );
                m_streamer_thread->Run();

                m_mainframe_pointer->PrintStatusBarMessage( wxT( "Start streaming..." ), 0 );
        }


        //
        //
        //              R E C E I V I N G 
        //
        //

        // should we receive a stream?
        if ( m_receive_stream_check->IsChecked() && m_receive_stream_check->IsEnabled() ) {
                if ( m_receiver_thread->isReceiving() ) {
                        wxMessageDialog dlg1( this, wxT( "RTSP Receiver is already running!" ), wxT( "Info" ), wxOK );
                        dlg1.ShowModal();
                        return;
                }

                wxString addr_str = m_receive_stream_text->GetValue();

                if ( addr_str.IsEmpty() ) {
                        wxMessageDialog dlg( this, wxT( "Please fill the RTSP address field" ), wxT( "Warning" ), wxOK );
                        dlg.ShowModal();
                        return;
                }

                // Should we perform a face tracking/detecting?
                // the stream we receive is an omnidirectional one?
                // do this check *only if* multistream is disabled
                if ( m_face_tracking_check->IsChecked() && !m_multi_face_stream_check->IsChecked() ) {
                        wxArrayString *c_array = new wxArrayString();

                        int cascade_count = 0;

                        if ( m_xml_enable_1->IsChecked() ) { 
                                wxString str = m_xml_file_1->GetValue();
                                if ( !str.IsEmpty() ) {
                                        c_array->Add(str);
                                        cascade_count++;
                                }
                        }

                        if ( m_xml_enable_2->IsChecked() ) {
                                wxString str = m_xml_file_2->GetValue();
                                if ( !str.IsEmpty() ) {
                                        c_array->Add(str);
                                        cascade_count++;
                                }
                        }

                        wxString algorithm_str = m_algorithm_choose->GetValue();

                        bool algo_simple;
                        if ( algorithm_str.CompareTo( wxT("SimpleDetection") ) == 0 ){
                                algo_simple = true;
                        }
                        else {
                                algo_simple = false;
                        }

                        // get radius_max, min and center_x, y 
                        long max_, min_, x = 0, y = 0;
                        long freeze;
                        double hitrate;

                        (m_radius_max->GetValue()).ToLong(&max_);
                        (m_radius_min->GetValue()).ToLong(&min_);
                        (m_center_x->GetValue()).ToLong(&x);
                        (m_center_y->GetValue()).ToLong(&y);
                        (m_freeze_time->GetValue()).ToLong(&freeze);
                        (m_hitrate->GetValue()).ToDouble(&hitrate);
                        
                        // setFacetrackOptions
                        m_mainframe_pointer->SetFacetrackOptions( c_array, cascade_count, (int)min_,
                                 (int)max_, (int)x, (int)y, (int)freeze, hitrate, 
                                 m_gcard_use_check->IsChecked (), m_flipped_mode_check->IsChecked(), 
                                 -1, algo_simple );
                }

                // let the server listening. Two seconds should suffice
#ifdef __LINUX__
                sleep (2);
#else
                Sleep(2);
#endif // ____LINUX__

                //
                // create the receiver and receive the stream
                // perform simple display of frames
                //
                m_receiver_thread->Create( addr_str, m_multi_face_stream_check->IsChecked () );
                m_receiver_thread->Run();
                
                m_mainframe_pointer->PrintStatusBarMessage( wxT( "Start receiving stream..." ), 1 );

        }

        Close();
        event.Skip();
}




void DialogOptions::OnButton1Click( wxCommandEvent& event )
{
    wxFileDialog file (this , wxT( "Choose haarcascade file.." ), wxT( "" ), wxT( "" ), wxT( "XML files (*.xml)|*.xml" ), wxOPEN);
        if ( file.ShowModal() ){
                
                m_xml_file_1->SetValue(file.GetPath());

        }

        file.Destroy();
}



void DialogOptions::OnButton2Click( wxCommandEvent& event )
{
        wxFileDialog file (this , wxT( "Choose haarcascade file.." ), wxT( "" ), wxT( "" ), wxT( "XML files (*.xml)|*.xml" ), wxOPEN);
        if ( file.ShowModal() ){
                
                m_xml_file_2->SetValue(file.GetPath());

        }

        file.Destroy();
}



void DialogOptions::OnButton3Click( wxCommandEvent& event )
{
        wxFileDialog file (this , wxT( "Choose video file.." ), wxT( "" ), wxT( "" ), wxT( "Video files (*.avi)|*.avi" ), wxOPEN);
        if ( file.ShowModal() ){
                
                m_grab_file_text->SetValue(file.GetPath());

        }

        file.Destroy();
}


void DialogOptions::OnCheckboxXmlFile1( wxCommandEvent& event )
{       
        if( m_xml_enable_1->IsChecked()){
                xml_button_1->Enable();
                m_xml_file_1->Enable();
        }
        else{
                xml_button_1->Disable();
                m_xml_file_1->Disable();
        }
}


void DialogOptions::OnCheckboxXmlFile2( wxCommandEvent& event )
{
        if( m_xml_enable_2->IsChecked()){
                xml_button_2->Enable();
                m_xml_file_2->Enable();
        }
        else{
                xml_button_2->Disable();
                m_xml_file_2->Disable();
        }
}


void DialogOptions::OnGcardUseClick( wxCommandEvent& event )
{
        // check for 3d gcard availability
        if ( OmniGCardConverter::check_for_3d_gcard_availability() == false ) {
                wxMessageDialog dlg1( this, 
                        wxT("Your card doesn't support pixel/vertex shader handling."
                        "This feature won't be available for your system.") , wxT( "Warning" ), wxOK );
                dlg1.ShowModal();

                m_gcard_use_check->SetValue( false );
        }

    // Before editing this code, remove the block markers.
    event.Skip();
}


void DialogOptions::OnComboboxSelected( wxCommandEvent& event )
{
    // Before editing this code, remove the block markers.
    event.Skip();
}

---