CDStarRepeaterConfigControllerSet::CDStarRepeaterConfigControllerSet(wxWindow* parent, int id, const wxString& title, const wxString& type, unsigned int config, bool pttInvert, unsigned int time) :
wxPanel(parent, id),
m_title(title),
m_type(NULL),
m_config(NULL),
m_pttInvert(NULL),
m_time(NULL)
{
	wxFlexGridSizer* sizer = new wxFlexGridSizer(2);

	wxStaticText* typeLabel = new wxStaticText(this, -1, _("Type"));
	sizer->Add(typeLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_type = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));

	m_type->Append(_("None"));

#if defined(GPIO)
	m_type->Append(wxT("GPIO"));
	m_type->Append(wxT("UDRC"));
#endif

	m_type->Append(wxT("Velleman K8055 - 0"));
	m_type->Append(wxT("Velleman K8055 - 1"));
	m_type->Append(wxT("Velleman K8055 - 2"));
	m_type->Append(wxT("Velleman K8055 - 3"));

	// Add the URI USB
        m_type->Append(wxT("URI USB - 1"));
        m_type->Append(wxT("URI USB - 2"));
        m_type->Append(wxT("URI USB - 3"));
        m_type->Append(wxT("URI USB - 4"));
        m_type->Append(wxT("URI USB - 5"));
        m_type->Append(wxT("URI USB - 6"));

	// Add the Serial ports
	wxArrayString serialDevs = CSerialPortSelector::getDevices();
	for (size_t i = 0U; i < serialDevs.GetCount(); i++)
		m_type->Append(wxT("Serial - ") + serialDevs.Item(i));

	// Add the Arduino ports
	serialDevs = CSerialPortSelector::getDevices();
	for (size_t i = 0U; i < serialDevs.GetCount(); i++)
		m_type->Append(wxT("Arduino - ") + serialDevs.Item(i));

	sizer->Add(m_type, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	if (type.IsEmpty())
		m_type->SetSelection(0);
	else
		m_type->SetStringSelection(type);

	wxStaticText* configLabel = new wxStaticText(this, -1, _("Config"));
	sizer->Add(configLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_config = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH3, -1));
	m_config->Append("1");
	m_config->Append("2");
	m_config->Append("3");
	m_config->Append("4");
	m_config->Append("5");
	sizer->Add(m_config, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_config->SetSelection(config - 1);

	wxStaticText* pttInvertLabel = new wxStaticText(this, -1, _("PTT Inversion"));
	sizer->Add(pttInvertLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_pttInvert = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH3, -1));
	m_pttInvert->Append(_("Off"));
	m_pttInvert->Append(_("On"));
	sizer->Add(m_pttInvert, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_pttInvert->SetSelection(pttInvert ? 1 : 0);

	wxStaticText* timeLabel = new wxStaticText(this, -1, _("Time (secs)"));
	sizer->Add(timeLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_time = new wxSlider(this, -1, time, 0, 300, wxDefaultPosition, wxSize(CONTROL_WIDTH2, -1), wxSL_HORIZONTAL | wxSL_LABELS);
	sizer->Add(m_time, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	SetAutoLayout(true);

	sizer->Fit(this);
	sizer->SetSizeHints(this);

	SetSizer(sizer);
}
Exemplo n.º 2
0
// Constructor
wxHandheldInstallCtrl::wxHandheldInstallCtrl(wxWindow *parent, wxWindowID id,
                          const wxString &users_message, const wxString &directories_message,
                          const wxPoint& pos, const wxSize& size, const wxString& name  )
   : wxPanel(parent, id, pos, size, wxTAB_TRAVERSAL, name)
{
    m_usersListCtrlImageId = 0;
    m_directoriesListCtrlImageId = 0;

    // Create a new instance of palm_installer to get data for the different controls
    m_palmInstaller = new palm_installer;

    // See constructor of winflip.cpp for comments
    wxFlexGridSizer *mainFlexGridSizer = new wxFlexGridSizer( 2, 3, 0 );

    mainFlexGridSizer->AddGrowableCol( 0 );
    mainFlexGridSizer->AddGrowableRow( 1 );
    mainFlexGridSizer->AddGrowableRow( 3 );

    wxStaticText *usersStaticText = new wxStaticText( this, -1,
                                         users_message,
                                         wxDefaultPosition, wxDefaultSize, 0 );

    mainFlexGridSizer->Add( usersStaticText, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5 );

    mainFlexGridSizer->Add( 1, 1, 0, wxALIGN_CENTRE, 25 );

    m_usersListCtrl = new pda_listctrl( this, wxID_HANDHELDINSTALLCTRL_USERS_LISTCTRL,
                                          wxDefaultPosition, wxDefaultSize,
                                          wxLC_REPORT|wxSUNKEN_BORDER,
                                          wxDefaultValidator, wxT( "users_listctrl" ),
                                          _( "Handheld destination" ),
                                          optionIS_USERS_LISTCTRL );

    mainFlexGridSizer->Add( m_usersListCtrl, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5 );

    wxFlexGridSizer *usersFlexGridSizer = new wxFlexGridSizer( 1, 0, 0 );
    usersFlexGridSizer->AddGrowableCol( 0 );

    m_usersAddButton = new wxButton( this, wxID_HANDHELDINSTALLCTRL_USERS_ADD_BUTTON,
                                     _( "Add handheld..." ),
                                     wxDefaultPosition, wxDefaultSize, 0 );

    usersFlexGridSizer->Add( m_usersAddButton, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    m_usersRemoveButton = new wxButton( this, wxID_HANDHELDINSTALLCTRL_USERS_REMOVE_BUTTON,
                                        _( "Remove selected handhelds" ),
                                        wxDefaultPosition, wxDefaultSize, 0 );

    usersFlexGridSizer->Add( m_usersRemoveButton, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    mainFlexGridSizer->Add( usersFlexGridSizer, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5 );

    wxStaticText *directoriesStaticText = new wxStaticText( this, -1,
                                          directories_message,
                                          wxDefaultPosition, wxDefaultSize, 0 );


    mainFlexGridSizer->Add( directoriesStaticText, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxTOP, 5 );

    mainFlexGridSizer->Add( 1, 1, 0, wxALIGN_CENTRE, 5 );

    m_directoriesListCtrl = new pda_listctrl( this, wxID_HANDHELDINSTALLCTRL_DIRECTORIES_LISTCTRL,
                                                wxDefaultPosition, wxDefaultSize,
                                                wxLC_REPORT|wxSUNKEN_BORDER,
                                                wxDefaultValidator, wxT( "directories_listctrl" ),
                                                _( "Directory destination" ),
                                                optionIS_DIRECTORIES_LISTCTRL );

    mainFlexGridSizer->Add( m_directoriesListCtrl, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxTOP|wxBOTTOM, 5 );

    wxFlexGridSizer *directoryFlexGridSizer = new wxFlexGridSizer( 1, 0, 0 );

    directoryFlexGridSizer->AddGrowableCol( 0 );

    m_directoriesAddButton = new wxButton( this, wxID_HANDHELDINSTALLCTRL_DIRECTORIES_ADD_BUTTON,
                                           _( "Add output directory..." ),
                                           wxDefaultPosition, wxDefaultSize, 0 );

    directoryFlexGridSizer->Add( m_directoriesAddButton, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    m_directoriesRemoveButton = new wxButton( this, wxID_HANDHELDINSTALLCTRL_DIRECTORIES_REMOVE_BUTTON,
                                              _( "Remove selected directories" ),
                                              wxDefaultPosition, wxDefaultSize, 0 );

    directoryFlexGridSizer->Add( m_directoriesRemoveButton, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    mainFlexGridSizer->Add( directoryFlexGridSizer, 0, wxGROW|wxLEFT|wxRIGHT|wxBOTTOM, 5 );

    SetAutoLayout( TRUE );
    SetSizer( mainFlexGridSizer );
    mainFlexGridSizer->Fit( this );
    mainFlexGridSizer->SetSizeHints( this );

    // TODO: Don't know whether this Layout() is needed
	Layout();
}
Exemplo n.º 3
0
GridFrame::GridFrame()
        : wxFrame( (wxFrame *)NULL, wxID_ANY, _T("wxWidgets grid class demo"),
                   wxDefaultPosition,
                   wxDefaultSize )
{
    wxMenu *fileMenu = new wxMenu;
    fileMenu->Append( ID_VTABLE, _T("&Virtual table test\tCtrl-V"));
    fileMenu->Append( ID_BUGS_TABLE, _T("&Bugs table test\tCtrl-B"));
    fileMenu->Append( ID_SMALL_GRID, _T("&Small Grid test\tCtrl-S"));
    fileMenu->AppendSeparator();
    fileMenu->Append( wxID_EXIT, _T("E&xit\tAlt-X") );

    wxMenu *viewMenu = new wxMenu;
    viewMenu->Append( ID_TOGGLEROWLABELS,  _T("&Row labels"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLECOLLABELS,  _T("&Col labels"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLEEDIT,  _T("&Editable"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLEROWSIZING, _T("Ro&w drag-resize"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLECOLSIZING, _T("C&ol drag-resize"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLECOLMOVING, _T("Col drag-&move"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLEGRIDSIZING, _T("&Grid drag-resize"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLEGRIDDRAGCELL, _T("&Grid drag-cell"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_TOGGLEGRIDLINES, _T("&Grid Lines"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_SET_HIGHLIGHT_WIDTH, _T("&Set Cell Highlight Width...") );
    viewMenu->Append( ID_SET_RO_HIGHLIGHT_WIDTH, _T("&Set Cell RO Highlight Width...") );
    viewMenu->Append( ID_AUTOSIZECOLS, _T("&Auto-size cols") );
    viewMenu->Append( ID_CELLOVERFLOW, _T("&Overflow cells"), wxEmptyString, wxITEM_CHECK );
    viewMenu->Append( ID_RESIZECELL, _T("&Resize cell (7,1)"), wxEmptyString, wxITEM_CHECK );

    wxMenu *rowLabelMenu = new wxMenu;

    viewMenu->Append( ID_ROWLABELALIGN, _T("R&ow label alignment"),
                      rowLabelMenu,
                      _T("Change alignment of row labels") );

    rowLabelMenu->Append( ID_ROWLABELHORIZALIGN, _T("&Horizontal") );
    rowLabelMenu->Append( ID_ROWLABELVERTALIGN, _T("&Vertical") );

    wxMenu *colLabelMenu = new wxMenu;

    viewMenu->Append( ID_COLLABELALIGN, _T("Col l&abel alignment"),
                      colLabelMenu,
                      _T("Change alignment of col labels") );

    colLabelMenu->Append( ID_COLLABELHORIZALIGN, _T("&Horizontal") );
    colLabelMenu->Append( ID_COLLABELVERTALIGN, _T("&Vertical") );

    wxMenu *colMenu = new wxMenu;
    colMenu->Append( ID_SETLABELCOLOUR, _T("Set &label colour...") );
    colMenu->Append( ID_SETLABELTEXTCOLOUR, _T("Set label &text colour...") );
    colMenu->Append( ID_SETLABEL_FONT, _T("Set label fo&nt...") );
    colMenu->Append( ID_GRIDLINECOLOUR, _T("&Grid line colour...") );
    colMenu->Append( ID_SET_CELL_FG_COLOUR, _T("Set cell &foreground colour...") );
    colMenu->Append( ID_SET_CELL_BG_COLOUR, _T("Set cell &background colour...") );

    wxMenu *editMenu = new wxMenu;
    editMenu->Append( ID_INSERTROW, _T("Insert &row") );
    editMenu->Append( ID_INSERTCOL, _T("Insert &column") );
    editMenu->Append( ID_DELETEROW, _T("Delete selected ro&ws") );
    editMenu->Append( ID_DELETECOL, _T("Delete selected co&ls") );
    editMenu->Append( ID_CLEARGRID, _T("Cl&ear grid cell contents") );

    wxMenu *selectMenu = new wxMenu;
    selectMenu->Append( ID_SELECT_UNSELECT, _T("Add new cells to the selection"),
                        _T("When off, old selection is deselected before ")
                        _T("selecting the new cells"), wxITEM_CHECK );
    selectMenu->Append( ID_SHOW_SELECTION,
                        _T("&Show current selection\tCtrl-Alt-S"));
    selectMenu->AppendSeparator();
    selectMenu->Append( ID_SELECT_ALL, _T("Select all"));
    selectMenu->Append( ID_SELECT_ROW, _T("Select row 2"));
    selectMenu->Append( ID_SELECT_COL, _T("Select col 2"));
    selectMenu->Append( ID_SELECT_CELL, _T("Select cell (3, 1)"));
    selectMenu->AppendSeparator();
    selectMenu->Append( ID_DESELECT_ALL, _T("Deselect all"));
    selectMenu->Append( ID_DESELECT_ROW, _T("Deselect row 2"));
    selectMenu->Append( ID_DESELECT_COL, _T("Deselect col 2"));
    selectMenu->Append( ID_DESELECT_CELL, _T("Deselect cell (3, 1)"));
    wxMenu *selectionMenu = new wxMenu;
    selectMenu->Append( ID_CHANGESEL, _T("Change &selection mode"),
                      selectionMenu,
                      _T("Change selection mode") );

    selectionMenu->Append( ID_SELCELLS, _T("Select &Cells") );
    selectionMenu->Append( ID_SELROWS, _T("Select &Rows") );
    selectionMenu->Append( ID_SELCOLS, _T("Select C&ols") );


    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append( wxID_ABOUT, _T("&About wxGrid demo") );

    wxMenuBar *menuBar = new wxMenuBar;
    menuBar->Append( fileMenu, _T("&File") );
    menuBar->Append( viewMenu, _T("&View") );
    menuBar->Append( colMenu,  _T("&Colours") );
    menuBar->Append( editMenu, _T("&Edit") );
    menuBar->Append( selectMenu, _T("&Select") );
    menuBar->Append( helpMenu, _T("&Help") );

    SetMenuBar( menuBar );

    m_addToSel = false;

    grid = new wxGrid( this,
                       wxID_ANY,
                       wxPoint( 0, 0 ),
                       wxSize( 400, 300 ) );

#if wxUSE_LOG
    int gridW = 600, gridH = 300;
    int logW = gridW, logH = 100;

    logWin = new wxTextCtrl( this,
                             wxID_ANY,
                             wxEmptyString,
                             wxPoint( 0, gridH + 20 ),
                             wxSize( logW, logH ),
                             wxTE_MULTILINE );

    logger = new wxLogTextCtrl( logWin );
    m_logOld = wxLog::SetActiveTarget( logger );
    wxLog::SetTimestamp( NULL );
#endif // wxUSE_LOG

    // this will create a grid and, by default, an associated grid
    // table for strings
    grid->CreateGrid( 0, 0 );
    grid->AppendRows(100);
    grid->AppendCols(100);

    int ir = grid->GetNumberRows();
    grid->DeleteRows(0, ir);
    grid->AppendRows(ir);

    grid->SetRowSize( 0, 60 );
    grid->SetCellValue( 0, 0, _T("Ctrl+Home\nwill go to\nthis cell") );

    grid->SetCellValue( 0, 1, _T("A long piece of text to demonstrate wrapping.") );
    grid->SetCellRenderer(0 , 1, new wxGridCellAutoWrapStringRenderer);
    grid->SetCellEditor( 0,  1 , new wxGridCellAutoWrapStringEditor);

    grid->SetCellValue( 0, 2, _T("Blah") );
    grid->SetCellValue( 0, 3, _T("Read only") );
    grid->SetReadOnly( 0, 3 );

    grid->SetCellValue( 0, 4, _T("Can veto edit this cell") );

    grid->SetCellValue( 0, 5, _T("Press\nCtrl+arrow\nto skip over\ncells") );

    grid->SetRowSize( 99, 60 );
    grid->SetCellValue( 99, 99, _T("Ctrl+End\nwill go to\nthis cell") );
    grid->SetCellValue( 1, 0, _T("This default cell will overflow into neighboring cells, but not if you turn overflow off."));

    grid->SetCellTextColour(1, 2, *wxRED);
    grid->SetCellBackgroundColour(1, 2, *wxGREEN);

    grid->SetCellValue( 1, 4, _T("I'm in the middle"));

    grid->SetCellValue(2, 2, _T("red"));

    grid->SetCellTextColour(2, 2, *wxRED);
    grid->SetCellValue(3, 3, _T("green on grey"));
    grid->SetCellTextColour(3, 3, *wxGREEN);
    grid->SetCellBackgroundColour(3, 3, *wxLIGHT_GREY);

    grid->SetCellValue(4, 4, _T("a weird looking cell"));
    grid->SetCellAlignment(4, 4, wxALIGN_CENTRE, wxALIGN_CENTRE);
    grid->SetCellRenderer(4, 4, new MyGridCellRenderer);

    grid->SetCellValue(3, 0, _T("0"));
    grid->SetCellRenderer(3, 0, new wxGridCellBoolRenderer);
    grid->SetCellEditor(3, 0, new wxGridCellBoolEditor);

    wxGridCellAttr *attr;
    attr = new wxGridCellAttr;
    attr->SetTextColour(*wxBLUE);
    grid->SetColAttr(5, attr);
    attr = new wxGridCellAttr;
    attr->SetBackgroundColour(*wxRED);
    grid->SetRowAttr(5, attr);

    grid->SetCellValue(2, 4, _T("a wider column"));
    grid->SetColSize(4, 120);
    grid->SetColMinimalWidth(4, 120);

    grid->SetCellTextColour(5, 8, *wxGREEN);
    grid->SetCellValue(5, 8, _T("Bg from row attr\nText col from cell attr"));
    grid->SetCellValue(5, 5, _T("Bg from row attr Text col from col attr and this text is so long that it covers over many many empty cells but is broken by one that isn't"));

    grid->SetColFormatFloat(6);
    grid->SetCellValue(0, 6, _T("3.1415"));
    grid->SetCellValue(1, 6, _T("1415"));
    grid->SetCellValue(2, 6, _T("12345.67890"));

    grid->SetColFormatFloat(7, 6, 2);
    grid->SetCellValue(0, 7, _T("3.1415"));
    grid->SetCellValue(1, 7, _T("1415"));
    grid->SetCellValue(2, 7, _T("12345.67890"));

    const wxString choices[] =
    {
        _T("Please select a choice"),
        _T("This takes two cells"),
        _T("Another choice"),
    };
    grid->SetCellEditor(4, 0, new wxGridCellChoiceEditor(WXSIZEOF(choices), choices));
    grid->SetCellSize(4, 0, 1, 2);
    grid->SetCellValue(4, 0, choices[0]);
    grid->SetCellOverflow(4, 0, false);

    grid->SetCellSize(7, 1, 3, 4);
    grid->SetCellAlignment(7, 1, wxALIGN_CENTRE, wxALIGN_CENTRE);
    grid->SetCellValue(7, 1, _T("Big box!"));

    wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
    topSizer->Add( grid,
                   1,
                   wxEXPAND );

#if wxUSE_LOG
    topSizer->Add( logWin,
                   0,
                   wxEXPAND );
#endif // wxUSE_LOG

    SetAutoLayout(true);
    SetSizer( topSizer );

    topSizer->Fit( this );

    Centre();
    SetDefaults();
}
Exemplo n.º 4
0
wxGenericDirDialog::wxGenericDirDialog(wxWindow* parent, const wxString& title,
                                       const wxString& defaultPath, long style,
                                       const wxPoint& pos, const wxSize& sz,
                                       const wxString& name):
                wxDialog(parent, ID_DIRCTRL, title, pos, sz, style, name)
{
    wxBusyCursor cursor;

    m_path = defaultPath;
    if (m_path == wxT("~"))
        wxGetHomeDir(&m_path);
    if (m_path == wxT("."))
        m_path = wxGetCwd();

    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );

    // smart phones does not support or do not waste space for wxButtons
#if defined(__SMARTPHONE__)

    wxMenu *dirMenu = new wxMenu;
    dirMenu->Append(ID_GO_HOME, _("Home"));

    if (style & wxDD_NEW_DIR_BUTTON)
    {
        dirMenu->Append(ID_NEW, _("New directory"));
    }

    dirMenu->AppendCheckItem(ID_SHOW_HIDDEN, _("Show hidden directories"));
    dirMenu->AppendSeparator();
    dirMenu->Append(wxID_CANCEL, _("Cancel"));

    SetRightMenu(wxID_ANY, _("Options"), dirMenu);

#else

    // 0) 'New' and 'Home' Buttons
    wxSizer* buttonsizer = new wxBoxSizer( wxHORIZONTAL );

    // VS: 'Home directory' concept is unknown to MS-DOS
#if !defined(__DOS__)
    wxBitmapButton* homeButton =
        new wxBitmapButton(this, ID_GO_HOME,
                           wxArtProvider::GetBitmap(wxART_GO_HOME, wxART_BUTTON));
    buttonsizer->Add( homeButton, 0, wxLEFT|wxRIGHT, 10 );
#endif

    // I'm not convinced we need a New button, and we tend to get annoying
    // accidental-editing with label editing enabled.
    if (style & wxDD_NEW_DIR_BUTTON)
    {
        wxBitmapButton* newButton =
            new wxBitmapButton(this, ID_NEW,
                            wxArtProvider::GetBitmap(wxART_NEW_DIR, wxART_BUTTON));
        buttonsizer->Add( newButton, 0, wxRIGHT, 10 );
#if wxUSE_TOOLTIPS
        newButton->SetToolTip(_("Create new directory"));
#endif
    }

#if wxUSE_TOOLTIPS
    homeButton->SetToolTip(_("Go to home directory"));
#endif

    topsizer->Add( buttonsizer, 0, wxTOP | wxALIGN_RIGHT, 10 );

#endif // __SMARTPHONE__/!__SMARTPHONE__

    // 1) dir ctrl
    m_dirCtrl = NULL; // this is necessary, event handler called from
                      // wxGenericDirCtrl would crash otherwise!
    long dirStyle = wxDIRCTRL_DIR_ONLY | wxDEFAULT_CONTROL_BORDER;

#ifdef __WXMSW__
    if (style & wxDD_NEW_DIR_BUTTON)
    {
        // Only under Windows do we need the wxTR_EDIT_LABEL tree control style
        // before we can call EditLabel (required for "New directory")
        dirStyle |= wxDIRCTRL_EDIT_LABELS;
    }
#endif

    m_dirCtrl = new wxGenericDirCtrl(this, ID_DIRCTRL,
                                     m_path, wxDefaultPosition,
                                     wxSize(300, 200),
                                     dirStyle);

    topsizer->Add( m_dirCtrl, 1, wxTOP|wxLEFT|wxRIGHT | wxEXPAND, wxLARGESMALL(10,0) );

#ifndef __SMARTPHONE__
    // Make the an option depending on a flag?
    wxCheckBox* check = new wxCheckBox( this, ID_SHOW_HIDDEN, _("Show hidden directories") );
    topsizer->Add( check, 0, wxLEFT|wxRIGHT|wxTOP | wxALIGN_RIGHT, 10 );
#endif // !__SMARTPHONE__

    // 2) text ctrl
    m_input = new wxTextCtrl( this, ID_TEXTCTRL, m_path, wxDefaultPosition );
    topsizer->Add( m_input, 0, wxTOP|wxLEFT|wxRIGHT | wxEXPAND, wxLARGESMALL(10,0) );

#ifndef __SMARTPHONE__

#if wxUSE_STATLINE
    // 3) Static line
    topsizer->Add( new wxStaticLine( this, wxID_ANY ), 0, wxEXPAND | wxLEFT|wxRIGHT|wxTOP, 10 );
#endif

    // 4) Buttons
    topsizer->Add( CreateButtonSizer( wxOK|wxCANCEL ), 0, wxEXPAND | wxALL, 10 );

#endif // !__SMARTPHONE__

    m_input->SetFocus();

    SetAutoLayout( true );
    SetSizer( topsizer );

#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__)
    topsizer->SetSizeHints( this );
    topsizer->Fit( this );

    Centre( wxBOTH );
#endif
}
Exemplo n.º 5
0
//------------------------------------------------------------------------------
MdiChildTsFrame::MdiChildTsFrame(wxMDIParentFrame *parent, bool isMainFrame,
      const wxString &plotName, const wxString& plotTitle,
      const wxString& xAxisTitle, const wxString& yAxisTitle,
      const wxPoint& pos, const wxSize& size, const long style) :
   GmatMdiChildFrame(parent, plotName, plotTitle, GmatTree::OUTPUT_XY_PLOT, -1,
                       pos, size, style | wxNO_FULL_REPAINT_ON_RESIZE)
{
   mXyPlot = (TsPlotCanvas *) NULL;
   mIsMainFrame = isMainFrame;
   mPlotTitle = plotTitle;
   mXAxisTitle = xAxisTitle;
   mYAxisTitle = yAxisTitle;

   for (int i=0; i<MAX_NUM_CURVE; i++)
      mHasFirstXSet[i] = false;
   
   #ifdef DEBUG_MDI_TS_FRAME
   MessageInterface::ShowMessage
      ("MdiChildTsFrame::MdiChildTsFrame()\n   X Axis Title = '%s'\n"
       "   Y Axis Title = '%s'\n   isMainFrame = %d\n", xAxisTitle.c_str(),
       yAxisTitle.c_str(), isMainFrame);
   #endif
   
   MdiTsPlot::mdiChildren.Append(this);
    
   // Give it an icon
   #ifdef __WXMSW__
      SetIcon(wxIcon(_T("chrt_icn")));
   #else
      SetIcon(wxIcon( mondrian_xpm ));
   #endif

   // Create XyPlotFrame
   int width, height;
   GetClientSize(&width, &height);
   
   #ifdef DEBUG_MDI_TS_FRAME
   MessageInterface::ShowMessage("   Creating TsPlotCanvas\n");
   #endif
   
   TsPlotCanvas *frame =
      new TsPlotXYCanvas(this, -1, wxPoint(0, 0), wxSize(width, height),
                       wxTAB_TRAVERSAL,//wxPLOT_DEFAULT,
                       plotTitle);
   
   frame->SetLabel(xAxisTitle.c_str(), TsPlotCanvas::X_LABEL);
   frame->SetLabel(yAxisTitle.c_str(), TsPlotCanvas::Y_LABEL);

   mXyPlot = frame;
   
   wxBoxSizer *topSizer = new wxBoxSizer( wxVERTICAL );
   
   topSizer->Add(mXyPlot, 1, wxALIGN_CENTER |wxEXPAND);
   
   SetAutoLayout( TRUE ); //loj: this is called implicitly by SetSizer()
   SetSizer( topSizer );
   
   // this should work for MDI frames as well as for normal ones
   SetSizeHints(100, 100);
   GmatAppData::Instance()->GetMainFrame()->theMdiChildren->Append(this);
   
   isActive = true;


   #ifdef DEBUG_MDI_TS_FRAME
   MessageInterface::ShowMessage("MdiChildTsFrame::MdiChildTsFrame() "
         "leaving\n");
   #endif
}
Exemplo n.º 6
0
QualityPrefs::QualityPrefs(wxWindow * parent):
PrefsPanel(parent)
{
   int i;
   int rate =
       gPrefs->Read("/SamplingRate/DefaultProjectSampleRate", 44100);
   int format =
      gPrefs->Read("/SamplingRate/DefaultProjectSampleFormat", floatSample);

   int pos = NUM_RATES;     // Fall back to other
   for (i = 0; i < NUM_RATES; i++)
      if (rate == rates[i]) {
         pos = i;
         break;
      }

   int fmtpos = NUM_FORMATS-1;
   for (i = 0; i < NUM_FORMATS; i++)
      if (format == formats[i]) {
         fmtpos = i;
         break;
      }

    topSizer = new wxBoxSizer( wxHORIZONTAL );

   {
      topSizer->Add(
         new wxStaticText(this, -1, _("Default Sample Rate:")), 0, 
         wxALIGN_LEFT|wxALL|wxALIGN_CENTER_VERTICAL, GENERIC_CONTROL_BORDER);

      mSampleRates = new wxChoice(this, ID_SAMPLE_RATE_CHOICE, wxDefaultPosition, wxDefaultSize,
                                 NUM_RATES+1, stringRates);
      mSampleRates->SetSelection(pos);

      topSizer->Add( mSampleRates, 0, wxALL|wxALIGN_CENTER_VERTICAL, TOP_LEVEL_BORDER );

      mOtherSampleRate = NULL;
      mOtherSampleRate = new wxTextCtrl(
         this, -1, wxString::Format("%i", rate),
         wxDefaultPosition, wxSize(50, -1), 0 );

      mOtherSampleRate->Enable(pos == NUM_RATES);

      topSizer->Add( mOtherSampleRate, 0, wxALL|wxALIGN_CENTER_VERTICAL, TOP_LEVEL_BORDER );
   }

    wxBoxSizer *top2Sizer = new wxBoxSizer( wxHORIZONTAL );

   {
      top2Sizer->Add(
         new wxStaticText(this, -1, _("Default Sample Format:")), 0, 
         wxALIGN_LEFT|wxALL|wxALIGN_CENTER_VERTICAL, GENERIC_CONTROL_BORDER);

      mSampleFormats = new wxChoice(this, -1, wxDefaultPosition, wxDefaultSize,
                                 NUM_FORMATS, stringFormats);
      mSampleFormats->SetSelection(fmtpos);

      top2Sizer->Add( mSampleFormats, 0, wxALL|wxALIGN_CENTER_VERTICAL, TOP_LEVEL_BORDER );
   }

   outSizer = new wxBoxSizer( wxVERTICAL );
   outSizer->Add(topSizer, 0, wxGROW|wxALL, TOP_LEVEL_BORDER);
   outSizer->Add(top2Sizer, 0, wxGROW|wxALL, TOP_LEVEL_BORDER);

   SetAutoLayout(true);
   outSizer->Fit(this);
   outSizer->SetSizeHints(this);
   SetSizer(outSizer);
}
Exemplo n.º 7
0
wxNumberEntryDialog::wxNumberEntryDialog(wxWindow *parent,
                                         const wxString& message,
                                         const wxString& prompt,
                                         const wxString& caption,
                                         long value,
                                         long min,
                                         long max,
                                         const wxPoint& pos)
                   : wxDialog(parent, wxID_ANY, caption,
                              pos, wxDefaultSize)
{
    m_value = value;
    m_max = max;
    m_min = min;

    wxBeginBusyCursor();

    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
#if wxUSE_STATTEXT
    // 1) text message
    topsizer->Add( CreateTextSizer( message ), 0, wxALL, 10 );
#endif        

    // 2) prompt and text ctrl
    wxBoxSizer *inputsizer = new wxBoxSizer( wxHORIZONTAL );

#if wxUSE_STATTEXT
    // prompt if any
    if (!prompt.IsEmpty())
        inputsizer->Add( new wxStaticText( this, wxID_ANY, prompt ), 0, wxCENTER | wxLEFT, 10 );
#endif
        
    // spin ctrl
    wxString valStr;
    valStr.Printf(wxT("%ld"), m_value);
    m_spinctrl = new wxSpinCtrl(this, wxID_ANY, valStr, wxDefaultPosition, wxSize( 140, wxDefaultCoord ) );
#if wxUSE_SPINCTRL
    m_spinctrl->SetRange((int)m_min, (int)m_max);
#endif
    inputsizer->Add( m_spinctrl, 1, wxCENTER | wxLEFT | wxRIGHT, 10 );
    // add both
    topsizer->Add( inputsizer, 1, wxEXPAND | wxLEFT|wxRIGHT, 5 );

    // smart phones does not support or do not waste space for wxButtons
#ifdef __SMARTPHONE__

    SetRightMenu(wxID_CANCEL, _("Cancel"));

#else // __SMARTPHONE__/!__SMARTPHONE__

#if wxUSE_STATLINE
    // 3) static line
    topsizer->Add( new wxStaticLine( this, wxID_ANY ), 0, wxEXPAND | wxLEFT|wxRIGHT|wxTOP, 10 );
#endif

    // 4) buttons
    topsizer->Add( CreateButtonSizer( wxOK|wxCANCEL ), 0, wxEXPAND | wxALL, 10 );

#endif // !__SMARTPHONE__

    SetSizer( topsizer );
    SetAutoLayout( true );

#if !defined(__SMARTPHONE__) && !defined(__POCKETPC__)
    topsizer->SetSizeHints( this );
    topsizer->Fit( this );

    Centre( wxBOTH );
#endif

    m_spinctrl->SetSelection(-1, -1);
    m_spinctrl->SetFocus();

    wxEndBusyCursor();
}
Exemplo n.º 8
0
   LadspaEffectDialog::LadspaEffectDialog(wxWindow * parent,
                                          const LADSPA_Descriptor *data,
                                          float *inputControls,
                                          int sampleRate)
      :wxDialog(parent, -1, data->Name,
                wxDefaultPosition, wxDefaultSize,
                wxDEFAULT_DIALOG_STYLE)
{
   numParams = 0;
   this->mData = data;
   this->inputControls = inputControls;
   this->sampleRate = sampleRate;
   inSlider = false;
   inText = false;
   targetSlider = NULL;

   sliders = new wxSlider*[mData->PortCount];
   fields = new wxTextCtrl*[mData->PortCount];
   labels = new wxStaticText*[mData->PortCount];
   ports = new unsigned long [mData->PortCount];

   unsigned long p;
   for(p=0; p<mData->PortCount; p++) {
      LADSPA_PortDescriptor d = mData->PortDescriptors[p];
      if (LADSPA_IS_PORT_CONTROL(d) &&
          LADSPA_IS_PORT_INPUT(d)) {
         ports[numParams] = p;
         numParams++;
      }
   }

   wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
   wxControl *item;

   item = new wxStaticText(this, 0,
                           wxString(_("Author: "))+mData->Maker);
   mainSizer->Add(item, 0, wxALL, 5);
   
   if (mData->Copyright &&
       mData->Copyright[0] && 
       mData->Copyright != wxString(_("None"))) {
      
      item = new wxStaticText(this, 0,
                              mData->Copyright);
      mainSizer->Add(item, 0, wxALL, 5);
   }

   wxSizer *paramSizer =
      new wxStaticBoxSizer(new wxStaticBox(this, -1,
                                           _("Ladspa Effect Settings")),
                           wxVERTICAL );

   wxFlexGridSizer *gridSizer =
      new wxFlexGridSizer(3, 0, 0);

   for (p = 0; p < numParams; p++) {

      item = new wxStaticText(this, 0, mData->PortNames[ports[p]]);
      gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);

      wxString fieldText;
      LADSPA_PortRangeHint hint = mData->PortRangeHints[ports[p]];
      if (LADSPA_IS_HINT_INTEGER(hint.HintDescriptor))
         fieldText.Printf("%d", (int)(inputControls[ports[p]] + 0.5));
      else
         fieldText.Printf("%f", inputControls[ports[p]]);
      fields[p] = new wxTextCtrl(this, LADSPA_TEXTCTRL_ID, fieldText);
      gridSizer->Add(fields[p], 0, wxALL, 5);

      sliders[p] =
          new wxSlider(this, LADSPA_SLIDER_ID,
                       0, 0, 1000,
                       wxDefaultPosition,
                       wxSize(200, -1));
      gridSizer->Add(sliders[p], 0, wxALL, 5);
   }

   // Set all of the sliders based on the value in the
   // text fields
   HandleText();
   
   paramSizer->Add(gridSizer, 1, wxALL, 5);
   mainSizer->Add(paramSizer, 1, wxALL, 5);

   wxBoxSizer *okSizer = new wxBoxSizer(wxHORIZONTAL);

   wxButton *button;

   button = new wxButton(this, wxID_OK, _("OK"));
   button->SetDefault();
   button->SetFocus();
   okSizer->Add(button, 0, wxALIGN_CENTRE | wxALL, 5);

   button = new wxButton(this, wxID_CANCEL, _("Cancel"));
   okSizer->Add(button, 0, wxALIGN_CENTRE | wxALL, 5);

   mainSizer->Add(okSizer, 0, wxALIGN_CENTRE | wxALL, 5);

   SetAutoLayout(TRUE);
   SetSizer(mainSizer);
   mainSizer->Fit(this);
   mainSizer->SetSizeHints(this);
}
Exemplo n.º 9
0
COptionsDialog::COptionsDialog(wxWindow * parent)
               :CResizableDlg( parent, "Edit options", SZ_SECT_WND_OPTIONS_DLG)//, wxDEFAULT_DIALOG_STYLE)
{
    wxBoxSizer   * topsizer;
    wxBoxSizer   * rowsizer;
    wxBoxSizer   * colsizer;
    wxBoxSizer   * layoutsizer;
    wxButton     * btnFont  ;
    wxButton     * btnColor ;
    wxButton     * btnOk    ;
    wxButton     * btnCancel;
    wxStaticText * stPwd;
    wxStaticText * stFaction;
    wxStaticText * stLayout;
    wxStaticText * stIcons;

    m_IsValid = false;

    m_pComboFonts               = new wxComboBox(this, ID_D1_CB_FONT );
    m_pComboColors              = new wxComboBox(this, ID_D1_CB_COLOR);
    m_pComboFactions            = new wxComboBox(this, ID_D1_CB_FACTION);

    m_pChkLoadOrd               = new wxCheckBox(this, ID_D1_CHK_LOAD_ORD         , wxT("Load Orders"));
    m_pChkLoadRep               = new wxCheckBox(this, ID_D1_CHK_LOAD_REP         , wxT("Load Report"));
    m_pChkUnixStyle             = new wxCheckBox(this, ID_D1_CHK_UNIX_FILES       , wxT("Unix file format"));
    m_pChkHatchUnvisited        = new wxCheckBox(this, ID_D1_CHK_HATCH_UNVISITED  , wxT("Hatch unvisited"));
    m_pChkRClickCenters         = new wxCheckBox(this, ID_D1_CHK_RIGHT_CLCK_CENTER, wxT("Right Click Centers"));
//    m_pChk3WinLayout            = new wxCheckBox(this, ID_D1_CHK_3WIN_LAYOUT      , wxT("3 windows layout"));
    m_pChkTeach                 = new wxCheckBox(this, ID_D1_CHK_TEACH_LVL        , wxT("Check TEACH level"));
    m_pChkReadPwd               = new wxCheckBox(this, ID_D1_CHK_READ_PWD         , wxT("Import Passwords"));
    m_pChkCheckProdReq          = new wxCheckBox(this, ID_D1_CHK_CHK_PROD_REQ     , wxT("Immediate production check"));
    m_pChkMoveMode              = new wxCheckBox(this, ID_D1_CHK_CHK_MOVE_MODE    , wxT("Check movement modes"));

    m_pTxtPassword              = new wxTextCtrl(this, ID_D1_TXT_PASSWORD);

    m_pRadio1Win                = new wxRadioButton(this, ID_D1_RADIO_1_WIN, wxT("1 window"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
    m_pRadio2Win                = new wxRadioButton(this, ID_D1_RADIO_2_WIN, wxT("2 windows"));
    m_pRadio3Win                = new wxRadioButton(this, ID_D1_RADIO_3_WIN, wxT("3 windows"));

    m_pRadioIconsSimple         = new wxRadioButton(this, ID_D1_RADIO_ICONS_SIMPLE  , wxT("Simple"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
    m_pRadioIconsAdvanced       = new wxRadioButton(this, ID_D1_RADIO_ICONS_ADVANCED, wxT("Advanced"));


    btnFont                     = new wxButton     (this, ID_D1_BTN_FONT     , wxT("Font") );
    btnColor                    = new wxButton     (this, ID_D1_BTN_COLOR    , wxT("Color") );
    btnOk                       = new wxButton     (this, wxID_OK            , wxT("Ok")    );
    btnCancel                   = new wxButton     (this, wxID_CANCEL        , wxT("Cancel") );

    stPwd                       = new wxStaticText (this, -1                 , wxT("Password"));
    stFaction                   = new wxStaticText (this, -1                 , wxT("Faction"));
    stLayout                    = new wxStaticText (this, -1                 , wxT("Layout"));
    stIcons                     = new wxStaticText (this, -1                 , wxT("Icons"));


#define space 2

    topsizer = new wxBoxSizer( wxVERTICAL );

    rowsizer    = new wxBoxSizer( wxHORIZONTAL );
        rowsizer->Add(m_pComboFonts   , 1, wxALIGN_CENTER | wxALL , space);
        rowsizer->Add(btnFont         , 0, wxALIGN_CENTER | wxALL , space);
    topsizer->Add(rowsizer        , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

    rowsizer    = new wxBoxSizer( wxHORIZONTAL );
        rowsizer->Add(m_pComboColors   , 1, wxALIGN_CENTER | wxALL , space);
        rowsizer->Add(btnColor         , 0, wxALIGN_CENTER | wxALL , space);
    topsizer->Add(rowsizer         , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

    rowsizer    = new wxBoxSizer( wxHORIZONTAL );

        rowsizer->Add(stFaction        , 0, wxALIGN_CENTER | wxALL , space);
        rowsizer->Add(m_pComboFactions , 1, wxALIGN_CENTER | wxALL , space);
        rowsizer->Add(stPwd            , 0, wxALIGN_CENTER | wxALL , space);
        rowsizer->Add(m_pTxtPassword   , 1, wxALIGN_CENTER | wxALL , space);
    topsizer->Add(rowsizer         , 0, wxALIGN_CENTER | wxALL | wxGROW, space );


    rowsizer    = new wxBoxSizer( wxHORIZONTAL );

        colsizer = new wxBoxSizer( wxVERTICAL );
            colsizer->Add(m_pChkLoadOrd            , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkLoadRep            , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkUnixStyle          , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkHatchUnvisited     , 0, wxALIGN_LEFT | wxALL, space);
        rowsizer->Add(colsizer         , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

        colsizer = new wxBoxSizer( wxVERTICAL );
            colsizer->Add(m_pChkRClickCenters      , 0, wxALIGN_LEFT | wxALL, space);
            //colsizer->Add(m_pChk3WinLayout         , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkTeach              , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkReadPwd            , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkCheckProdReq       , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(m_pChkMoveMode           , 0, wxALIGN_LEFT | wxALL, space);

        rowsizer->Add(colsizer         , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

        colsizer = new wxBoxSizer( wxVERTICAL );
            colsizer->Add(stLayout         , 0, wxALIGN_CENTER | wxALL | wxGROW, space );
            layoutsizer = new wxBoxSizer( wxVERTICAL );
                layoutsizer->Add(m_pRadio1Win       , 0, wxALIGN_LEFT | wxALL, space);
                layoutsizer->Add(m_pRadio2Win       , 0, wxALIGN_LEFT | wxALL, space);
                layoutsizer->Add(m_pRadio3Win       , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(layoutsizer      , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

            colsizer->Add(stIcons         , 0, wxALIGN_CENTER | wxTOP | wxGROW, space+space );
            layoutsizer = new wxBoxSizer( wxVERTICAL );
                layoutsizer->Add(m_pRadioIconsSimple       , 0, wxALIGN_LEFT | wxALL, space);
                layoutsizer->Add(m_pRadioIconsAdvanced     , 0, wxALIGN_LEFT | wxALL, space);
            colsizer->Add(layoutsizer      , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

        rowsizer->Add(colsizer         , 0, wxALIGN_CENTER | wxALL | wxGROW, space );

    topsizer->Add(rowsizer         , 1, wxALIGN_CENTER | wxALL | wxGROW, space );


    rowsizer = new wxBoxSizer( wxHORIZONTAL );
        rowsizer->Add(btnOk     , 0, wxALIGN_CENTER | wxALL, space);
        rowsizer->Add(btnCancel , 0, wxALIGN_CENTER | wxALL, space);
    topsizer->Add(rowsizer  , 0, wxALIGN_CENTER | wxALL, space );




    SetAutoLayout( TRUE );     // tell dialog to use sizer
    SetSizer( topsizer );      // actually set the sizer
    topsizer->Fit( this );            // set size to minimum size as calculated by the sizer
    topsizer->SetSizeHints( this );   // set size hints to honour mininum size}



    CResizableDlg::SetSize();
}
Exemplo n.º 10
0
EffectPanel::EffectPanel(wxScrolledWindow* scrollMe, Effect* effect, bool isConstant, TimelinePanel *parent, wxWindowID id)
              : wxPanel(parent, id, wxDefaultPosition, wxDefaultSize) {
  timelineParent = parent;
  this->isConstant = isConstant;
  this->effect = effect;
  this->scrollMe = scrollMe;
  depthChange = 0;
  PushEventHandler(new WheelCatcher(scrollMe));
  
  wxBoxSizer *vBox;
  wxStaticText *text;
  vBox = new wxBoxSizer(wxVERTICAL);
  SetSizer( vBox );
  SetAutoLayout( true );
  
  effectTypeChoice = new wxChoice(this, EFFECT_TYPE_CHOICE, wxDefaultPosition, wxDefaultSize, NUM_EFFECT_TYPES + 1, effectChoices);
  effectTypeChoice->PushEventHandler(new WheelCatcher(scrollMe));
  
  vBox->Add(effectTypeChoice, wxSizerFlags(0).Center().Expand());
  effectTypeChoice->Select(effect->type);
  
  sliderBox = new wxBoxSizer(wxHORIZONTAL);
  vBox->Add(sliderBox, wxSizerFlags(0).Expand().Border(wxBOTTOM, 2));
  
  if (isConstant) {
    if (isFinite()) {
      text = new wxStaticText( this, wxID_ANY, _T("Offset: "), wxDefaultPosition, wxDefaultSize);
    } else {
      text = new wxStaticText( this, wxID_ANY, _T("Range: "), wxDefaultPosition, wxDefaultSize);
    }
  } else {
    text = new wxStaticText( this, wxID_ANY, _T("Range: "), wxDefaultPosition, wxDefaultSize);
  }
  text->PushEventHandler(new WheelCatcher(scrollMe));
  sliderBox->Add(text, wxSizerFlags(0));
  
  depthSlider = new wxSlider( this, DEPTH_SLIDER, 0, 0, 254,
                              wxDefaultPosition, wxSize(125,wxDefaultCoord), wxSL_AUTOTICKS);
  sliderBox->Add(depthSlider, wxSizerFlags(1));
  depthSlider->PushEventHandler(new WheelCatcher(scrollMe));
  depthSlider->SetValue(effect->inst->getDepth(effect->type, effect->timeline));
  if (isConstant == false) {
    if (!isFinite()) {
      sliderBox->Show(false);
    }
    
    effectCanvas = new EffectCanvas(effect, this, EFFECT_CANVAS, wxDefaultPosition, wxSize(192,80));
    vBox->Add(effectCanvas, wxSizerFlags(0).Border(wxBOTTOM, 10));
    effectCanvas->PushEventHandler(new WheelCatcher(scrollMe));
  } else {
    effectCanvas = 0;
  }
  
  vBox->Layout();
  
  
  
  Monitor::addCallback( &effect->type, 
                        new Callback<char, EffectPanel>
                          (this, &EffectPanel::typeChangedCallback) );
  oldType = effect->type;
  Monitor::addCallback( &effect->inst->original->depths[effect->timeline][effect->type], 
                        new Callback<unsigned char, EffectPanel>
                          (this, &EffectPanel::depthChangedCallback) );
}
Exemplo n.º 11
0
/// Constructor
AlcFrame::AlcFrame (const wxString & title):
    wxFrame ((wxFrame *) NULL, -1, title)
{
  // Give it an icon
#ifdef __WXMSW__
  wxIcon icon(wxT("alc"));
#else
  wxIcon icon;
  icon.CopyFromBitmap(AlcPix::getPixmap(wxT("alc")));
#endif
  SetIcon (icon);

  // Status Bar
  CreateStatusBar ();
  SetStatusText (_("Welcome!"));

  // Unused dialog for now
  m_progressBar = NULL;

  // Frame Vertical sizer
  m_frameVBox = new wxBoxSizer (wxVERTICAL);

  // Add Main panel to frame (needed by win32 for padding sub panels)
  m_mainPanel = new wxPanel (this, -1);

  // Main Panel Vertical Sizer
  m_mainPanelVBox = new wxBoxSizer (wxVERTICAL);

  // Main Panel static line
  m_staticLine = new wxStaticLine (m_mainPanel, -1);
  m_mainPanelVBox->Add (m_staticLine, 0, wxALL | wxGROW);

  // Input Parameters
  m_inputSBox =
    new wxStaticBox (m_mainPanel, -1, _("Input parameters"));
  m_inputSBoxSizer = new wxStaticBoxSizer (m_inputSBox, wxHORIZONTAL);

  // Input Grid
  m_inputFlexSizer = new wxFlexGridSizer (6, 2, 5, 10);

  // Left col is growable
  m_inputFlexSizer->AddGrowableCol (0);

  // Static texts
  m_inputFileStaticText=new wxStaticText(m_mainPanel, -1,
                                         _("File to Hash"),
                                         wxDefaultPosition,wxDefaultSize,wxALIGN_CENTRE);

  m_inputAddStaticText=new wxStaticText(m_mainPanel, -1,
                                        _("Add Optional URLs for this file"),
                                        wxDefaultPosition,wxDefaultSize,wxALIGN_CENTRE);

  // Text ctrls
  m_inputFileTextCtrl = new wxTextCtrl (m_mainPanel,-1,wxEmptyString,
                                        wxDefaultPosition, wxSize(300,-1));
  m_inputFileTextCtrl->
  SetToolTip (_
              ("Enter here the file you want to compute the eD2k link"));

  m_inputAddTextCtrl = new wxTextCtrl (m_mainPanel,-1,wxEmptyString,
                                       wxDefaultPosition, wxSize(300,-1));
  m_inputAddTextCtrl->
  SetToolTip (_
              ("Enter here the URL you want to add to the eD2k link: Add / at the end to let aLinkCreator append the current file name"));

  // List box
  m_inputUrlListBox = new wxListBox(m_mainPanel, -1, wxDefaultPosition,
                                    wxDefaultSize, 0, NULL, wxLB_SINGLE | wxLB_NEEDED_SB | wxLB_HSCROLL);

  // Buttons
  m_inputFileBrowseButton =
    new wxButton (m_mainPanel, ID_BROWSE_BUTTON, wxString (_("Browse")));

  m_inputAddButton =
    new wxButton (m_mainPanel, ID_ADD_BUTTON, wxString (_("Add")));

  // Button bar
  m_buttonUrlVBox = new wxBoxSizer (wxVERTICAL);
  m_removeButton =
    new wxButton (m_mainPanel, ID_REMOVE_BUTTON, wxString (_("Remove")));
  m_clearButton =
    new wxButton (m_mainPanel, ID_CLEAR_BUTTON, wxString (_("Clear")));

  m_buttonUrlVBox->Add (m_removeButton, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, 5);
  m_buttonUrlVBox->Add (m_clearButton, 0, wxALIGN_CENTER | wxTOP | wxBOTTOM, 5);

  // Check button
  m_parthashesCheck =
    new wxCheckBox (m_mainPanel, ID_PARTHASHES_CHECK,
                    _
                    ("Create link with part-hashes"));

  m_parthashesCheck->SetValue(false);

  m_parthashesCheck->
  SetToolTip (_
              ("Help to spread new and rare files faster, at the cost of an increased link size"));

  // Add to sizers
  m_inputFlexSizer->Add (m_inputFileStaticText, 1, wxGROW | wxALIGN_BOTTOM | wxTOP, 10);
  m_inputFlexSizer->Add (1,1);

  m_inputFlexSizer->Add (m_inputFileTextCtrl, 1, wxGROW | wxALIGN_TOP , 0);
  m_inputFlexSizer->Add (m_inputFileBrowseButton, 0, wxGROW | wxALIGN_TOP , 0);

  m_inputFlexSizer->Add (m_inputAddStaticText, 1, wxGROW | wxALIGN_BOTTOM | wxTOP, 10);
  m_inputFlexSizer->Add (1,1);

  m_inputFlexSizer->Add (m_inputAddTextCtrl, 1, wxGROW | wxALIGN_TOP , 0);
  m_inputFlexSizer->Add (m_inputAddButton, 0, wxGROW | wxALIGN_TOP , 0);

  m_inputFlexSizer->Add (m_inputUrlListBox, 0, wxGROW | wxALIGN_CENTER , 0);
  m_inputFlexSizer->Add (m_buttonUrlVBox, 0, wxGROW | wxALIGN_CENTER , 0);

  m_inputFlexSizer->Add (m_parthashesCheck, 0, wxGROW | wxALIGN_CENTER | wxTOP, 10);
  m_inputFlexSizer->Add (1,1);

  m_inputSBoxSizer->Add (m_inputFlexSizer, 1, wxGROW | wxALIGN_CENTER | wxALL, 10);
  m_mainPanelVBox->Add (m_inputSBoxSizer, 0, wxGROW | wxALIGN_CENTER | wxALL, 10);

#ifdef WANT_MD4SUM
  // MD4 Hash Vertical Box Sizer
  m_md4HashSBox = new wxStaticBox (m_mainPanel, -1, _("MD4 File Hash"));
  m_md4HashSBoxSizer = new wxStaticBoxSizer (m_md4HashSBox, wxHORIZONTAL);

  // MD4 Hash results
  m_md4HashTextCtrl = new wxTextCtrl( m_mainPanel, -1, wxEmptyString, wxDefaultPosition,
                                      wxDefaultSize, wxTE_READONLY );

  m_md4HashSBoxSizer->Add (m_md4HashTextCtrl, 1, wxALL | wxALIGN_CENTER, 5);
  m_mainPanelVBox->Add( m_md4HashSBoxSizer, 0, wxALL | wxGROW, 10 );
#endif

  // Hash Vertical Box Sizer
  m_e2kHashSBox = new wxStaticBox (m_mainPanel, -1, _("eD2k File Hash"));
  m_e2kHashSBoxSizer = new wxStaticBoxSizer (m_e2kHashSBox, wxHORIZONTAL);

  // Hash results
  m_e2kHashTextCtrl = new wxTextCtrl( m_mainPanel, -1, wxEmptyString, wxDefaultPosition,
                                      wxDefaultSize, wxTE_READONLY );

  m_e2kHashSBoxSizer->Add (m_e2kHashTextCtrl, 1, wxALL | wxALIGN_CENTER, 5);
  m_mainPanelVBox->Add( m_e2kHashSBoxSizer, 0, wxALL | wxGROW, 10 );

  // Ed2k Vertical Box Sizer
  m_ed2kSBox = new wxStaticBox (m_mainPanel, -1, _("eD2k link"));
  m_ed2kSBoxSizer = new wxStaticBoxSizer (m_ed2kSBox, wxVERTICAL);

  // Ed2k results
  m_ed2kTextCtrl = new wxTextCtrl( m_mainPanel, -1, wxEmptyString, wxDefaultPosition,
                                   wxSize(-1,60), wxTE_MULTILINE|wxTE_READONLY|wxVSCROLL );

  m_ed2kSBoxSizer->Add (m_ed2kTextCtrl, 1, wxALL | wxGROW, 5);
  m_mainPanelVBox->Add( m_ed2kSBoxSizer, 1, wxALL | wxGROW, 10 );

  // Button bar
  m_buttonHBox = new wxBoxSizer (wxHORIZONTAL);
  m_startButton =
    new wxButton (m_mainPanel, ID_START_BUTTON, wxString (_("Start")));
  m_saveButton =
    new wxButton (m_mainPanel, ID_SAVEAS_BUTTON, wxString (_("Save")));
  m_copyButton =
    new wxButton (m_mainPanel, ID_COPY_BUTTON, wxString (_("Copy to clipboard")));
  m_closeButton =
    new wxButton (m_mainPanel, ID_EXIT_BUTTON, wxString (_("Exit")));

  m_buttonHBox->Add (m_copyButton, 0, wxALIGN_LEFT | wxALL, 5);
  m_buttonHBox->Add(1,1,1);
  m_buttonHBox->Add (m_startButton, 0, wxALIGN_RIGHT | wxALL, 5);
  m_buttonHBox->Add (m_saveButton, 0, wxALIGN_RIGHT | wxALL, 5);
  m_buttonHBox->Add (m_closeButton, 0, wxALIGN_RIGHT | wxALL, 5);


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

  // Toolbar Pixmaps
  m_toolBarBitmaps[0] = AlcPix::getPixmap(wxT("open"));
  m_toolBarBitmaps[1] = AlcPix::getPixmap(wxT("copy"));
  m_toolBarBitmaps[2] = AlcPix::getPixmap(wxT("saveas"));
  m_toolBarBitmaps[3] = AlcPix::getPixmap(wxT("about"));

  // Constructing toolbar
  m_toolbar =
    new wxToolBar (this, -1, wxDefaultPosition, wxDefaultSize,
                   wxTB_HORIZONTAL | wxTB_FLAT);

  m_toolbar->SetToolBitmapSize (wxSize (32, 32));
  m_toolbar->SetMargins (2, 2);

  m_toolbar->AddTool (ID_BAR_OPEN, _("Open"), m_toolBarBitmaps[0],
                      _("Open a file to compute its eD2k link"));

  m_toolbar->AddTool (ID_BAR_COPY, _("Copy"), m_toolBarBitmaps[1],
                      _("Copy computed eD2k link to clipboard"));

  m_toolbar->AddTool (ID_BAR_SAVEAS, _("Save as"), m_toolBarBitmaps[2],
                      _("Save computed eD2k link to file"));

  m_toolbar->AddSeparator ();

  m_toolbar->AddTool (ID_BAR_ABOUT, _("About"), m_toolBarBitmaps[3],
                      _("About aLinkCreator"));

  m_toolbar->Realize ();

  SetToolBar (m_toolbar);

  // Main panel Layout
  m_mainPanel->SetAutoLayout(true);
  m_mainPanel->SetSizerAndFit (m_mainPanelVBox);

  // Frame Layout
  m_frameVBox->Add (m_mainPanel, 1, wxALL | wxGROW, 0);
  SetAutoLayout (true);
  SetSizerAndFit (m_frameVBox);

  m_startButton->SetFocus();
}
Exemplo n.º 12
0
CHexExportDlg::CHexExportDlg(wxWindow *parent)
              :CResizableDlg( parent, wxT("Hex export options"), SZ_SECT_WND_EXP_HEXES, wxDEFAULT_DIALOG_STYLE)
{
    wxBoxSizer * topsizer;
    wxBoxSizer * sizer   ;
    wxBoxSizer * colsizer;
    wxStaticBox* box;
    CStr         ConfigKey;
    CStr         S;

    m_btnOk           = new wxButton     (this, wxID_OK    , wxT("Ok")    );
    m_btnCancel       = new wxButton     (this, wxID_CANCEL, wxT("Cancel") );
    m_btnBrowse       = new wxButton     (this, -1,          wxT("Browse") );
    m_tcFName         = new wxTextCtrl   (this, -1, wxT(""), wxDefaultPosition, wxSize(150, -1));



    m_rbHexNew        = new wxRadioButton(this, -1, wxT("New")     , wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
    m_rbHexCurrent    = new wxRadioButton(this, -1, wxT("Current") , wxDefaultPosition, wxDefaultSize, 0);
    m_rbHexSelected   = new wxRadioButton(this, -1, wxT("Selected"), wxDefaultPosition, wxDefaultSize, 0);
    m_rbHexAll        = new wxRadioButton(this, -1, wxT("All")     , wxDefaultPosition, wxDefaultSize, 0);

    m_rbFileOverwrite = new wxRadioButton(this, -1, wxT("Overwrite it") ,wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
    m_rbFileAppend    = new wxRadioButton(this, -1, wxT("Append to it") , wxDefaultPosition, wxDefaultSize, 0);

    m_chbInclStructs  = new wxCheckBox   (this, -1, wxT("Structures"));
    m_chbInclUnits    = new wxCheckBox   (this, -1, wxT("Units"));
    m_chbInclResources= new wxCheckBox   (this, -1, wxT("Resources"));
    m_chbInclTurnNoAcl= new wxCheckBox   (this, -1, wxT("Turn No a la Atlaclient"));


    topsizer = new wxBoxSizer( wxVERTICAL );

    sizer     = new wxBoxSizer( wxHORIZONTAL );
    sizer->Add(new wxStaticText(this, -1, wxT("Export to file")), 0, wxALIGN_LEFT | wxALL, 5);
    sizer->Add(m_tcFName  , 0, wxALIGN_CENTER | wxALL, 5);
    sizer->Add(m_btnBrowse, 0, wxALIGN_CENTER | wxALL, 5);
    topsizer->Add(sizer, 0, wxALIGN_CENTER | wxALL, 10);



    sizer    = new wxBoxSizer( wxHORIZONTAL );

    box      = new wxStaticBox(this, -1, wxT("If file exists:"));
    colsizer = new wxStaticBoxSizer(box, wxVERTICAL );
    colsizer->Add(m_rbFileOverwrite , 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_rbFileAppend    , 0, wxALIGN_LEFT | wxALL, 2);
    sizer->Add(colsizer, 0, wxALIGN_LEFT | wxALL, 5 );

    box      = new wxStaticBox(this, -1, wxT("Hex(es):"));
    colsizer = new wxStaticBoxSizer(box, wxVERTICAL );
    colsizer->Add(m_rbHexNew     , 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_rbHexCurrent , 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_rbHexSelected, 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_rbHexAll     , 0, wxALIGN_LEFT | wxALL, 2);
    sizer->Add(colsizer, 0, wxALIGN_LEFT | wxALL, 5 );

    box      = new wxStaticBox(this, -1, wxT("Include:"));
    colsizer = new wxStaticBoxSizer(box, wxVERTICAL );
    colsizer->Add(m_chbInclStructs  , 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_chbInclUnits    , 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_chbInclResources, 0, wxALIGN_LEFT | wxALL, 2);
    colsizer->Add(m_chbInclTurnNoAcl, 0, wxALIGN_LEFT | wxALL, 2);
    sizer->Add(colsizer, 0, wxALIGN_LEFT | wxALL, 5 );

    topsizer->Add(sizer, 0, wxALIGN_CENTER );



    sizer    = new wxBoxSizer( wxHORIZONTAL );
    sizer->Add(m_btnOk     , 0, wxALIGN_CENTER | wxALL, 5);
    sizer->Add(m_btnCancel , 0, wxALIGN_CENTER | wxALL, 5);
    topsizer->Add(sizer, 0, wxALIGN_CENTER | wxALL, 10 );




    SetAutoLayout( TRUE );     // tell dialog to use sizer
    SetSizer( topsizer );      // actually set the sizer
    topsizer->Fit( this );            // set size to minimum size as calculated by the sizer
    topsizer->SetSizeHints( this );   // set size hints to honour mininum size}

    m_tcFName->SetFocus();
    m_btnOk->SetDefault();


    CResizableDlg::SetSize();
}
Exemplo n.º 13
0
CExportMagesCSVDlg::CExportMagesCSVDlg(wxWindow * parent, const char * fname)
                   :CResizableDlg( parent, wxT("Export mages"), SZ_SECT_WND_EXP_MAGES_CSV)
{
    wxButton    * pBtn;
    wxStaticText* pStatic;
    const char  * p;
    wxString      FName = wxString::FromAscii(fname);

    wxBoxSizer  * topsizer = new wxBoxSizer( wxVERTICAL );
    wxBoxSizer  * horsizer;
    wxBoxSizer  * colsizer;
    wxBoxSizer  * layoutsizer;

    m_pSeparator = new wxComboBox(this, -1, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_DROPDOWN);
    m_pSeparator->Append(wxT(","));
    m_pSeparator->Append(wxT(";"));
    p = SkipSpaces(gpApp->GetConfig(m_sConfigSection.GetData(), SZ_KEY_SEPARATOR));
    if (p && *p)
        m_pSeparator->SetValue(wxString::FromAscii(p));
    else
        m_pSeparator->SetSelection(0);

    m_pOrientation = new wxComboBox(this, -1, wxT(""), wxDefaultPosition, wxDefaultSize, 0, NULL, wxCB_DROPDOWN );
    m_pOrientation->Append(wxT(SZ_VERTICAL));
    m_pOrientation->Append(wxT(SZ_HORIZONTAL));
    p = SkipSpaces(gpApp->GetConfig(m_sConfigSection.GetData(), SZ_KEY_ORIENTATION));
    if (p && *p)
        m_pOrientation->SetValue(wxString::FromAscii(p));
    else
        m_pOrientation->SetSelection(0);

    m_pRadio1 = new wxRadioButton(this, MCSV_RADIO_1, wxT("Decorated"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP);
    m_pRadio2 = new wxRadioButton(this, MCSV_RADIO_2, wxT("days"));
    m_pRadio3 = new wxRadioButton(this, MCSV_RADIO_3, wxT("level(days)"));

    m_nFormat = atol(gpApp->GetConfig(m_sConfigSection.GetData(), SZ_KEY_FORMAT));
    switch (m_nFormat)
    {
        case 0:   m_pRadio1->SetValue(TRUE); break;
        case 1:   m_pRadio2->SetValue(TRUE); break;
        case 2:   m_pRadio3->SetValue(TRUE); break;
    }

    m_pFileName = new wxTextCtrl(this, -1, FName);

    // -------------

    horsizer = new wxBoxSizer( wxHORIZONTAL );


    colsizer = new wxBoxSizer( wxVERTICAL );
        pStatic  = new wxStaticText(this, -1, wxT("Format :"), wxDefaultPosition, wxDefaultSize);
        colsizer->Add(pStatic, 0, wxALL, borderwidth );
        colsizer->Add(m_pRadio1, 0, wxALIGN_LEFT | wxALL, 1);
        colsizer->Add(m_pRadio2, 0, wxALIGN_LEFT | wxALL, 1);
        colsizer->Add(m_pRadio3, 0, wxALIGN_LEFT | wxALL, 1);
    horsizer->Add(colsizer, 0, wxALIGN_CENTER | wxALL | wxGROW, borderwidth*4 );


    colsizer = new wxBoxSizer( wxVERTICAL );
        layoutsizer = new wxBoxSizer( wxHORIZONTAL );
            pStatic  = new wxStaticText(this, -1, wxT("Separator :"), wxDefaultPosition, wxDefaultSize);
            layoutsizer->Add(pStatic     , 1, wxALIGN_RIGHT | wxALL, borderwidth );
            layoutsizer->Add(m_pSeparator, 2, wxALIGN_RIGHT | wxALL, borderwidth );
        colsizer->Add(layoutsizer, 0, wxALL, borderwidth );

        layoutsizer = new wxBoxSizer( wxHORIZONTAL );
            pStatic  = new wxStaticText(this, -1, wxT("Orientation :"), wxDefaultPosition, wxDefaultSize);
            layoutsizer->Add(pStatic       , 1, wxALIGN_RIGHT | wxALL, borderwidth );
            layoutsizer->Add(m_pOrientation, 2, wxALIGN_RIGHT | wxALL, borderwidth );
        colsizer->Add(layoutsizer, 0, wxALL, borderwidth );
    horsizer->Add(colsizer, 0, wxALIGN_CENTER | wxALL | wxGROW, borderwidth );

    topsizer->Add( horsizer, 0, wxALIGN_CENTER | wxALL | wxGROW );

    // -------------


    horsizer = new wxBoxSizer( wxHORIZONTAL );

    pStatic  = new wxStaticText(this, -1, wxT("Export to file :"), wxDefaultPosition, wxDefaultSize);
    horsizer->Add(pStatic, 0, wxALL, borderwidth );

    horsizer->Add(m_pFileName, 1, wxALL, borderwidth );

    pBtn = new wxButton  (this, wxID_SETUP , wxT("Browse") );
    horsizer->Add(pBtn, 0, wxALL, borderwidth );


    topsizer->Add( horsizer, 0, wxALIGN_CENTER | wxALL | wxGROW  );

    // -------------


    horsizer = new wxBoxSizer( wxHORIZONTAL );

    pBtn = new wxButton  (this, wxID_OK    , wxT("Ok") );
    horsizer->Add(pBtn, 0, wxALL, borderwidth );

    pBtn = new wxButton  (this, wxID_CANCEL    , wxT("Cancel") );
    horsizer->Add(pBtn, 0, wxALL, borderwidth );

    topsizer->Add( horsizer, 0, wxALIGN_CENTER | wxALL | wxGROW  );

    // -------------

    SetAutoLayout( TRUE );     // tell dialog to use sizer
    SetSizer( topsizer );      // actually set the sizer
    topsizer->Fit( this );            // set size to minimum size as calculated by the sizer
    topsizer->SetSizeHints( this );   // set size hints to honour mininum size}

    CResizableDlg::SetSize();
}
Exemplo n.º 14
0
CShowDescriptionListDlg::CShowDescriptionListDlg(wxWindow * parent, const char * title, CCollection * items)
                        :CResizableDlg( parent, wxString::FromUTF8(title), SZ_SECT_WND_DESCR_LIST)
{
    long i;
    CBaseObject * pObj;
    wxButton    * pBtnView;
    wxButton    * pBtnStoreSize;
    wxButton    * pBtnSave;


    m_pItems = items;
    m_pList = new wxListBox(this, -1, wxDefaultPosition, wxDefaultSize,
                               0, NULL, wxLB_SINGLE | wxLB_NEEDED_SB );

    for (i=0; i<items->Count(); i++)
    {
        pObj = (CBaseObject * )items->At(i);
        m_pList->Append(wxString::FromAscii(pObj->Name.GetData()), (void *)i);
    }


    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );

    pBtnView         = new wxButton  (this, wxID_OK    , wxT("View") );
    pBtnStoreSize    = new wxButton  (this, wxID_CANCEL, wxT("Done") );
    pBtnSave         = new wxButton  (this, wxID_SAVE  , wxT("Save as") );

    topsizer->Add(  m_pList  ,
                    1,                  // make vertically stretchable
                    wxEXPAND | wxALL,   // make horizontally stretchable //   and make border all around
                    4 );                // set border width to 10

    wxBoxSizer *button_sizer = new wxBoxSizer( wxHORIZONTAL );

    button_sizer->Add(  pBtnView,
                        0,           // make horizontally unstretchable
                        wxALL,       // make border all around (implicit top alignment)
                        10 );        // set border width to 10
    button_sizer->Add(  pBtnSave,
                        0,           // make horizontally unstretchable
                        wxALL,       // make border all around (implicit top alignment)
                        10 );        // set border width to 10
    button_sizer->Add(  pBtnStoreSize,
                        0,           // make horizontally unstretchable
                        wxALL,       // make border all around (implicit top alignment)
                        10 );        // set border width to 10

    topsizer->Add( button_sizer,
                   0,                // make vertically unstretchable
                   wxALIGN_CENTER ); // no border and centre horizontally

    SetAutoLayout( TRUE );     // tell dialog to use sizer
    SetSizer( topsizer );      // actually set the sizer
    topsizer->Fit( this );            // set size to minimum size as calculated by the sizer
    topsizer->SetSizeHints( this );   // set size hints to honour mininum size}

    m_pList->SetSelection(0);
    m_pList->SetFocus();
    pBtnView->SetDefault();

    CResizableDlg::SetSize();
}
Exemplo n.º 15
0
void wxFbPalette::Create()
{
	wxBoxSizer *top_sizer = new wxBoxSizer( wxVERTICAL );

#ifdef USE_FLATNOTEBOOK
	long nbStyle;
	wxConfigBase* config = wxConfigBase::Get();
	config->Read( wxT( "/palette/notebook_style" ), &nbStyle, wxFNB_NO_X_BUTTON | wxFNB_NO_NAV_BUTTONS | DRAG_OPTION | wxFNB_DROPDOWN_TABS_LIST  | wxFNB_VC8 | wxFNB_CUSTOM_DLG );

	m_notebook = new wxFlatNotebook( this, -1, wxDefaultPosition, wxDefaultSize, FNB_STYLE_OVERRIDES( nbStyle ) );
	m_notebook->SetCustomizeOptions( wxFNB_CUSTOM_TAB_LOOK | wxFNB_CUSTOM_ORIENTATION | wxFNB_CUSTOM_LOCAL_DRAG );
#else
	m_notebook = new wxAuiNotebook( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxAUI_NB_TOP | wxAUI_NB_SCROLL_BUTTONS );
	m_notebook->SetArtProvider( new AuiTabArt() );
#endif

	unsigned int pkg_count = AppData()->GetPackageCount();

	LogDebug( wxT( "[Palette] Pages %d" ), pkg_count );

#ifdef USE_FLATNOTEBOOK
	// Populate icon vector
	for ( unsigned int j = 0; j < pkg_count;j++ )
	{
		PObjectPackage pkg = AppData()->GetPackage( j );
		m_icons.Add( pkg->GetPackageIcon() );
	}

	// Add icons to notebook
	m_notebook->SetImageList( &m_icons );
#else
	wxSize minsize;
#endif

	for ( unsigned int i = 0; i < pkg_count;i++ )
	{
		PObjectPackage pkg = AppData()->GetPackage( i );
		wxString pkg_name = pkg->GetPackageName();

		wxPanel *panel = new wxPanel( m_notebook, -1 );
		//panel->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
		wxBoxSizer *sizer = new wxBoxSizer( wxHORIZONTAL );

#if wxVERSION_NUMBER >= 2900
		wxAuiToolBar *toolbar = new wxAuiToolBar( panel, -1, wxDefaultPosition, wxDefaultSize, wxAUI_TB_DEFAULT_STYLE | wxAUI_TB_OVERFLOW | wxNO_BORDER );
		toolbar->SetToolBitmapSize( wxSize( 22, 22 ) );
		PopulateToolbar( pkg, toolbar );
		m_tv.push_back( toolbar );

		sizer->Add( toolbar, 1, wxEXPAND, 0 );
#else
		wxPanel *tbPanel = new wxPanel( panel, -1 );
		//tbPanel->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
		wxBoxSizer *tbSizer = new wxBoxSizer( wxHORIZONTAL );

		wxPanel *sbPanel = new wxPanel( panel, -1 );
		//sbPanel->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
		wxBoxSizer *sbSizer = new wxBoxSizer( wxHORIZONTAL );

		wxToolBar *toolbar = new wxToolBar( tbPanel, -1, wxDefaultPosition, wxDefaultSize, wxTB_NODIVIDER | wxTB_FLAT );
		toolbar->SetToolBitmapSize( wxSize( 22, 22 ) );
		//toolbar->SetBackgroundColour( wxSystemSettings::GetColour( wxSYS_COLOUR_3DFACE ) );
		PopulateToolbar( pkg, toolbar );
		m_tv.push_back( toolbar );

		tbSizer->Add( toolbar, 1, wxEXPAND | wxALIGN_CENTER_VERTICAL );
		tbPanel->SetSizer( tbSizer );

		wxSpinButton *sb = new wxSpinButton( sbPanel, -1, wxDefaultPosition, wxDefaultSize, wxSP_HORIZONTAL );
		sb->SetRange( 0, ( int )pkg->GetObjectCount() - 1 );
		sb->SetValue( 0 );
		m_posVector.push_back( 0 );
		sbSizer->Add( sb, 0, wxEXPAND );//wxALL | wxALIGN_TOP, 0);
		sbPanel->SetSizer( sbSizer );

		sizer->Add( tbPanel, 1, wxEXPAND, 0 );
		sizer->Add( sbPanel, 0, wxEXPAND, 0 );
#endif

		panel->SetAutoLayout( true );
		panel->SetSizer( sizer );
		sizer->Fit( panel );
		sizer->SetSizeHints( panel );

#ifndef USE_FLATNOTEBOOK
		wxSize cursize = panel->GetSize();
		if( cursize.x > minsize.x ) minsize.x = cursize.x;
		if( cursize.y > minsize.y ) minsize.y = cursize.y + 30;
#endif

		m_notebook->AddPage( panel, pkg_name, false, i );
#ifndef USE_FLATNOTEBOOK
		m_notebook->SetPageBitmap( i, pkg->GetPackageIcon() );
#endif

	}
	//Title *title = new Title( this, wxT("Component Palette") );
	//top_sizer->Add(title,0,wxEXPAND,0);
#ifdef USE_FLATNOTEBOOK
	top_sizer->Add( m_notebook, 1, wxEXPAND, 0 );
	SetAutoLayout( true );
	SetSizer( top_sizer );
	top_sizer->Fit( this );
	top_sizer->SetSizeHints( this );
#else
	top_sizer->Add( m_notebook, 1, wxEXPAND, 0 );
	SetSizer( top_sizer );
	SetSize( minsize );
	SetMinSize( minsize );
	Layout();
	Fit();
#endif
}
CSoundCardRepeaterCallsignSet::CSoundCardRepeaterCallsignSet(wxWindow* parent, int id, const wxString& title, const wxString& callsign, const wxString& gateway, DSTAR_MODE mode, ACK_TYPE ack, bool restriction, bool rpt1Validation) :
wxPanel(parent, id),
m_title(title),
m_callsign(NULL),
m_gateway(NULL),
m_suffix(NULL),
m_mode(NULL),
m_ack(NULL),
m_restriction(NULL),
m_rpt1Validation(NULL)
{
	wxFlexGridSizer* sizer = new wxFlexGridSizer(3);

	wxStaticText* callsignLabel = new wxStaticText(this, -1, _("Callsign"));
	sizer->Add(callsignLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxString call = callsign;
	call.Append(wxT("        "));
	call.Truncate(LONG_CALLSIGN_LENGTH);

	m_callsign = new CCallsignTextCtrl(this, -1, call.Left(LONG_CALLSIGN_LENGTH - 1U).Trim(), wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_callsign->SetMaxLength(LONG_CALLSIGN_LENGTH - 1U);
	sizer->Add(m_callsign, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_suffix = new wxChoice(this, -1, wxDefaultPosition, wxSize(SUFFIX_WIDTH, -1));
#if defined(__WXDEBUG__)
	m_suffix->Append(wxT(" "));
#endif
	m_suffix->Append(wxT("A"));
	m_suffix->Append(wxT("B"));
	m_suffix->Append(wxT("C"));
	m_suffix->Append(wxT("D"));
	m_suffix->Append(wxT("E"));
	sizer->Add(m_suffix, 0, wxALL, BORDER_SIZE);

	wxString suffix = callsign.Right(1U);
	bool res = m_suffix->SetStringSelection(suffix);
	if (!res)
		m_suffix->SetStringSelection(wxT("B"));

	wxStaticText* gatewayLabel = new wxStaticText(this, -1, _("Gateway"));
	sizer->Add(gatewayLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	call = gateway;
	call.Append(wxT("        "));
	call.Truncate(LONG_CALLSIGN_LENGTH);

	m_gateway = new CCallsignTextCtrl(this, -1, call.Left(LONG_CALLSIGN_LENGTH - 1U).Trim(), wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_gateway->SetMaxLength(LONG_CALLSIGN_LENGTH - 1U);
	sizer->Add(m_gateway, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* gLabel = new wxStaticText(this, -1, wxT("G"));
	sizer->Add(gLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* modeLabel = new wxStaticText(this, -1, _("Mode"));
	sizer->Add(modeLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_mode = new wxChoice(this, CHOICE_MODE, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_mode->Append(_("Duplex"));
	m_mode->Append(_("Simplex"));
	m_mode->Append(_("Gateway"));
	m_mode->Append(_("TX Only"));
	m_mode->Append(_("RX Only"));
	m_mode->Append(_("TX and RX"));
	sizer->Add(m_mode, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_mode->SetSelection(int(mode));

	wxStaticText* dummy1 = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy1, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* ackLabel = new wxStaticText(this, -1, _("Ack"));
	sizer->Add(ackLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_ack = new wxChoice(this, -1, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_ack->Append(_("Off"));
	m_ack->Append(wxT("BER"));
	m_ack->Append(_("Status"));
	sizer->Add(m_ack, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_ack->SetSelection(int(ack));

	wxStaticText* dummy2 = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy2, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* restrictionLabel = new wxStaticText(this, -1, _("Restrict"));
	sizer->Add(restrictionLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_restriction = new wxChoice(this, -1, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_restriction->Append(_("Off"));
	m_restriction->Append(_("On"));
	sizer->Add(m_restriction, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_restriction->SetSelection(restriction ? 1 : 0);

	wxStaticText* dummy3 = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy3, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* rpt1ValidationLabel = new wxStaticText(this, -1, _("RPT1 Validation"));
	sizer->Add(rpt1ValidationLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_rpt1Validation = new wxChoice(this, -1, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_rpt1Validation->Append(_("Off"));
	m_rpt1Validation->Append(_("On"));
	sizer->Add(m_rpt1Validation, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_rpt1Validation->SetSelection(rpt1Validation ? 1 : 0);

	SetAutoLayout(true);

	sizer->Fit(this);
	sizer->SetSizeHints(this);

	SetSizer(sizer);
}
Exemplo n.º 17
0
void wxGenericMessageDialog::DoCreateMsgdialog()
{
    wxDialog::Create(m_parent, wxID_ANY, m_caption, m_pos, wxDefaultSize, wxDEFAULT_DIALOG_STYLE);

    bool is_pda = (wxSystemSettings::GetScreenType() <= wxSYS_SCREEN_PDA);

    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );

    wxBoxSizer *icon_text = new wxBoxSizer( wxHORIZONTAL );

#if wxUSE_STATBMP
    // 1) icon
    if (m_dialogStyle & wxICON_MASK)
    {
        wxStaticBitmap *icon = new wxStaticBitmap
                                   (
                                    this,
                                    wxID_ANY,
                                    wxArtProvider::GetMessageBoxIcon(m_dialogStyle)
                                   );
        if (is_pda)
            topsizer->Add( icon, 0, wxTOP|wxLEFT|wxRIGHT | wxALIGN_LEFT, 10 );
        else
            icon_text->Add(icon, wxSizerFlags().Top().Border(wxRIGHT, 20));
    }
#endif // wxUSE_STATBMP

#if wxUSE_STATTEXT
    // 2) text

    wxBoxSizer * const textsizer = new wxBoxSizer(wxVERTICAL);

    // We want to show the main message in a different font to make it stand
    // out if the extended message is used as well. This looks better and is
    // more consistent with the native dialogs under MSW and GTK.
    wxString lowerMessage;
    if ( !m_extendedMessage.empty() )
    {
        wxTitleTextWrapper titleWrapper(this);
        textsizer->Add(CreateTextSizer(GetMessage(), titleWrapper),
                       wxSizerFlags().Border(wxBOTTOM, 20));

        lowerMessage = GetExtendedMessage();
    }
    else // no extended message
    {
        lowerMessage = GetMessage();
    }

    textsizer->Add(CreateTextSizer(lowerMessage));

    icon_text->Add(textsizer, 0, wxALIGN_CENTER, 10);
    topsizer->Add( icon_text, 1, wxLEFT|wxRIGHT|wxTOP, 10 );
#endif // wxUSE_STATTEXT

    // 3) optional checkbox and detailed text
    AddMessageDialogCheckBox( topsizer );
    AddMessageDialogDetails( topsizer );

    // 4) buttons
    wxSizer *sizerBtn = CreateMsgDlgButtonSizer();
    if ( sizerBtn )
        topsizer->Add(sizerBtn, 0, wxEXPAND | wxALL, 10 );

    SetAutoLayout( true );
    SetSizer( topsizer );

    topsizer->SetSizeHints( this );
    topsizer->Fit( this );
    wxSize size( GetSize() );
    if (size.x < size.y*3/2)
    {
        size.x = size.y*3/2;
        SetSize( size );
    }

    Centre( wxBOTH | wxCENTER_FRAME);
}
handheld_dest_dialog::handheld_dest_dialog( wxWindow* parent,
        const wxString& title,
        wxArrayString& user_name_array
                                          )
    : wxDialog( parent, -1, title, wxDefaultPosition, wxDefaultSize,
                wxDEFAULT_DIALOG_STYLE | wxRESIZE_BORDER )
{

    wxFlexGridSizer *root_flexgridsizer = new wxFlexGridSizer( 1, 0, 0 );
    root_flexgridsizer->AddGrowableCol( 0 );
    root_flexgridsizer->AddGrowableRow( 1 );

    wxStaticBox *user_name_staticbox = new wxStaticBox( this, -1, _( "Handheld" ) );
    wxStaticBoxSizer *user_name_staticboxsizer = new wxStaticBoxSizer( user_name_staticbox, wxVERTICAL );

    wxFlexGridSizer *user_name_flexgridsizer = new wxFlexGridSizer( 2, 0, 0 );
    user_name_flexgridsizer->AddGrowableCol( 1 );
    user_name_flexgridsizer->AddGrowableRow( 0 );

    wxStaticText *user_name_statictext = new wxStaticText( this, -1, _( "Handheld user:"******"This is a USB-connected device" ) );
    user_name_staticboxsizer->Add( m_is_usb_pause_checkbox, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    root_flexgridsizer->Add( user_name_staticboxsizer, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    wxStaticBox *location_on_handheld_staticbox = new wxStaticBox( this, -1, _( "Location on handheld" ) );
    wxStaticBoxSizer *location_on_handheld_staticboxsizer = new wxStaticBoxSizer( location_on_handheld_staticbox, wxVERTICAL );

    wxStaticText *install_to_statictext = new wxStaticText( this, -1, _( "On the handheld, send the files to:" ), wxDefaultPosition, wxDefaultSize, 0 );
    location_on_handheld_staticboxsizer->Add( install_to_statictext, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    wxFlexGridSizer *ram_or_card_flexgridsizer = new wxFlexGridSizer( 2, 0, 5 );
    ram_or_card_flexgridsizer->AddGrowableCol( 2 );
    ram_or_card_flexgridsizer->AddGrowableRow( 0 );
    ram_or_card_flexgridsizer->AddGrowableRow( 1 );
    ram_or_card_flexgridsizer->AddGrowableRow( 2 );

    ram_or_card_flexgridsizer->Add( 20, 20, 0, wxALIGN_CENTRE|wxALL, 0 );

    m_install_to_ram_radiobutton = new wxRadioButton( this, ID_INSTALL_TO_RAM_RADIOBUTTON, _( "The handheld's RAM memory" ), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
    ram_or_card_flexgridsizer->Add( m_install_to_ram_radiobutton, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxBOTTOM, 5 );

    ram_or_card_flexgridsizer->Add( 20, 20, 0, wxALIGN_CENTRE|wxALL, 0 );

    m_install_to_sd_card_radiobutton = new wxRadioButton( this, ID_INSTALL_TO_SD_CARD_RADIOBUTTON, _( "The removable SD/MMC card" ), wxDefaultPosition, wxDefaultSize, 0 );
    ram_or_card_flexgridsizer->Add( m_install_to_sd_card_radiobutton, 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxBOTTOM, 5 );

    ram_or_card_flexgridsizer->Add( 20, 20, 0, wxALIGN_CENTRE|wxALL, 0 );

    m_install_to_memory_stick_radiobutton = new wxRadioButton( this, ID_INSTALL_TO_MEMORY_STICK_RADIOBUTTON, _( "The removable Memory Stick"), wxDefaultPosition, wxDefaultSize, 0 );
    ram_or_card_flexgridsizer->Add( m_install_to_memory_stick_radiobutton , 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxBOTTOM, 5 );

    ram_or_card_flexgridsizer->Add( 20, 20, 0, wxALIGN_CENTRE|wxALL, 0 );

    m_install_to_compact_flash_radiobutton = new wxRadioButton( this, ID_INSTALL_TO_COMPACT_FLASH_RADIOBUTTON, _( "The removable CompactFlash card"), wxDefaultPosition, wxDefaultSize, 0 );
    ram_or_card_flexgridsizer->Add( m_install_to_compact_flash_radiobutton , 0, wxALIGN_CENTER_VERTICAL|wxRIGHT|wxBOTTOM, 5 );

    location_on_handheld_staticboxsizer->Add( ram_or_card_flexgridsizer, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxRIGHT, 5 );

    wxFlexGridSizer *card_directory_flexgridsizer = new wxFlexGridSizer( 3, 0, 5 );
    card_directory_flexgridsizer->AddGrowableCol( 1 );
    card_directory_flexgridsizer->AddGrowableRow( 0 );

    card_directory_flexgridsizer->Add( 30, 10, 0, wxALIGN_CENTRE|wxALL, 5 );

    m_default_card_directory_radiobutton = new wxRadioButton( this, ID_DEFAULT_CARD_DIRECTORY_RADIOBUTTON, _("Send to the default directory on the card"), wxDefaultPosition, wxDefaultSize, wxRB_GROUP );
    card_directory_flexgridsizer->Add( m_default_card_directory_radiobutton, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxBOTTOM, 5 );

    card_directory_flexgridsizer->Add( 1, 1, 0, wxALIGN_CENTRE|wxALL, 5 );
    card_directory_flexgridsizer->Add( 30, 10, 0, wxALIGN_CENTRE|wxALL, 5 );

    m_specified_card_directory_radiobutton = new wxRadioButton( this, ID_SPECIFIED_CARD_DIRECTORY_RADIOBUTTON, _("Send to this specified directory on the card:"), wxDefaultPosition, wxDefaultSize, 0 );
    card_directory_flexgridsizer->Add( m_specified_card_directory_radiobutton, 0, wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT, 5 );

    m_directory_on_card_textctrl = new wxTextCtrl( this, ID_DIRECTORY_ON_CARD_TEXTCTRL, wxT( "" ), wxDefaultPosition, wxSize(140,-1), 0 );
    card_directory_flexgridsizer->Add( m_directory_on_card_textctrl, 0, wxALIGN_CENTER_VERTICAL, 5 );

    location_on_handheld_staticboxsizer->Add( card_directory_flexgridsizer, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    root_flexgridsizer->Add( location_on_handheld_staticboxsizer, 0, wxGROW|wxALIGN_CENTER_VERTICAL|wxLEFT|wxRIGHT|wxBOTTOM, 5 );

    wxBoxSizer *bottom_button_boxsizer = new wxBoxSizer( wxHORIZONTAL );

    wxButton *ok_button = new wxButton( this, wxID_OK, _( "OK" ) );
    bottom_button_boxsizer->Add( ok_button, 0, wxALIGN_CENTRE|wxALL, 5 );

    wxButton *cancel_button= new wxButton( this, wxID_CANCEL, _( "Cancel" ) );
    bottom_button_boxsizer->Add( cancel_button, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL|wxALL, 5 );

    wxButton *help_button = new wxButton( this, wxID_HELP_CONTEXT, _( "Help" ) );
    bottom_button_boxsizer->Add( help_button, 0, wxALIGN_CENTRE|wxALL, 5 );

    root_flexgridsizer->Add( bottom_button_boxsizer, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL, 0 );

    // Do the standard sizer fitting stuff.
    SetAutoLayout( TRUE );
    SetSizer( root_flexgridsizer );
    root_flexgridsizer->SetSizeHints( this );
    root_flexgridsizer->Fit( this );

    // Center the html tip dialog on its parent.
    Centre( wxBOTH | wxCENTER_FRAME );

    // Finally, load the array of possible user names into the choice
    for ( size_t n = 0; n < user_name_array.GetCount(); n++ )
    {
        m_user_name_choice->Append( user_name_array.Item( n ) );
    }
    // And set the selection to the first one
    if ( 0 < user_name_array.GetCount() )
    {
        m_user_name_choice->SetSelection( 0 );
    }

    // A radiobutton should alway have one value selected. Set RAM radiobutton to TRUE.
    m_install_to_ram_radiobutton->SetValue( TRUE );

    // Make the directory controls invisible, since not using yet.
    // Disabled doesn't really matter
    m_default_card_directory_radiobutton->Show( FALSE );
    m_specified_card_directory_radiobutton->Show( FALSE );
    m_directory_on_card_textctrl->Show( FALSE );
}
CDStarRepeaterConfigDVRPTR1Set::CDStarRepeaterConfigDVRPTR1Set(wxWindow* parent, int id, const wxString& port, bool rxInvert, bool txInvert, bool channel, unsigned int modLevel, unsigned int txDelay) :
wxDialog(parent, id, wxString(_("DV-RPTR V1 Settings"))),
m_port(NULL),
m_txInvert(NULL),
m_rxInvert(NULL),
m_channel(NULL),
m_modLevel(NULL),
m_txDelay(NULL)
{
	wxBoxSizer* topSizer = new wxBoxSizer(wxVERTICAL);

	wxFlexGridSizer* sizer = new wxFlexGridSizer(2);

	wxStaticText* portLabel = new wxStaticText(this, -1, _("Port"));
	sizer->Add(portLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_port = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));
	sizer->Add(m_port, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxArrayString ports = CSerialPortSelector::getDevices();
	for (unsigned int i = 0U; i < ports.GetCount(); i++)
		m_port->Append(ports.Item(i));

	bool found = m_port->SetStringSelection(port);
	if (!found)
		m_port->SetSelection(0);

	wxStaticText* txInvertLabel = new wxStaticText(this, -1, _("TX Inversion"));
	sizer->Add(txInvertLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_txInvert = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));
	m_txInvert->Append(_("Off"));
	m_txInvert->Append(_("On"));
	sizer->Add(m_txInvert, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_txInvert->SetSelection(txInvert ? 1 : 0);

	wxStaticText* rxInvertLabel = new wxStaticText(this, -1, _("RX Inversion"));
	sizer->Add(rxInvertLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_rxInvert = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));
	m_rxInvert->Append(_("Off"));
	m_rxInvert->Append(_("On"));
	sizer->Add(m_rxInvert, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_rxInvert->SetSelection(rxInvert ? 1 : 0);

	wxStaticText* channelLabel = new wxStaticText(this, -1, _("Channel"));
	sizer->Add(channelLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_channel = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));
	m_channel->Append(_("A / FSK Pin"));
	m_channel->Append(_("B / AFSK Pin"));
	sizer->Add(m_channel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_channel->SetSelection(channel ? 1 : 0);

	wxStaticText* modLevelLabel = new wxStaticText(this, -1, _("TX Level (%)"));
	sizer->Add(modLevelLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_modLevel = new wxSlider(this, -1, modLevel, 0, 100, wxDefaultPosition, wxSize(CONTROL_WIDTH2, -1), wxSL_HORIZONTAL | wxSL_LABELS);
	sizer->Add(m_modLevel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* txDelayLabel = new wxStaticText(this, -1, _("TX Delay (ms)"));
	sizer->Add(txDelayLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_txDelay = new wxSlider(this, -1, txDelay, 0, 500, wxDefaultPosition, wxSize(CONTROL_WIDTH2, -1), wxSL_HORIZONTAL | wxSL_LABELS);
	sizer->Add(m_txDelay, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	topSizer->Add(sizer);

	topSizer->Add(CreateButtonSizer(wxOK | wxCANCEL), 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	SetAutoLayout(true);

	topSizer->Fit(this);
	topSizer->SetSizeHints(this);

	SetSizer(topSizer);
}
Exemplo n.º 20
0
LadspaEffectDialog::LadspaEffectDialog(LadspaEffect *eff,
                                       wxWindow * parent,
                                       const LADSPA_Descriptor *data,
                                       float *inputControls,
                                       int sampleRate)
   :wxDialog(parent, -1, data->Name,
             wxDefaultPosition, wxDefaultSize,
             wxDEFAULT_DIALOG_STYLE),
    effect(eff)
{
   numParams = 0;
   this->mData = data;
   this->inputControls = inputControls;
   this->sampleRate = sampleRate;
	#ifdef __WXMSW__
		// On Windows, for some reason, wxWindows calls OnTextCtrl during creation
		// of the text control, and LadspaEffectDialog::OnTextCtrl calls HandleText, 
		// which assumes all the fields have been initialized. 
		// This can give us a bad pointer crash, so manipulate inSlider to 
		// no-op HandleText during creation.
		inSlider = true;
	#else
		inSlider = false;
	#endif
   inText = false;
   targetSlider = NULL;

   sliders = new wxSlider*[mData->PortCount];
   fields = new wxTextCtrl*[mData->PortCount];
	labels = new wxStaticText*[mData->PortCount];
   ports = new unsigned long [mData->PortCount];

   unsigned long p;
   for(p=0; p<mData->PortCount; p++) {
      LADSPA_PortDescriptor d = mData->PortDescriptors[p];
      if (LADSPA_IS_PORT_CONTROL(d) &&
          LADSPA_IS_PORT_INPUT(d)) {
         ports[numParams] = p;
         numParams++;
      }
   }

   wxBoxSizer *mainSizer = new wxBoxSizer(wxVERTICAL);
   wxControl *item;

   if (mData->Maker &&
       mData->Maker[0] && 
       mData->Maker != wxString(_("None"))) {       
      item = new wxStaticText(this, 0,
                              wxString(_("Author: "))+mData->Maker);
      mainSizer->Add(item, 0, wxALL, 5);
   }
   
   if (mData->Copyright &&
       mData->Copyright[0] && 
       mData->Copyright != wxString(_("None"))) {
      
      item = new wxStaticText(this, 0,
                              mData->Copyright);
      mainSizer->Add(item, 0, wxALL, 5);
   }

   wxSizer *paramSizer =
      new wxStaticBoxSizer(new wxStaticBox(this, -1,
                                           _("Effect Settings")),
                           wxVERTICAL );

   wxFlexGridSizer *gridSizer =
      new wxFlexGridSizer(3, 0, 0);

   for (p = 0; p < numParams; p++) {

      item = new wxStaticText(this, 0, mData->PortNames[ports[p]]);
      gridSizer->Add(item, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);

      wxString fieldText;
      LADSPA_PortRangeHint hint = mData->PortRangeHints[ports[p]];
      if (LADSPA_IS_HINT_INTEGER(hint.HintDescriptor))
         fieldText.Printf("%d", (int)(inputControls[ports[p]] + 0.5));
      else
         fieldText.Printf("%f", inputControls[ports[p]]);
      fields[p] = new wxTextCtrl(this, LADSPA_TEXTCTRL_ID, fieldText);
      gridSizer->Add(fields[p], 0, wxALL, 5);

      sliders[p] =
          new wxSlider(this, LADSPA_SLIDER_ID,
                       0, 0, 1000,
                       wxDefaultPosition,
                       wxSize(200, -1));
      gridSizer->Add(sliders[p], 0, wxALL, 5);
   }

   // Set all of the sliders based on the value in the
   // text fields
	inSlider = false; // Now we're ready for HandleText to actually do something.
   HandleText();
   
   paramSizer->Add(gridSizer, 1, wxALL, 5);
   mainSizer->Add(paramSizer, 1, wxALL, 5);

   wxBoxSizer *okSizer = new wxBoxSizer(wxHORIZONTAL);

   wxButton *button;

   button = new wxButton(this, LADSPA_PREVIEW_ID, effect->GetPreviewName());
   okSizer->Add(button, 0, wxALIGN_CENTRE | wxALL, 5);

   button = new wxButton(this, wxID_CANCEL, _("Cancel"));
   okSizer->Add(button, 0, wxALIGN_CENTRE | wxALL, 5);

   button = new wxButton(this, wxID_OK, _("OK"));
   button->SetDefault();
   button->SetFocus();
   okSizer->Add(button, 0, wxALIGN_CENTRE | wxALL, 5);

   mainSizer->Add(okSizer, 0, wxALIGN_CENTRE | wxALL, 5);

   SetAutoLayout(TRUE);
   SetSizer(mainSizer);
   mainSizer->Fit(this);
   mainSizer->SetSizeHints(this);
}
Exemplo n.º 21
0
LevellerDialog::LevellerDialog(wxWindow *parent, wxWindowID id,
                             const wxString &title ) :
   wxDialog( parent, id, title)
{
   wxBoxSizer       *mainSizer = new wxBoxSizer(wxVERTICAL);
   wxControl        *item;

   wxStaticText *statText = new wxStaticText(this, -1,
                           _("Leveller by Lynn Allan"));
   mainSizer->Add(statText, 0, wxALIGN_CENTRE | wxALL, 5);
   statText = new wxStaticText(this, -1,
                           _("Equalize soft and loud sections ... a key to better listening"));
   mainSizer->Add(statText, 0, wxALIGN_CENTRE | wxALL, 5);

   wxStaticBoxSizer *group = new wxStaticBoxSizer(new wxStaticBox(this, -1, _("Degree of Leveling")), wxVERTICAL);;
   item = new wxStaticText(this, -1,
                           _("You want to preclude the listener feeling the need to increase\nthe volume during soft sections and decreasing during loud parts.\nSome distortion can result from excessive leveling, so try to minimize\nthis with good equipment, recording technique, the speaker not\nusing too much dynamic range, and perhaps 'working the mic'."),
                           wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
   group->Add(item, 0, wxALIGN_CENTRE|wxALL, 5 );
   wxBoxSizer *hSizer = new wxBoxSizer(wxHORIZONTAL);
//   wxString numPasses[] = { "None-Skip", "Light", "Moderate", "Heavy", "Heavier", "Heaviest" };
   statText = new wxStaticText(this, -1, _("Degree of Leveling: "));
   hSizer->Add(statText, 0, wxALIGN_CENTRE | wxALL, 5);

   mLevellerNumPassesChoice = new wxChoice(this, ID_DB_NUM_PASSES_CHOICE,
                                       wxDefaultPosition, wxDefaultSize, NUM_PASSES_CHOICES,
                                       numPasses);
   hSizer->Add(mLevellerNumPassesChoice, 0, wxALIGN_LEFT|wxALL, 5);
   group->Add(hSizer, 0, wxALIGN_CENTRE|wxALL, 5 );
   mainSizer->Add(group, 0, wxALIGN_CENTRE | wxALL, 5);

   group = new wxStaticBoxSizer(new wxStaticBox(this, -1,
                                                _("Noise Threshold (Hiss/Hum/Ambient Noise)")), wxVERTICAL);
   item = new wxStaticText(this, -1,
                           _("Below the Noise Threshold, the Signal Strength is reduced.\nAbove this Threshold, the Signal Strength is equalized so that\nsoft parts are made louder and loud parts are made softer.\n\nGenerally, recordings with low noise can use lower settings. so\ngood equipment, technique, and NoiseRemoval help out a LOT."),
                           wxDefaultPosition, wxDefaultSize, wxALIGN_LEFT );
   group->Add(item, 0, wxALIGN_CENTRE|wxALL, 5 );

   hSizer = new wxBoxSizer(wxHORIZONTAL);
   statText = new wxStaticText(this, -1, _("Threshold for Noise: "));
   hSizer->Add(statText, 0, wxALIGN_CENTRE | wxALL, 5);

   mLevellerDbSilenceThresholdChoice = new wxChoice(this, ID_DB_SILENCE_THRESHOLD_CHOICE,
      wxDefaultPosition, wxDefaultSize, Enums::NumDbChoices,
                                       Enums::GetDbChoices());
   hSizer->Add(mLevellerDbSilenceThresholdChoice, 0, wxALIGN_CENTER | wxALL, 4);
   group->Add(hSizer, 0, wxALIGN_CENTRE|wxALL, 5 );
   mainSizer->Add(group, 0, wxALIGN_CENTRE | wxALL, 5);

   hSizer = new wxBoxSizer(wxHORIZONTAL);
   wxButton *cancel = new wxButton(this, wxID_CANCEL, _("&Cancel"));
   hSizer->Add(cancel, 0, wxALIGN_CENTRE|wxALL, 5);

   wxButton *ok = new wxButton(this, wxID_OK, _("&OK"));
   ok->SetDefault();
   hSizer->Add(ok, 0, wxALIGN_CENTRE|wxALL, 5);

   mainSizer->Add(hSizer, 0, wxALIGN_CENTRE|wxALIGN_CENTER_VERTICAL|wxALL, 5);

   SetAutoLayout(true);
   SetSizer(mainSizer);
   mainSizer->Fit(this);
   mainSizer->SetSizeHints(this);
}
Exemplo n.º 22
0
//----------------------------------------------------------------------------------------
DlgUser::DlgUser(wxWindow *parent, MainDoc *p_Doc, const wxString& title) :
                wxDialog(parent, ID_DIALOG_DSN, title)
{
    int chSize;                          // Height of Font * 1.4 = Height of wxTextCtrl

    float ratio = (float)1.4;
#ifdef __WXMOTIF__
    ratio = (float)2.1;
#endif

    SetBackgroundColour(_T("wheat"));
    pDoc = p_Doc;
    wxLayoutConstraints* layout;
    SetAutoLayout(true);

    m_Label1 = new wxStaticText(this, wxID_ANY, _("User ID:"));
    m_Label1->SetFont(* pDoc->ft_Doc);
    layout = new wxLayoutConstraints;
    layout->left.SameAs(this, wxLeft, 10);
    layout->top.SameAs(this, wxTop, 10);
    layout->height.AsIs();
    layout->width.Absolute(75);
    m_Label1->SetConstraints(layout);

    int w;
    m_Label1->GetSize(&w, &chSize);

    m_UserName = new wxTextCtrl(this, wxID_ANY, wxEmptyString);
    m_UserName->SetFont(* pDoc->ft_Doc);
    chSize = (int) (m_UserName->GetCharHeight()*ratio);

    layout = new wxLayoutConstraints;
    layout->left.SameAs(m_Label1, wxRight, 10);
    layout->centreY.SameAs(m_Label1,wxCentreY);
    layout->width.Absolute(200);
    layout->height.Absolute(chSize);
    // layout->height.AsIs();
    m_UserName->SetConstraints(layout);


    m_Label2 = new wxStaticText(this, wxID_ANY, _("Password:"));
    m_Label2->SetFont(* pDoc->ft_Doc);
    layout = new wxLayoutConstraints;
    layout->left.SameAs(m_Label1, wxLeft);
    layout->top.SameAs(m_Label1, wxBottom, 10);
    layout->height.AsIs();
    layout->width.SameAs(m_Label1, wxWidth);
    m_Label2->SetConstraints(layout);

    m_Password = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_PASSWORD);
    m_Password->SetFont(* pDoc->ft_Doc);
    layout = new wxLayoutConstraints;
    layout->left.SameAs(m_UserName, wxLeft);
    layout->width.SameAs(m_UserName, wxWidth);
    layout->centreY.SameAs(m_Label2,wxCentreY);
    layout->height.Absolute(chSize);
    //layout->height.AsIs();
    m_Password->SetConstraints(layout);

    m_OK = new wxButton(this, wxID_OK);
    m_OK->SetFont(* pDoc->ft_Doc);
    layout = new wxLayoutConstraints;
    layout->left.SameAs(this, wxLeft, 10);
    layout->top.SameAs(m_Label2, wxBottom,10);
    layout->height.AsIs();
    layout->width.Absolute(75);
    m_OK->SetConstraints(layout);

    m_Cancel = new wxButton(this, wxID_CANCEL);
    m_Cancel->SetFont(* pDoc->ft_Doc);
    layout = new wxLayoutConstraints;
    layout->left.SameAs(m_OK, wxRight, 10);
    layout->top.SameAs(m_OK, wxTop);
    layout->height.AsIs();
    layout->width.SameAs(m_OK, wxWidth);
    m_Cancel->SetConstraints(layout);

    m_OK->SetDefault();
    m_UserName->SetFocus();

    s_User = wxEmptyString;
    s_Password = wxEmptyString;
    Layout();
}
Exemplo n.º 23
0
/*----------------------------------------------------------------------
  DocInfoDlgWX create the Document Info dialog 
  params:
  + parent : parent window
  + doc : the document
  ----------------------------------------------------------------------*/
DocInfoDlgWX::DocInfoDlgWX( int ref, wxWindow* parent, int doc ) : 
    AmayaDialog( parent, ref )
{
  const char         *content;

  My_ref = ref;
  wxXmlResource::Get()->LoadDialog(this, parent, wxT("DocInfoDlgWX"));
  wxString wx_title = TtaConvMessageToWX(TtaGetMessage(AMAYA, AM_DOCINFO_TITLE));
  SetTitle( wx_title );

   /* Document URL */
  XRCCTRL(*this, "wxID_URL_LABEL", wxStaticText)->SetLabel(TtaConvMessageToWX(TtaGetMessage(AMAYA,AM_HREF_VALUE)));
  if (DocumentURLs[doc] != NULL)
    content = DocumentURLs[doc];
  else
  content = TtaGetMessage (AMAYA, AM_UNKNOWN);
  XRCCTRL(*this, "wxID_URL_CONTENT", wxTextCtrl)->SetValue(TtaConvMessageToWX(content));

   /* Document type */
  XRCCTRL(*this, "wxID_DOCUMENT_TYPE_LABEL", wxStaticText)->SetLabel(TtaConvMessageToWX(TtaGetMessage(AMAYA,AM_DOCINFO_TYPE)));
  content = DocumentTypeString (doc);
  if (!content)
    content = TtaGetMessage (AMAYA, AM_UNKNOWN);
  XRCCTRL(*this, "wxID_DOCUMENT_TYPE_CONTENT", wxTextCtrl)->SetValue(TtaConvMessageToWX(content));

   /* Mime Type */
  XRCCTRL(*this, "wxID_MIME_TYPE_LABEL", wxStaticText)->SetLabel(TtaConvMessageToWX(TtaGetMessage(AMAYA,AM_DOCINFO_TYPEMIME)));
  if (DocumentMeta[doc] && DocumentMeta[doc]->content_type)
    content = DocumentMeta[doc]->content_type;
  else
    content = TtaGetMessage (AMAYA, AM_UNKNOWN);
  XRCCTRL(*this, "wxID_MIME_TYPE_CONTENT", wxTextCtrl)->SetValue(TtaConvMessageToWX(content));

   /* Charset */
  XRCCTRL(*this, "wxID_CHARSET_LABEL", wxStaticText)->SetLabel(TtaConvMessageToWX(TtaGetMessage(AMAYA,AM_DOCINFO_CHARSET)));
  if (DocumentMeta[doc] && DocumentMeta[doc]->charset != NULL)
    content = DocumentMeta[doc]->charset;
  else
    content = TtaGetMessage (AMAYA, AM_UNKNOWN);
  XRCCTRL(*this, "wxID_CHARSET_CONTENT", wxTextCtrl)->SetValue(TtaConvMessageToWX(content));

   /* Content Length */
  XRCCTRL(*this, "wxID_LENGTH_LABEL", wxStaticText)->SetLabel(TtaConvMessageToWX(TtaGetMessage(AMAYA,AM_DOCINFO_CLENGTH)));
  if (DocumentMeta[doc] && DocumentMeta[doc]->content_length)
    content = DocumentMeta[doc]->content_length;
  else
    content = TtaGetMessage (AMAYA, AM_UNKNOWN);
  XRCCTRL(*this, "wxID_LENGTH_CONTENT", wxTextCtrl)->SetValue(TtaConvMessageToWX(content));

   /* Content Location */
  XRCCTRL(*this, "wxID_LOCATION_LABEL", wxStaticText)->SetLabel(TtaConvMessageToWX(TtaGetMessage(AMAYA,AM_DOCINFO_CLOCATION)));
  if (DocumentMeta[doc] 
      && DocumentMeta[doc]->full_content_location != NULL)
    content = DocumentMeta[doc]->full_content_location;
  else
    content = TtaGetMessage (AMAYA, AM_UNKNOWN);
  XRCCTRL(*this, "wxID_LOCATION_CONTENT", wxTextCtrl)->SetValue(TtaConvMessageToWX(content));

  // Reason
  if (DocumentMeta[doc] 
      && DocumentMeta[doc]->reason != NULL)
    {
      char msg[512];
      sprintf (msg, TtaGetMessage (AMAYA, AM_UNKNOWN_XXX_STATUS), DocumentMeta[doc]->reason);
      XRCCTRL(*this, "wxID_REASON", wxStaticText)->SetLabel(TtaConvMessageToWX(msg));
    }
  else
    XRCCTRL(*this, "wxID_REASON", wxStaticText)->SetLabel(TtaConvMessageToWX(""));
   
  // update dialog labels
  XRCCTRL(*this, "wxID_CANCEL", wxButton)->SetLabel(TtaConvMessageToWX(TtaGetMessage(LIB,TMSG_DONE)));

  Layout();
  SetAutoLayout( TRUE );
}
Exemplo n.º 24
0
SpectrumPrefs::SpectrumPrefs(wxWindow * parent):
PrefsPanel(parent)
{
   int fftSize = gPrefs->Read("/Spectrum/FFTSize", 256L);
   bool isGrayscale = false;
   gPrefs->Read("/Spectrum/Grayscale", &isGrayscale, false);

   int i;
   int maxFreq = gPrefs->Read("/Spectrum/MaxFreq", 8000L);
   wxString maxFreqStr;
   maxFreqStr.Printf("%d", maxFreq);

   int pos = 3;                 // Fall back to 256 if it doesn't match anything else
   for (i = 0; i < numFFTSizes; i++)
      if (fftSize == FFTSizes[i]) {
         pos = i;
         break;
      }

   topSizer = new wxStaticBoxSizer(
      new wxStaticBox(this, -1, "Spectrogram Options"),
      wxVERTICAL);

   {
      wxStaticBoxSizer *fftSizeSizer = new wxStaticBoxSizer(
         new wxStaticBox(this, -1, "FFT Size"),
         wxVERTICAL);

      mFFTSize[0] = new wxRadioButton(
         this, -1, stringFFTSizes[0], wxDefaultPosition,
         wxDefaultSize, wxRB_GROUP );
      mFFTSize[0]->SetValue(false);
      fftSizeSizer->Add(mFFTSize[0], 0, 
         wxGROW|wxLEFT|wxRIGHT, RADIO_BUTTON_BORDER );

      for(i = 1; i < numFFTSizes; i++) {
         mFFTSize[i] = new wxRadioButton(this, -1, stringFFTSizes[i]);
         mFFTSize[i]->SetValue(false);
         fftSizeSizer->Add(mFFTSize[i], 0,
            wxGROW|wxLEFT|wxRIGHT, RADIO_BUTTON_BORDER );
      }

      mFFTSize[pos]->SetValue(true);
            
      topSizer->Add( fftSizeSizer, 0, 
         wxGROW|wxALL, TOP_LEVEL_BORDER );
   }

   {
      mGrayscale  = new wxCheckBox(this, -1, "Grayscale");
      topSizer->Add(mGrayscale, 0,
         wxGROW|wxALL, RADIO_BUTTON_BORDER );
      
      if(isGrayscale)
         mGrayscale->SetValue(true);

      wxBoxSizer *freqSizer = new wxBoxSizer( wxHORIZONTAL );

      freqSizer->Add(
         new wxStaticText(this, -1, "Maximum Frequency (Hz):"),
         0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, GENERIC_CONTROL_BORDER );

      mMaxFreqCtrl = new wxTextCtrl( this, -1, maxFreqStr,
         wxDefaultPosition, wxSize(80,-1));
      freqSizer->Add(mMaxFreqCtrl, 0, wxALIGN_CENTER_VERTICAL|wxALL,
                     GENERIC_CONTROL_BORDER );

      topSizer->Add(freqSizer, 0, wxGROW|wxALL, TOP_LEVEL_BORDER );
   }


   SetAutoLayout(true);
   topSizer->Fit(this);
   topSizer->SetSizeHints(this);
   SetSizer(topSizer);
} 
Exemplo n.º 25
0
ProfileWizard::ProfileWizard(wxWindow *parent, bool firstLight) :
    wxDialog(parent, wxID_ANY, _("New Profile Wizard"), wxDefaultPosition, wxDefaultSize, wxCAPTION | wxCLOSE_BOX),
    m_launchDarks(true)
{
    TitlePrefix = _("New Profile Wizard - ");

    // Create overall vertical sizer
    m_pvSizer = new wxBoxSizer(wxVERTICAL);

#   include "icons/phd2_48.png.h"
    wxBitmap phd2(wxBITMAP_PNG_FROM_DATA(phd2_48));
    m_bitmaps[STATE_GREETINGS] = new wxBitmap(phd2);
    m_bitmaps[STATE_WRAPUP] = new wxBitmap(phd2);
#   include "icons/cam2.xpm"
    m_bitmaps[STATE_CAMERA] = new wxBitmap(cam_icon);
#   include "icons/scope1.xpm"
    m_bitmaps[STATE_MOUNT] = new wxBitmap(scope_icon);
    m_bitmaps[STATE_AUXMOUNT] = new wxBitmap(scope_icon);
#   include "icons/ao.xpm"
    m_bitmaps[STATE_AO] = new wxBitmap(ao_xpm);
#ifndef  __WXGTK__  // this resizing make a later crash in UpdateState with wxGtk
    m_bitmaps[STATE_CAMERA]->SetWidth(55);
    m_bitmaps[STATE_CAMERA]->SetHeight(55);
    m_bitmaps[STATE_MOUNT]->SetWidth(55);
    m_bitmaps[STATE_MOUNT]->SetHeight(55);
    m_bitmaps[STATE_AUXMOUNT]->SetWidth(55);
    m_bitmaps[STATE_AUXMOUNT]->SetHeight(55);
#endif // __WXGTK__

    // Build the superset of UI controls, minus state-specific labels and data
    // User instructions at top
    wxBoxSizer *instrSizer = new wxBoxSizer(wxHORIZONTAL);
    m_bitmap = new wxStaticBitmap(this, wxID_ANY, *m_bitmaps[STATE_GREETINGS], wxDefaultPosition, wxSize(55, 55));
    instrSizer->Add(m_bitmap, 0, wxALIGN_CENTER_VERTICAL | wxFIXED_MINSIZE, 5);

    m_pInstructions = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(DialogWidth, 75), wxALIGN_LEFT | wxST_NO_AUTORESIZE);
    wxFont font = m_pInstructions->GetFont();
    font.SetWeight(wxFONTWEIGHT_BOLD);
    m_pInstructions->SetFont(font);
    instrSizer->Add(m_pInstructions, wxSizerFlags().Border(wxALL, 10));
    m_pvSizer->Add(instrSizer);

    // Verbose help block
    m_pHelpGroup = new wxStaticBoxSizer(wxVERTICAL, this, _("More Info"));
    m_pHelpText = new wxStaticText(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(DialogWidth, -1));
    // Vertical sizing of help text will be handled in state machine
    m_pHelpGroup->Add(m_pHelpText, wxSizerFlags().Border(wxLEFT, 10).Border(wxBOTTOM, 10));
    m_pvSizer->Add(m_pHelpGroup, wxSizerFlags().Border(wxALL, 5));

    // Gear label and combo box
    m_pGearGrid = new wxFlexGridSizer(1, 2, 5, 15);
    m_pGearLabel = new wxStaticText(this, wxID_ANY, "Temp:", wxDefaultPosition, wxDefaultSize);
    m_pGearChoice = new wxChoice(this, ID_COMBO, wxDefaultPosition, wxDefaultSize,
                              GuideCamera::List(), 0, wxDefaultValidator, _("Gear"));
    m_pGearGrid->Add(m_pGearLabel, 1, wxALL, 5);
    m_pGearGrid->Add(m_pGearChoice, 1, wxLEFT, 10);
    m_pvSizer->Add(m_pGearGrid, wxSizerFlags().Center().Border(wxALL, 5));

    // Control for pixel-size and focal length
    m_pUserProperties = new wxFlexGridSizer(2, 2, 5, 15);
    m_pPixelSize = new wxSpinCtrlDouble(this, ID_PIXELSIZE, wxEmptyString, wxDefaultPosition,
                                          wxDefaultSize, wxSP_ARROW_KEYS, 0.0, 20.0, 0.0, 0.1);
    m_pPixelSize->SetDigits(2);
    m_PixelSize = m_pPixelSize->GetValue();
    m_pPixelSize->SetToolTip(_("Click Detect to read the pixel size from the camera. Otherwise, you can get this value from your camera documentation or from an online source.  You can use the up/down control "
        "or type in a value directly."));
    m_detectPixelSizeBtn = new wxButton(this, ID_DETECT_PIXELSIZE, _("Detect"));
    m_detectPixelSizeBtn->Enable(false);
    m_detectPixelSizeBtn->SetToolTip(_("Connect to camera and detect pixel size"));
    wxBoxSizer *sizer = new wxBoxSizer(wxHORIZONTAL);
    sizer->Add(m_pPixelSize, 1);
    sizer->Add(m_detectPixelSizeBtn, 0, wxLEFT, 10);
    AddTableEntryPair(this, m_pUserProperties, _("Guide camera un-binned pixel size (microns)"), sizer);
    m_pFocalLength = new wxSpinCtrlDouble(this, ID_FOCALLENGTH, _T("foo2"), wxDefaultPosition,
        wxDefaultSize, wxSP_ARROW_KEYS, 50, 3000, 300, 50);
    m_pFocalLength->SetValue(300);
    m_pFocalLength->SetDigits(0);
    m_pFocalLength->SetToolTip(_("This is the focal length of the guide scope - or the imaging scope if you are using an off-axis-guider or "
        "an adaptive optics device.  You can use the up/down control or type in a value directly."));
    m_FocalLength = (int) m_pFocalLength->GetValue();
    AddTableEntryPair(this, m_pUserProperties, _("Guide scope focal length (mm)"), m_pFocalLength);
    // controls for the mount pane
    wxBoxSizer *mtSizer = new wxBoxSizer(wxHORIZONTAL);
    m_pMountProperties = new wxFlexGridSizer(1, 2, 5, 15);
    m_pGuideSpeed = new wxSpinCtrlDouble(this, ID_GUIDESPEED, wxEmptyString, wxDefaultPosition,
        wxDefaultSize, wxSP_ARROW_KEYS, 0.2, 1.0, 0.5, 0.1);
    m_pGuideSpeed->SetValue(0.5);
    m_GuideSpeed = 0.5;
    m_pGuideSpeed->SetDigits(2);
    m_pGuideSpeed->SetToolTip(_("The mount guide speed you will use for calibration and guiding, expressed as a multiple of the sidereal rate. If you "
        "don't know, leave the setting at the default value (0.5X)"));
    m_detectGuideSpeedBtn = new wxButton(this, ID_DETECT_GUIDESPEED, _("Detect"));
    m_detectGuideSpeedBtn->Enable(false);
    m_detectGuideSpeedBtn->SetToolTip(_("Connect to mount and detect guide speed"));
    mtSizer->Add(m_pGuideSpeed, 1);
    mtSizer->Add(10, 0);
    mtSizer->Add(m_detectGuideSpeedBtn);
    AddTableEntryPair(this, m_pMountProperties, _("Mount guide speed (n.n x sidereal)"), mtSizer);

    m_pvSizer->Add(m_pUserProperties, wxSizerFlags().Center().Border(wxALL, 5));
    m_pvSizer->Add(m_pMountProperties, wxSizerFlags().Center().Border(wxALL, 5));

    // Wrapup panel
    m_pWrapUp = new wxFlexGridSizer(2, 2, 5, 15);
    m_pProfileName = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxSize(250,-1));
    m_pLaunchDarks = new wxCheckBox(this, wxID_ANY, _("Build dark library"));
    m_pLaunchDarks->SetValue(m_launchDarks);
    m_pLaunchDarks->SetToolTip(_("Check this to automatically start the process of building a dark library for this profile."));
    AddTableEntryPair(this, m_pWrapUp, _("Profile Name"), m_pProfileName);
    m_pWrapUp->Add(m_pLaunchDarks, wxSizerFlags().Border(wxTOP, 5).Border(wxLEFT, 10));
    m_pvSizer->Add(m_pWrapUp, wxSizerFlags().Border(wxALL, 10).Expand().Center());

    // Row of buttons for prev, help, next
    wxBoxSizer *pButtonSizer = new wxBoxSizer(wxHORIZONTAL);
    m_pPrevBtn = new wxButton(this, ID_PREV, _("< Back"));
    m_pPrevBtn->SetToolTip(_("Back up to the previous screen"));

    wxButton* helpBtn = new wxButton(this, ID_HELP, _("Help"));

    m_pNextBtn = new wxButton(this, ID_NEXT, _("Next >"));
    m_pNextBtn->SetToolTip(_("Move forward to next screen"));

    pButtonSizer->AddStretchSpacer();
    pButtonSizer->Add(
        m_pPrevBtn,
        wxSizerFlags(0).Align(0).Border(wxALL, 5));
    pButtonSizer->Add(
        helpBtn,
        wxSizerFlags(0).Align(0).Border(wxALL, 5));
    pButtonSizer->Add(
        m_pNextBtn,
        wxSizerFlags(0).Align(0).Border(wxALL, 5));
    m_pvSizer->Add(pButtonSizer, wxSizerFlags().Expand().Border(wxALL, 10));

    // Status bar for error messages
    m_pStatusBar = new wxStatusBar(this, -1);
    m_pStatusBar->SetFieldsCount(1);
    m_pvSizer->Add(m_pStatusBar, 0, wxGROW);

    SetAutoLayout(true);
    SetSizerAndFit(m_pvSizer);
    // Special cases - neither AuxMount nor AO requires an explicit user choice
    m_SelectedAuxMount = _("None");
    m_SelectedAO = _("None");
    if (firstLight)
        m_State = STATE_GREETINGS;
    else
        m_State = STATE_CAMERA;
    UpdateState(0);
}
Exemplo n.º 26
0
CStarNetSet::CStarNetSet(wxWindow* parent, int id, const wxString& title, const wxString& band, const wxString& callsign, const wxString& logoff, const wxString& info, const wxString& permanent, unsigned int userTimeout, unsigned int groupTimeout, STARNET_CALLSIGN_SWITCH callsignSwitch, bool txMsgSwitch, const wxString& reflector) :
#else
CStarNetSet::CStarNetSet(wxWindow* parent, int id, const wxString& title, const wxString& band, const wxString& callsign, const wxString& logoff, const wxString& info, const wxString& permanent, unsigned int userTimeout, unsigned int groupTimeout, STARNET_CALLSIGN_SWITCH callsignSwitch, bool txMsgSwitch) :
#endif
wxPanel(parent, id),
m_title(title),
m_band(NULL),
m_callsign(NULL),
m_logoff(NULL),
m_info(NULL),
m_permanent(NULL),
m_userTimeout(NULL),
m_groupTimeout(NULL),
m_callsignSwitch(NULL),
m_txMsgSwitch(NULL)
#if defined(DEXTRA_LINK) || defined(DCS_LINK)
,m_reflector(NULL)
#endif
{
	wxFlexGridSizer* sizer = new wxFlexGridSizer(3);

	wxStaticText* bandLabel = new wxStaticText(this, -1, _("Band"));
	sizer->Add(bandLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_band = new wxChoice(this, -1, wxDefaultPosition, wxSize(BAND_WIDTH, -1));
	m_band->Append(wxT("A"));
	m_band->Append(wxT("B"));
	m_band->Append(wxT("C"));
	m_band->Append(wxT("D"));
	sizer->Add(m_band, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	bool res = m_band->SetStringSelection(band);
	if (!res)
		m_band->SetSelection(0);

	wxStaticText* dummy1Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy1Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* callsignLabel = new wxStaticText(this, -1, _("Group Call"));
	sizer->Add(callsignLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxString call = callsign;
	call.Truncate(LONG_CALLSIGN_LENGTH);

	m_callsign = new CCallsignTextCtrl(this, -1, call, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_callsign->SetMaxLength(LONG_CALLSIGN_LENGTH);
	sizer->Add(m_callsign, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* dummy2Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy2Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* logoffLabel = new wxStaticText(this, -1, _("Logoff Call"));
	sizer->Add(logoffLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	call = logoff;
	call.Truncate(LONG_CALLSIGN_LENGTH);

	m_logoff = new CCallsignTextCtrl(this, -1, call, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_logoff->SetMaxLength(LONG_CALLSIGN_LENGTH);
	sizer->Add(m_logoff, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* dummy3Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy3Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* infoLabel = new wxStaticText(this, -1, _("Information"));
	sizer->Add(infoLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_info = new wxTextCtrl(this, -1, info, wxDefaultPosition, wxSize(INFO_WIDTH, -1));
	m_info->SetMaxLength(INFO_LENGTH);
	sizer->Add(m_info, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* dummy4Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy4Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* permanentLabel = new wxStaticText(this, -1, _("Permanent Call"));
	sizer->Add(permanentLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	call = permanent;
	call.Truncate(LONG_CALLSIGN_LENGTH);

	m_permanent = new CCallsignTextCtrl(this, -1, call, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_permanent->SetMaxLength(LONG_CALLSIGN_LENGTH);
	sizer->Add(m_permanent, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	wxStaticText* dummy4ALabel = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy4ALabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* userTimeoutLabel = new wxStaticText(this, -1, _("User Timeout"));
	sizer->Add(userTimeoutLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_userTimeout = new wxChoice(this, -1, wxDefaultPosition, wxSize(TIMEOUT_WIDTH, -1));
	m_userTimeout->Append(_("Never"));
	m_userTimeout->Append(_("30 mins"));
	m_userTimeout->Append(_("60 mins"));
	m_userTimeout->Append(_("120 mins"));
	m_userTimeout->Append(_("180 mins"));
	m_userTimeout->Append(_("240 mins"));
	m_userTimeout->Append(_("300 mins"));
	sizer->Add(m_userTimeout, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	switch (userTimeout) {
		case 0U:   m_userTimeout->SetSelection(0); break;
		case 30U:  m_userTimeout->SetSelection(1); break;
		case 60U:  m_userTimeout->SetSelection(2); break;
		case 120U: m_userTimeout->SetSelection(3); break;
		case 180U: m_userTimeout->SetSelection(4); break;
		case 240U: m_userTimeout->SetSelection(5); break;
		default:   m_userTimeout->SetSelection(6); break;
	}

	wxStaticText* dummy5Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy5Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* groupTimeoutLabel = new wxStaticText(this, -1, _("Group Timeout"));
	sizer->Add(groupTimeoutLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_groupTimeout = new wxChoice(this, -1, wxDefaultPosition, wxSize(TIMEOUT_WIDTH, -1));
	m_groupTimeout->Append(_("Never"));
	m_groupTimeout->Append(_("30 mins"));
	m_groupTimeout->Append(_("60 mins"));
	m_groupTimeout->Append(_("120 mins"));
	m_groupTimeout->Append(_("180 mins"));
	m_groupTimeout->Append(_("240 mins"));
	m_groupTimeout->Append(_("300 mins"));
	sizer->Add(m_groupTimeout, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	switch (groupTimeout) {
		case 0U:   m_groupTimeout->SetSelection(0); break;
		case 30U:  m_groupTimeout->SetSelection(1); break;
		case 60U:  m_groupTimeout->SetSelection(2); break;
		case 120U: m_groupTimeout->SetSelection(3); break;
		case 180U: m_groupTimeout->SetSelection(4); break;
		case 240U: m_groupTimeout->SetSelection(5); break;
		default:   m_groupTimeout->SetSelection(6); break;
	}

	wxStaticText* dummy6Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy6Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* callsignSwitchLabel = new wxStaticText(this, -1, _("MYCALL Setting"));
	sizer->Add(callsignSwitchLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_callsignSwitch = new wxChoice(this, -1, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_callsignSwitch->Append(_("Group"));
	m_callsignSwitch->Append(_("User"));
	sizer->Add(m_callsignSwitch, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	switch (callsignSwitch) {
		case SCS_GROUP_CALLSIGN: m_callsignSwitch->SetSelection(0); break;
		case SCS_USER_CALLSIGN:  m_callsignSwitch->SetSelection(1); break;
		default:                 m_callsignSwitch->SetSelection(0); break;
	}

	wxStaticText* dummy7Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy7Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	wxStaticText* txMsgSwitchLabel = new wxStaticText(this, -1, _("TX Message"));
	sizer->Add(txMsgSwitchLabel, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

	m_txMsgSwitch = new wxChoice(this, -1, wxDefaultPosition, wxSize(CALLSIGN_WIDTH, -1));
	m_txMsgSwitch->Append(_("Off"));
	m_txMsgSwitch->Append(_("On"));
	sizer->Add(m_txMsgSwitch, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	m_txMsgSwitch->SetSelection(txMsgSwitch ? 1 : 0);

	wxStaticText* dummy8Label = new wxStaticText(this, -1, wxEmptyString);
	sizer->Add(dummy8Label, 0, wxALL | wxALIGN_RIGHT, BORDER_SIZE);

#if defined(DEXTRA_LINK)
	wxStaticText* reflectorLabel = new wxStaticText(this, -1, _("Reflector"));
	sizer->Add(reflectorLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_reflector = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));
	m_reflector->Append(_("None"));

	wxFileName fileName(wxFileName::GetHomeDir(), DEXTRA_HOSTS_FILE_NAME);
	if (!fileName.IsFileReadable()) {
		wxLogMessage(wxT("File %s not readable"), fileName.GetFullPath().c_str());
#if defined(__WINDOWS__)
		fileName.Assign(::wxGetCwd(), DEXTRA_HOSTS_FILE_NAME);
#else
		fileName.Assign(wxT(DATA_DIR), DEXTRA_HOSTS_FILE_NAME);
#endif
		if (!fileName.IsFileReadable())
			wxLogMessage(wxT("File %s not readable"), fileName.GetFullPath().c_str());
	}

	CHostFile file(fileName.GetFullPath(), false);

	for (unsigned int i = 0U; i < file.getCount(); i++)
		m_reflector->Append(file.getName(i));

	sizer->Add(m_reflector, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	if (reflector.IsEmpty()) {
		m_reflector->SetSelection(0);
	} else {
		wxString name = reflector;
		name.SetChar(LONG_CALLSIGN_LENGTH - 1U, wxT(' '));
		bool res = m_reflector->SetStringSelection(name);
		if (!res)
			m_reflector->SetSelection(0);
	}

	m_channel = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH2, -1));
	m_channel->Append(wxT("A"));
	m_channel->Append(wxT("B"));
	m_channel->Append(wxT("C"));
	m_channel->Append(wxT("D"));
	m_channel->Append(wxT("E"));
	sizer->Add(m_channel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	res = m_channel->SetStringSelection(reflector.Right(1U));
	if (!res)
		m_channel->SetSelection(0);
#endif

#if defined(DCS_LINK)
	wxStaticText* reflectorLabel = new wxStaticText(this, -1, _("Reflector"));
	sizer->Add(reflectorLabel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	m_reflector = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH1, -1));
	m_reflector->Append(_("None"));

	wxFileName fileName(wxFileName::GetHomeDir(), DCS_HOSTS_FILE_NAME);
	if (!fileName.IsFileReadable()) {
		wxLogMessage(wxT("File %s not readable"), fileName.GetFullPath().c_str());
#if defined(__WINDOWS__)
		fileName.Assign(::wxGetCwd(), DCS_HOSTS_FILE_NAME);
#else
		fileName.Assign(wxT(DATA_DIR), DCS_HOSTS_FILE_NAME);
#endif
		if (!fileName.IsFileReadable())
			wxLogMessage(wxT("File %s not readable"), fileName.GetFullPath().c_str());
	}

	CHostFile file(fileName.GetFullPath(), false);

	for (unsigned int i = 0U; i < file.getCount(); i++)
		m_reflector->Append(file.getName(i));

	sizer->Add(m_reflector, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);

	if (reflector.IsEmpty()) {
		m_reflector->SetSelection(0);
	} else {
		wxString name = reflector;
		name.SetChar(LONG_CALLSIGN_LENGTH - 1U, wxT(' '));
		bool res = m_reflector->SetStringSelection(name);
		if (!res)
			m_reflector->SetSelection(0);
	}

	m_channel = new wxChoice(this, -1, wxDefaultPosition, wxSize(CONTROL_WIDTH2, -1));
	m_channel->Append(wxT("A"));
	m_channel->Append(wxT("B"));
	m_channel->Append(wxT("C"));
	m_channel->Append(wxT("D"));
	m_channel->Append(wxT("E"));
	m_channel->Append(wxT("F"));
	m_channel->Append(wxT("G"));
	m_channel->Append(wxT("H"));
	m_channel->Append(wxT("I"));
	m_channel->Append(wxT("J"));
	m_channel->Append(wxT("K"));
	m_channel->Append(wxT("L"));
	m_channel->Append(wxT("M"));
	m_channel->Append(wxT("N"));
	m_channel->Append(wxT("O"));
	m_channel->Append(wxT("P"));
	m_channel->Append(wxT("Q"));
	m_channel->Append(wxT("R"));
	m_channel->Append(wxT("S"));
	m_channel->Append(wxT("T"));
	m_channel->Append(wxT("U"));
	m_channel->Append(wxT("V"));
	m_channel->Append(wxT("W"));
	m_channel->Append(wxT("X"));
	m_channel->Append(wxT("Y"));
	m_channel->Append(wxT("Z"));
	sizer->Add(m_channel, 0, wxALL | wxALIGN_LEFT, BORDER_SIZE);
	res = m_channel->SetStringSelection(reflector.Right(1U));
	if (!res)
		m_channel->SetSelection(0);
#endif

	SetAutoLayout(true);

	SetSizer(sizer);
}


CStarNetSet::~CStarNetSet()
{
}

bool CStarNetSet::Validate()
{
	int n = m_band->GetCurrentSelection();
	if (n == wxNOT_FOUND) {
		wxMessageDialog dialog(this, _("The StarNet Band is not set"), m_title + _(" Error"), wxICON_ERROR);
		dialog.ShowModal();
		return false;
	}

	n = m_userTimeout->GetCurrentSelection();
	if (n == wxNOT_FOUND) {
		wxMessageDialog dialog(this, _("The StarNet user timeout is not set"), m_title + _(" Error"), wxICON_ERROR);
		dialog.ShowModal();
		return false;
	}

	n = m_groupTimeout->GetCurrentSelection();
	if (n == wxNOT_FOUND) {
		wxMessageDialog dialog(this, _("The StarNet group timeout is not set"), m_title + _(" Error"), wxICON_ERROR);
		dialog.ShowModal();
		return false;
	}

	n = m_callsignSwitch->GetCurrentSelection();
	if (n == wxNOT_FOUND) {
		wxMessageDialog dialog(this, _("The MYCALL Setting is not set"), m_title + _(" Error"), wxICON_ERROR);
		dialog.ShowModal();
		return false;
	}

	n = m_txMsgSwitch->GetCurrentSelection();
	if (n == wxNOT_FOUND) {
		wxMessageDialog dialog(this, _("The TX Message switch is not set"), m_title + _(" Error"), wxICON_ERROR);
		dialog.ShowModal();
		return false;
	}

#if defined(DEXTRA_LINK) || defined(DCS_LINK)
	n = m_reflector->GetCurrentSelection();
	if (n == wxNOT_FOUND) {
		wxMessageDialog dialog(this, _("The StarNet reflector link is not set"), m_title + _(" Error"), wxICON_ERROR);
		dialog.ShowModal();
		return false;
	}
#endif

	return true;
}
Exemplo n.º 27
0
//------------------------------------------------------------------------------
ViewTextDialog::ViewTextDialog(wxWindow *parent, const wxString& title,
                               bool isEditable, const wxPoint &pos,
                               const wxSize &size, long style)
   : wxDialog(parent, -1, title, pos, size, style, title)
{
   isTextEditable = isEditable;
   
   // create bottom buttons
   theOkButton =
      new wxButton(this, ID_BUTTON, wxT("OK"), wxDefaultPosition, wxDefaultSize, 0);
   
   if (isTextEditable)
      theCancelButton =
         new wxButton(this, ID_BUTTON, wxT("Cancel"), wxDefaultPosition, wxDefaultSize, 0);
   
   // adds the buttons to button sizer
   theButtonSizer = new wxBoxSizer(wxHORIZONTAL);
   theButtonSizer->Add(theOkButton, 0, wxALIGN_CENTER | wxALL, 2);
   if (isTextEditable)
      theButtonSizer->Add(theCancelButton, 0, wxALIGN_CENTER | wxALL, 2);
   
   theBottomSizer = new wxBoxSizer(wxVERTICAL);
   theBottomSizer->Add(theButtonSizer, 0, wxALIGN_CENTER | wxALL, 2);
   
   // Set additional style wxTE_RICH to Ctrl + mouse scroll wheel to decrease or
   // increase text size(loj: 2009.02.05)
   if (isTextEditable)
      theText = new wxTextCtrl(this, -1, wxT(""), wxDefaultPosition, size,
                               wxTE_PROCESS_ENTER);
   else
      theText = new wxTextCtrl(this, -1, wxT(""), wxDefaultPosition, size,
                               wxTE_MULTILINE | wxTE_READONLY | wxTE_RICH);
   
   if (!isTextEditable)
      theText->SetMaxLength(320000);
   //theText->SetFont( GmatAppData::GetFont());
   
   // add items to middle sizer
   theMiddleSizer = new wxBoxSizer(wxVERTICAL);
   if (isTextEditable)
      theMiddleSizer->Add(theText, 0, wxGROW|wxALL, 2);
   else
      theMiddleSizer->Add(theText, 1, wxGROW|wxALL, 2);
   
   // add items to dialog sizer
   wxBoxSizer *dialogSizer = new wxBoxSizer(wxVERTICAL);
   if (isTextEditable)
   {
      dialogSizer->Add(theMiddleSizer, 0, wxGROW | wxALL, 1);
      dialogSizer->Add(theBottomSizer, 0, wxGROW | wxALL, 1);
   }
   else
   {
      dialogSizer->Add(theMiddleSizer, 1, wxGROW | wxALL, 1);
      dialogSizer->Add(theBottomSizer, 0, wxGROW | wxALL, 1);
   }
   
   
   // tells the enclosing window to adjust to the size of the sizer
   SetAutoLayout(TRUE);
   SetSizer(dialogSizer);
   dialogSizer->Fit(this);
   dialogSizer->SetSizeHints(this);
   
   // Set icon if icon file is in the start up file
   FileManager *fm = FileManager::Instance();
   try
   {
      wxString iconfile = fm->GetFullPathname(wxT("MAIN_ICON_FILE")).c_str();
      #if defined __WXMSW__
         SetIcon(wxIcon(iconfile, wxBITMAP_TYPE_ICO));
      #elif defined __WXGTK__
         SetIcon(wxIcon(iconfile, wxBITMAP_TYPE_XPM));
      #elif defined __WXMAC__
         SetIcon(wxIcon(iconfile, wxBITMAP_TYPE_PICT_RESOURCE));
      #endif
   }
   catch (GmatBaseException &)
   {
      //MessageInterface::ShowMessage(e.GetMessage());
   }
   
   if (!isTextEditable)
      CenterOnScreen(wxBOTH);
}
Exemplo n.º 28
0
wxNumberEntryDialog::wxNumberEntryDialog(wxWindow *parent,
                                         const wxString& message,
                                         const wxString& prompt,
                                         const wxString& caption,
                                         long value,
                                         long min,
                                         long max,
                                         const wxPoint& pos)
                   : wxDialog(parent, wxID_ANY, caption,
                              pos, wxDefaultSize)
{
    m_value = value;
    m_max = max;
    m_min = min;

    wxBeginBusyCursor();

    wxBoxSizer *topsizer = new wxBoxSizer( wxVERTICAL );
#if wxUSE_STATTEXT
    // 1) text message
    topsizer->Add( CreateTextSizer( message ), 0, wxALL, 10 );
#endif

    // 2) prompt and text ctrl
    wxBoxSizer *inputsizer = new wxBoxSizer( wxHORIZONTAL );

#if wxUSE_STATTEXT
    // prompt if any
    if (!prompt.empty())
        inputsizer->Add( new wxStaticText( this, wxID_ANY, prompt ), 0, wxCENTER | wxLEFT, 10 );
#endif

    // spin ctrl
    wxString valStr;
    valStr.Printf(wxT("%ld"), m_value);
    m_spinctrl = new wxSpinCtrl(this, wxID_ANY, valStr, wxDefaultPosition, wxSize( 140, wxDefaultCoord ) );
#if wxUSE_SPINCTRL
    m_spinctrl->SetRange((int)m_min, (int)m_max);
#endif
    inputsizer->Add( m_spinctrl, 1, wxCENTER | wxLEFT | wxRIGHT, 10 );
    // add both
    topsizer->Add( inputsizer, 0, wxEXPAND | wxLEFT|wxRIGHT, 5 );

    // 3) buttons if any
    wxSizer *buttonSizer = CreateSeparatedButtonSizer(wxOK | wxCANCEL);
    if ( buttonSizer )
    {
        topsizer->Add(buttonSizer, wxSizerFlags().Expand().DoubleBorder());
    }

    SetSizer( topsizer );
    SetAutoLayout( true );

    topsizer->SetSizeHints( this );
    topsizer->Fit( this );

    Centre( wxBOTH );

    m_spinctrl->SetSelection(-1, -1);
    m_spinctrl->SetFocus();

    wxEndBusyCursor();
}
Exemplo n.º 29
0
// Constructor
WxCasFrame::WxCasFrame ( const wxString & title ) :
		wxFrame ( ( wxFrame * ) NULL, -1, title, wxDefaultPosition, wxDefaultSize, wxDEFAULT_FRAME_STYLE )
{
	// Give it an icon
#ifdef __WXMSW__
	wxIcon icon(wxT("wxcas"));
#else
	wxIcon icon;
	icon.CopyFromBitmap( WxCasPix::getPixmap( wxT( "wxcas" ) ) );
#endif
	SetIcon ( icon );

	// Prefs
	wxConfigBase * prefs = wxConfigBase::Get();

	m_maxLineCount = 0;

	// Check if we have a previous DL max hit
	double absoluteMaxDL = ( double ) ( prefs->Read ( WxCasCte::ABSOLUTE_MAX_DL_KEY, 0L ) ) / 1024.0; // Stored in bytes
	wxDateTime absoluteMaxDlDate( ( time_t ) ( prefs->Read ( WxCasCte::ABSOLUTE_MAX_DL_DATE_KEY,
	                              ( long ) ( wxDateTime::Now().GetTicks() ) ) ) ); // Stored in Ticks

	// Add Online Sig file
	m_aMuleSig = new OnLineSig ( wxFileName( prefs->
	                             Read ( WxCasCte::AMULESIG_PATH_KEY,
	                                    WxCasCte::DEFAULT_AMULESIG_PATH ),
	                             WxCasCte::AMULESIG_FILENAME ),
	                             absoluteMaxDL, absoluteMaxDlDate );

	//Save absolute hit if we reach it during constructing
	if ( m_aMuleSig->IsSessionMaxDlChanged() ) {
		SaveAbsoluteHits();
	}

#ifdef __LINUX__		// System monitoring on Linux

	m_sysMonitor = new LinuxMon ();
#endif

	// Status Bar
	CreateStatusBar ();
	SetStatusText ( _( "Welcome!" ) );

	// Frame Vertical sizer
	m_frameVBox = new wxBoxSizer ( wxVERTICAL );

	// Add Main panel to frame (needed by win32 for padding sub panels)
	m_mainPanel = new wxPanel ( this, -1 );

	// Main Panel Vertical Sizer
	m_mainPanelVBox = new wxBoxSizer ( wxVERTICAL );

	// Main Panel static line
	m_staticLine = new wxStaticLine ( m_mainPanel, -1 );

#ifdef __WXMSW__

	m_BottomStaticLine = new wxStaticLine ( m_mainPanel, -1 );
#endif

	// Statistics Static Vertical Box Sizer
	m_sigPanelSBox = new wxStaticBox ( m_mainPanel, -1, _( "aMule" ) );
	m_sigPanelSBoxSizer = new wxStaticBoxSizer ( m_sigPanelSBox, wxVERTICAL );

	// Hit Static Horizontal Box Sizer
	m_hitPanelSBox = new wxStaticBox ( m_mainPanel, -1, _( "Maximum DL rate since wxCas is running" ) );
	m_hitPanelSBoxSizer = new wxStaticBoxSizer ( m_hitPanelSBox, wxHORIZONTAL );

	// Hit Static Horizontal Box Sizer
	m_absHitPanelSBox = new wxStaticBox ( m_mainPanel, -1, _( "Absolute Maximum DL rate during wxCas previous runs" ) );
	m_absHitPanelSBoxSizer = new wxStaticBoxSizer ( m_absHitPanelSBox, wxHORIZONTAL );

	// Statistic labels
	m_statLine_1 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_1() );
	m_statLine_2 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_2() );
	m_statLine_3 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_3() );
	m_statLine_4 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_4() );
	m_statLine_5 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_5() );
	m_statLine_6 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_6() );
	m_statLine_7 = new wxStaticText ( m_mainPanel, -1, MakeStatLine_7() );

	m_hitLine = new wxStaticText ( m_mainPanel, -1, MakeHitsLine_1() );
	m_hitButton =
	    new wxButton ( m_mainPanel, ID_HIT_BUTTON, wxString ( _( "Reset" ) ) );

	m_absHitLine = new wxStaticText ( m_mainPanel, -1, MakeHitsLine_2() );
	m_absHitButton =
	    new wxButton ( m_mainPanel, ID_ABS_HIT_BUTTON, wxString ( _( "Reset" ) ) );

#ifdef __LINUX__		// System monitoring on Linux

	// Monitoring Static Vertical Box Sizer
	m_monPanelSBox = new wxStaticBox ( m_mainPanel, -1, _( "System" ) );
	m_monPanelSBoxSizer = new wxStaticBoxSizer ( m_monPanelSBox, wxVERTICAL );

	m_sysLine_1 = new wxStaticText ( m_mainPanel, -1, MakeSysLine_1() );
	m_sysLine_2 = new wxStaticText ( m_mainPanel, -1, MakeSysLine_2() );
#endif

	// Statistic Panel Layout
	m_sigPanelSBoxSizer->Add ( m_statLine_1, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_sigPanelSBoxSizer->Add ( m_statLine_2, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_sigPanelSBoxSizer->Add ( m_statLine_3, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_sigPanelSBoxSizer->Add ( m_statLine_4, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_sigPanelSBoxSizer->Add ( m_statLine_5, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_sigPanelSBoxSizer->Add ( m_statLine_6, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_sigPanelSBoxSizer->Add ( m_statLine_7, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );

	m_hitPanelSBoxSizer->Add ( m_hitLine, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxGROW, 5 );
	m_hitPanelSBoxSizer->Add ( m_hitButton, 0, wxALL | wxALIGN_RIGHT, 5 );

	m_absHitPanelSBoxSizer->Add ( m_absHitLine, 0, wxALL | wxALIGN_LEFT | wxALIGN_CENTER_VERTICAL | wxGROW, 5 );
	m_absHitPanelSBoxSizer->Add ( m_absHitButton, 0, wxALL | wxALIGN_RIGHT, 5 );

#ifdef __LINUX__		// System monitoring on Linux

	m_monPanelSBoxSizer->Add ( m_sysLine_1, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
	m_monPanelSBoxSizer->Add ( m_sysLine_2, 0, wxALL | wxALIGN_CENTER | wxGROW, 5 );
#endif

	// Main panel Layout
	m_mainPanelVBox->Add ( m_staticLine, 0, wxALL | wxALIGN_CENTER | wxGROW );

	m_mainPanelVBox->Add ( m_sigPanelSBoxSizer, 0, wxALL | wxALIGN_CENTER | wxGROW, 10 );

#ifdef __LINUX__		// System monitoring on Linux

	m_mainPanelVBox->Add ( m_monPanelSBoxSizer, 0, wxALL | wxALIGN_CENTER | wxGROW, 10 );
#endif

	m_mainPanelVBox->Add ( m_hitPanelSBoxSizer, 0, wxALL | wxALIGN_CENTER | wxGROW, 10 );

	m_mainPanelVBox->Add ( m_absHitPanelSBoxSizer, 0, wxALL | wxALIGN_CENTER | wxGROW, 10 );

#ifdef __WXMSW__

	m_mainPanelVBox->Add ( m_BottomStaticLine, 0, wxALL | wxALIGN_CENTER | wxGROW );
#endif

	// Toolbar Pixmaps
	m_toolBarBitmaps[ 0 ] = WxCasPix::getPixmap( wxT( "refresh" ) );
	m_toolBarBitmaps[ 1 ] = WxCasPix::getPixmap( wxT( "save" ) );
	m_toolBarBitmaps[ 2 ] = WxCasPix::getPixmap( wxT( "print" ) );
	m_toolBarBitmaps[ 3 ] = WxCasPix::getPixmap( wxT( "about" ) );
	m_toolBarBitmaps[ 4 ] = WxCasPix::getPixmap( wxT( "stop" ) );
	m_toolBarBitmaps[ 5 ] = WxCasPix::getPixmap( wxT( "prefs" ) );

	// Constructing toolbar
	m_toolbar =
	    new wxToolBar ( this, -1, wxDefaultPosition, wxDefaultSize,
	                    wxTB_HORIZONTAL | wxTB_FLAT );

	m_toolbar->SetToolBitmapSize ( wxSize ( 32, 32 ) );
	m_toolbar->SetMargins ( 2, 2 );

	m_toolbar->AddTool ( ID_BAR_REFRESH, wxT( "Refresh" ), m_toolBarBitmaps[ 0 ],
	                     _( "Stop Auto Refresh" ) );

	m_toolbar->AddSeparator ();

	m_toolbar->AddTool ( ID_BAR_SAVE, wxT( "Save" ), m_toolBarBitmaps[ 1 ],
	                     _( "Save Online Statistics image" ) );

	m_toolbar->AddTool ( ID_BAR_PRINT, wxT( "Print" ), m_toolBarBitmaps[ 2 ],
	                     _( "Print Online Statistics image" ) );

	m_toolbar->AddTool ( ID_BAR_PREFS, wxT( "Prefs" ), m_toolBarBitmaps[ 5 ],
	                     _( "Preferences setting" ) );

	m_toolbar->AddSeparator ();

	m_toolbar->AddTool ( ID_BAR_ABOUT, wxT( "About" ), m_toolBarBitmaps[ 3 ],
	                     _( "About wxCas" ) );

	m_toolbar->Realize ();

	SetToolBar ( m_toolbar );

	// Panel Layout
	m_mainPanel->SetAutoLayout( true );
	m_mainPanel->SetSizer ( m_mainPanelVBox );

	// Frame Layout
	m_frameVBox->Add ( m_mainPanel, 1, wxALL | wxGROW );
	SetAutoLayout ( TRUE );
	SetSizerAndFit ( m_frameVBox );

	// Add refresh timer
	m_refresh_timer = new wxTimer ( this, ID_REFRESH_TIMER );
	m_refresh_timer->Start ( 1000 * prefs->Read ( WxCasCte::REFRESH_RATE_KEY, WxCasCte::DEFAULT_REFRESH_RATE ) );	// s to ms

	// Add FTP update timer
	m_ftp_update_timer = new wxTimer ( this, ID_FTP_UPDATE_TIMER );
	m_ftp_update_timer->Start ( 60000 * prefs->Read ( WxCasCte::FTP_UPDATE_RATE_KEY, WxCasCte::DEFAULT_FTP_UPDATE_RATE ) );	// min to ms
}
Exemplo n.º 30
0
void LuminaryPanel::doLayout()
{
  wxBoxSizer* m_panelSizer = new wxBoxSizer(wxVERTICAL);
  wxBoxSizer* m_timeStepSizer = new wxBoxSizer(wxHORIZONTAL);
  wxBoxSizer* m_resSizer = new wxBoxSizer(wxHORIZONTAL);
  wxBoxSizer* m_omegaDiffSizer = new wxBoxSizer(wxHORIZONTAL);
  wxBoxSizer* m_omegaProjSizer = new wxBoxSizer(wxHORIZONTAL);
  wxBoxSizer* m_epsilonSizer = new wxBoxSizer(wxHORIZONTAL);

  if(m_luminary){
    wxBoxSizer* m_posSizer = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer* m_wickSizer = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer* m_skeletonsNumberSizer = new wxBoxSizer(wxHORIZONTAL);

    /* Luminaire */
    m_posSizer->Add(m_posLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
    m_posSizer->Add(m_posXTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
    m_posSizer->Add(m_posYTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
    m_posSizer->Add(m_posZTextCtrl, 0, wxLEFT|wxADJUST_MINSIZE, 10);
    m_panelSizer->Add(m_posSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

    m_wickSizer->Add(m_wickLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
    m_wickSizer->Add(m_wickTextCtrl, 0, wxLEFT|wxADJUST_MINSIZE, 8);
    m_wickSizer->Add(m_wickBrowseButton, 0, wxADJUST_MINSIZE, 0);
    m_panelSizer->Add(m_wickSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

    /* Flame */
    m_panelSizer->Add(m_luminaryTypeRadioBox, 0, wxADJUST_MINSIZE, 0);
    m_skeletonsNumberSizer->Add(m_skeletonsNumberLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
    m_skeletonsNumberSizer->Add(m_skeletonsNumberCtrl, 0, wxLEFT|wxADJUST_MINSIZE, 8);
    m_panelSizer->Add(m_skeletonsNumberSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);
  }
  /* Field */
  m_panelSizer->Add(m_solverTypeRadioBox, 0, wxADJUST_MINSIZE, 0);

  m_resSizer->Add(m_resLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
  m_resSizer->Add(m_resXTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
  if(m_luminary){
    m_resSizer->Add(m_resYTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
    m_resSizer->Add(m_resZTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
  }
  m_panelSizer->Add(m_resSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

  if(m_luminary){
    wxBoxSizer* m_dimSizer = new wxBoxSizer(wxHORIZONTAL);
    wxBoxSizer* m_scaleSizer = new wxBoxSizer(wxHORIZONTAL);

    m_dimSizer->Add(m_dimLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
    m_dimSizer->Add(m_dimTextCtrl, 0, wxLEFT|wxADJUST_MINSIZE, 8);
    m_panelSizer->Add(m_dimSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

    m_scaleSizer->Add(m_scaleLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
    m_scaleSizer->Add(m_scaleXTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
    m_scaleSizer->Add(m_scaleYTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
    m_scaleSizer->Add(m_scaleZTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
    m_panelSizer->Add(m_scaleSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);
  }

  m_timeStepSizer->Add(m_timeStepLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
  m_timeStepSizer->Add(m_timeStepTextCtrl, 0, wxLEFT|wxADJUST_MINSIZE, 12);
  m_panelSizer->Add(m_timeStepSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

  m_omegaDiffSizer->Add(m_omegaDiffLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
  m_omegaDiffSizer->Add(m_omegaDiffTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
  m_panelSizer->Add(m_omegaDiffSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

  m_omegaProjSizer->Add(m_omegaProjLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
  m_omegaProjSizer->Add(m_omegaProjTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
  m_panelSizer->Add(m_omegaProjSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

  m_epsilonSizer->Add(m_epsilonLabel, 0, wxLEFT|wxTOP|wxADJUST_MINSIZE, 3);
  m_epsilonSizer->Add(m_epsilonTextCtrl, 0, wxLEFT|wxRIGHT|wxADJUST_MINSIZE, 10);
  m_panelSizer->Add(m_epsilonSizer, 0, wxTOP|wxBOTTOM|wxEXPAND, 5);

  SetAutoLayout(true);
  SetSizer(m_panelSizer);
  m_panelSizer->Fit(this);
  m_panelSizer->SetSizeHints(this);
}