[wxWidgets.git] / wxPython / demo / wxTimeCtrl.py

from wxPython.wx import *
from wxPython.lib.timectrl import *
from wxPython.lib.timectrl import __doc__ as overviewdoc
from wxPython.lib.scrolledpanel import wxScrolledPanel

#----------------------------------------------------------------------

class TestPanel( wxScrolledPanel ):
    def __init__( self, parent, log ):

        wxScrolledPanel.__init__( self, parent, -1 )
        self.log = log


        text1 = wxStaticText( self, -1, "12-hour format:")
        self.time12 = wxTimeCtrl( self, -1, name="12 hour control" )
        spin1 = wxSpinButton( self, -1, wxDefaultPosition, wxSize(-1,20), 0 )
        self.time12.BindSpinButton( spin1 )

        text2 = wxStaticText( self, -1, "24-hour format:")
        spin2 = wxSpinButton( self, -1, wxDefaultPosition, wxSize(-1,20), 0 )
        self.time24 = wxTimeCtrl( self, -1, name="24 hour control", fmt24hr=True, spinButton = spin2 )

        text3 = wxStaticText( self, -1, "No seconds\nor spin button:")
        self.spinless_ctrl = wxTimeCtrl( self, -1, name="spinless control", display_seconds = False )

        grid = wxFlexGridSizer( 0, 2, 10, 5 )
        grid.Add( text1, 0, wxALIGN_RIGHT )
        hbox1 = wxBoxSizer( wxHORIZONTAL )
        hbox1.Add( self.time12, 0, wxALIGN_CENTRE )
        hbox1.Add( spin1, 0, wxALIGN_CENTRE )
        grid.Add( hbox1, 0, wxLEFT )

        grid.Add( text2, 0, wxALIGN_RIGHT|wxTOP|wxBOTTOM )
        hbox2 = wxBoxSizer( wxHORIZONTAL )
        hbox2.Add( self.time24, 0, wxALIGN_CENTRE )
        hbox2.Add( spin2, 0, wxALIGN_CENTRE )
        grid.Add( hbox2, 0, wxLEFT )

        grid.Add( text3, 0, wxALIGN_RIGHT|wxTOP|wxBOTTOM )
        grid.Add( self.spinless_ctrl, 0, wxLEFT )


        buttonChange = wxButton( self, -1, "Change Controls")
        self.radio12to24 = wxRadioButton( self, -1, "Copy 12-hour time to 24-hour control", wxDefaultPosition, wxDefaultSize, wxRB_GROUP )
        self.radio24to12 = wxRadioButton( self, -1, "Copy 24-hour time to 12-hour control")
        self.radioWx = wxRadioButton( self, -1, "Set controls to 'now' using wxDateTime")
        self.radioMx = wxRadioButton( self, -1, "Set controls to 'now' using mxDateTime")

        radio_vbox = wxBoxSizer( wxVERTICAL )
        radio_vbox.Add( self.radio12to24, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 )
        radio_vbox.Add( self.radio24to12, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 )
        radio_vbox.Add( self.radioWx, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 )
        radio_vbox.Add( self.radioMx, 0, wxALIGN_CENTER_VERTICAL|wxALL, 5 )

        box_label = wxStaticBox( self, -1, "Change Controls through API" )
        buttonbox = wxStaticBoxSizer( box_label, wxHORIZONTAL )
        buttonbox.Add( buttonChange, 0, wxALIGN_CENTRE|wxALL, 5 )
        buttonbox.Add( radio_vbox, 0, wxALIGN_CENTRE|wxALL, 5 )

        hbox = wxBoxSizer( wxHORIZONTAL )
        hbox.Add( grid, 0, wxALIGN_LEFT|wxALL, 15 )
        hbox.Add( buttonbox, 0, wxALIGN_RIGHT|wxBOTTOM, 20 )


        box_label = wxStaticBox( self, -1, "Bounds Control" )
        boundsbox = wxStaticBoxSizer( box_label, wxHORIZONTAL )
        self.set_bounds = wxCheckBox( self, -1, "Set time bounds:" )

        minlabel = wxStaticText( self, -1, "minimum time:" )
        self.min = wxTimeCtrl( self, -1, name="min", display_seconds = False )
        self.min.Enable( False )

        maxlabel = wxStaticText( self, -1, "maximum time:" )
        self.max = wxTimeCtrl( self, -1, name="max", display_seconds = False )
        self.max.Enable( False )

        self.limit_check = wxCheckBox( self, -1, "Limit control" )

        label = wxStaticText( self, -1, "Resulting time control:" )
        self.target_ctrl = wxTimeCtrl( self, -1, name="new" )

        grid2 = wxFlexGridSizer( 0, 2, 0, 0 )
        grid2.Add( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
        grid2.Add( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )

        grid2.Add( self.set_bounds, 0, wxALIGN_LEFT|wxALL, 5 )
        grid3 = wxFlexGridSizer( 0, 2, 5, 5 )
        grid3.Add(minlabel, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL )
        grid3.Add( self.min, 0, wxALIGN_LEFT )
        grid3.Add(maxlabel, 0, wxALIGN_RIGHT|wxALIGN_CENTER_VERTICAL )
        grid3.Add( self.max, 0, wxALIGN_LEFT )
        grid2.Add(grid3, 0, wxALIGN_LEFT )

        grid2.Add( self.limit_check, 0, wxALIGN_LEFT|wxALL, 5 )
        grid2.Add( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )

        grid2.Add( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
        grid2.Add( 20, 0, 0, wxALIGN_LEFT|wxALL, 5 )
        grid2.Add( label, 0, wxALIGN_LEFT|wxALIGN_CENTER_VERTICAL|wxALL, 5 )
        grid2.Add( self.target_ctrl, 0, wxALIGN_LEFT|wxALL, 5 )
        boundsbox.Add(grid2, 0, wxALIGN_CENTER|wxEXPAND|wxALL, 5)

        vbox = wxBoxSizer( wxVERTICAL )
        vbox.AddSpacer(20, 20)
        vbox.Add( hbox, 0, wxALIGN_LEFT|wxALL, 5)
        vbox.Add( boundsbox, 0, wxALIGN_LEFT|wxALL, 5 )


        outer_box = wxBoxSizer( wxVERTICAL )
        outer_box.Add( vbox, 0, wxALIGN_LEFT|wxALL, 5)


        # Turn on mxDateTime option only if we can import the module:
        try:
            from mx import DateTime
        except ImportError:
            self.radioMx.Enable( False )


        self.SetAutoLayout( True )
        self.SetSizer( outer_box )
        outer_box.Fit( self )
        self.SetupScrolling()

        EVT_BUTTON( self, buttonChange.GetId(), self.OnButtonClick )
        EVT_TIMEUPDATE( self, self.time12.GetId(), self.OnTimeChange )
        EVT_TIMEUPDATE( self, self.time24.GetId(), self.OnTimeChange )
        EVT_TIMEUPDATE( self, self.spinless_ctrl.GetId(), self.OnTimeChange )


        EVT_CHECKBOX( self, self.set_bounds.GetId(), self.OnBoundsCheck )
        EVT_CHECKBOX( self, self.limit_check.GetId(), self.SetTargetMinMax )
        EVT_TIMEUPDATE( self, self.min.GetId(), self.SetTargetMinMax )
        EVT_TIMEUPDATE( self, self.max.GetId(), self.SetTargetMinMax )
        EVT_TIMEUPDATE( self, self.target_ctrl.GetId(), self.OnTimeChange )


    def OnTimeChange( self, event ):
        timectrl = self.FindWindowById( event.GetId() )
        ib_str = [ "  (out of bounds)", "" ]

        self.log.write('%s time = %s%s\n' % ( timectrl.GetName(), timectrl.GetValue(), ib_str[ timectrl.IsInBounds() ] ) )


    def OnButtonClick( self, event ):
        if self.radio12to24.GetValue():
            self.time24.SetValue( self.time12.GetValue() )

        elif self.radio24to12.GetValue():
            self.time12.SetValue( self.time24.GetValue() )

        elif self.radioWx.GetValue():
            now = wxDateTime_Now()
            self.time12.SetValue( now )
            # (demonstrates that G/SetValue returns/takes a wxDateTime)
            self.time24.SetValue( self.time12.GetValue(as_wxDateTime=True) )

            # (demonstrates that G/SetValue returns/takes a wxTimeSpan)
            self.spinless_ctrl.SetValue( self.time12.GetValue(as_wxTimeSpan=True) )

        elif self.radioMx.GetValue():
            from mx import DateTime
            now = DateTime.now()
            self.time12.SetValue( now )

            # (demonstrates that G/SetValue returns/takes a DateTime)
            self.time24.SetValue( self.time12.GetValue(as_mxDateTime=True) )

            # (demonstrates that G/SetValue returns/takes a DateTimeDelta)
            self.spinless_ctrl.SetValue( self.time12.GetValue(as_mxDateTimeDelta=True) )


    def OnBoundsCheck( self, event ):
        self.min.Enable( self.set_bounds.GetValue() )
        self.max.Enable( self.set_bounds.GetValue() )
        self.SetTargetMinMax()


    def SetTargetMinMax( self, event=None ):
        min = max = None

        if self.set_bounds.GetValue():
            min = self.min.GetWxDateTime()
            max = self.max.GetWxDateTime()
        else:
            min, max = None, None

        cur_min, cur_max = self.target_ctrl.GetBounds()

        if min != cur_min: self.target_ctrl.SetMin( min )
        if max != cur_max: self.target_ctrl.SetMax( max )

        self.target_ctrl.SetLimited( self.limit_check.GetValue() )

        if min != cur_min or max != cur_max:
            new_min, new_max = self.target_ctrl.GetBounds()
            if new_min and new_max:
                self.log.write( "current min, max:  (%s, %s)\n" % ( new_min.FormatTime(), new_max.FormatTime() ) )
            else:
                self.log.write( "current min, max:  (None, None)\n" )

#----------------------------------------------------------------------

def runTest( frame, nb, log ):
    win = TestPanel( nb, log )
    return win

#----------------------------------------------------------------------

overview = overviewdoc

if __name__ == '__main__':
    import sys,os
    import run
    run.main(['', os.path.basename(sys.argv[0])])
Commit	Line	Data
1e4a197e RD	1	from wxPython.wx import *
1e4a197e RD	2	from wxPython.lib.timectrl import *
1fded56b RD	3	from wxPython.lib.timectrl import __doc__ as overviewdoc
1fded56b RD	4	from wxPython.lib.scrolledpanel import wxScrolledPanel
1e4a197e RD	5
	6	#----------------------------------------------------------------------
	7
1fded56b	8	class TestPanel( wxScrolledPanel ):
1e4a197e RD	9	def __init__( self, parent, log ):
1e4a197e RD	10
1fded56b	11	wxScrolledPanel.__init__( self, parent, -1 )
1e4a197e	12	self.log = log
1e4a197e	13
1e4a197e	14
1fded56b RD	15	text1 = wxStaticText( self, -1, "12-hour format:")
	16	self.time12 = wxTimeCtrl( self, -1, name="12 hour control" )
	17	spin1 = wxSpinButton( self, -1, wxDefaultPosition, wxSize(-1,20), 0 )
1e4a197e RD	18	self.time12.BindSpinButton( spin1 )
1e4a197e RD	19
1fded56b RD	20	text2 = wxStaticText( self, -1, "24-hour format:")
	21	spin2 = wxSpinButton( self, -1, wxDefaultPosition, wxSize(-1,20), 0 )
	22	self.time24 = wxTimeCtrl( self, -1, name="24 hour control", fmt24hr=True, spinButton = spin2 )
1e4a197e	23
1fded56b RD	24	text3 = wxStaticText( self, -1, "No seconds\nor spin button:")
1fded56b RD	25	self.spinless_ctrl = wxTimeCtrl( self, -1, name="spinless control", display_seconds = False )
1e4a197e	26
1fded56b RD	27	grid = wxFlexGridSizer( 0, 2, 10, 5 )
	28	grid.Add( text1, 0, wxALIGN_RIGHT )
	29	hbox1 = wxBoxSizer( wxHORIZONTAL )
	30	hbox1.Add( self.time12, 0, wxALIGN_CENTRE )
	31	hbox1.Add( spin1, 0, wxALIGN_CENTRE )
	32	grid.Add( hbox1, 0, wxLEFT )
1e4a197e	33
1fded56b	34	grid.Add( text2, 0, wxALIGN_RIGHT\|wxTOP\|wxBOTTOM )
1e4a197e	35	hbox2 = wxBoxSizer( wxHORIZONTAL )
1fded56b RD	36	hbox2.Add( self.time24, 0, wxALIGN_CENTRE )
	37	hbox2.Add( spin2, 0, wxALIGN_CENTRE )
	38	grid.Add( hbox2, 0, wxLEFT )
1e4a197e	39
1fded56b RD	40	grid.Add( text3, 0, wxALIGN_RIGHT\|wxTOP\|wxBOTTOM )
1fded56b RD	41	grid.Add( self.spinless_ctrl, 0, wxLEFT )
1e4a197e	42
1e4a197e	43
1fded56b RD	44	buttonChange = wxButton( self, -1, "Change Controls")
	45	self.radio12to24 = wxRadioButton( self, -1, "Copy 12-hour time to 24-hour control", wxDefaultPosition, wxDefaultSize, wxRB_GROUP )
	46	self.radio24to12 = wxRadioButton( self, -1, "Copy 24-hour time to 12-hour control")
	47	self.radioWx = wxRadioButton( self, -1, "Set controls to 'now' using wxDateTime")
	48	self.radioMx = wxRadioButton( self, -1, "Set controls to 'now' using mxDateTime")
1e4a197e RD	49
1e4a197e RD	50	radio_vbox = wxBoxSizer( wxVERTICAL )
1fded56b RD	51	radio_vbox.Add( self.radio12to24, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5 )
	52	radio_vbox.Add( self.radio24to12, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5 )
	53	radio_vbox.Add( self.radioWx, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5 )
	54	radio_vbox.Add( self.radioMx, 0, wxALIGN_CENTER_VERTICAL\|wxALL, 5 )
1e4a197e	55
1fded56b	56	box_label = wxStaticBox( self, -1, "Change Controls through API" )
1e4a197e	57	buttonbox = wxStaticBoxSizer( box_label, wxHORIZONTAL )
1fded56b RD	58	buttonbox.Add( buttonChange, 0, wxALIGN_CENTRE\|wxALL, 5 )
	59	buttonbox.Add( radio_vbox, 0, wxALIGN_CENTRE\|wxALL, 5 )
	60
	61	hbox = wxBoxSizer( wxHORIZONTAL )
	62	hbox.Add( grid, 0, wxALIGN_LEFT\|wxALL, 15 )
	63	hbox.Add( buttonbox, 0, wxALIGN_RIGHT\|wxBOTTOM, 20 )
	64
	65
	66	box_label = wxStaticBox( self, -1, "Bounds Control" )
	67	boundsbox = wxStaticBoxSizer( box_label, wxHORIZONTAL )
	68	self.set_bounds = wxCheckBox( self, -1, "Set time bounds:" )
	69
	70	minlabel = wxStaticText( self, -1, "minimum time:" )
	71	self.min = wxTimeCtrl( self, -1, name="min", display_seconds = False )
	72	self.min.Enable( False )
	73
	74	maxlabel = wxStaticText( self, -1, "maximum time:" )
	75	self.max = wxTimeCtrl( self, -1, name="max", display_seconds = False )
	76	self.max.Enable( False )
	77
	78	self.limit_check = wxCheckBox( self, -1, "Limit control" )
	79
	80	label = wxStaticText( self, -1, "Resulting time control:" )
	81	self.target_ctrl = wxTimeCtrl( self, -1, name="new" )
	82
	83	grid2 = wxFlexGridSizer( 0, 2, 0, 0 )
	84	grid2.Add( 20, 0, 0, wxALIGN_LEFT\|wxALL, 5 )
	85	grid2.Add( 20, 0, 0, wxALIGN_LEFT\|wxALL, 5 )
	86
	87	grid2.Add( self.set_bounds, 0, wxALIGN_LEFT\|wxALL, 5 )
	88	grid3 = wxFlexGridSizer( 0, 2, 5, 5 )
	89	grid3.Add(minlabel, 0, wxALIGN_RIGHT\|wxALIGN_CENTER_VERTICAL )
	90	grid3.Add( self.min, 0, wxALIGN_LEFT )
	91	grid3.Add(maxlabel, 0, wxALIGN_RIGHT\|wxALIGN_CENTER_VERTICAL )
	92	grid3.Add( self.max, 0, wxALIGN_LEFT )
	93	grid2.Add(grid3, 0, wxALIGN_LEFT )
	94
	95	grid2.Add( self.limit_check, 0, wxALIGN_LEFT\|wxALL, 5 )
	96	grid2.Add( 20, 0, 0, wxALIGN_LEFT\|wxALL, 5 )
	97
	98	grid2.Add( 20, 0, 0, wxALIGN_LEFT\|wxALL, 5 )
	99	grid2.Add( 20, 0, 0, wxALIGN_LEFT\|wxALL, 5 )
	100	grid2.Add( label, 0, wxALIGN_LEFT\|wxALIGN_CENTER_VERTICAL\|wxALL, 5 )
	101	grid2.Add( self.target_ctrl, 0, wxALIGN_LEFT\|wxALL, 5 )
	102	boundsbox.Add(grid2, 0, wxALIGN_CENTER\|wxEXPAND\|wxALL, 5)
	103
	104	vbox = wxBoxSizer( wxVERTICAL )
	105	vbox.AddSpacer(20, 20)
	106	vbox.Add( hbox, 0, wxALIGN_LEFT\|wxALL, 5)
	107	vbox.Add( boundsbox, 0, wxALIGN_LEFT\|wxALL, 5 )
	108
1e4a197e RD	109
1e4a197e RD	110	outer_box = wxBoxSizer( wxVERTICAL )
1fded56b	111	outer_box.Add( vbox, 0, wxALIGN_LEFT\|wxALL, 5)
1e4a197e RD	112
	113
	114	# Turn on mxDateTime option only if we can import the module:
	115	try:
	116	from mx import DateTime
	117	except ImportError:
	118	self.radioMx.Enable( False )
	119
	120
1fded56b RD	121	self.SetAutoLayout( True )
	122	self.SetSizer( outer_box )
	123	outer_box.Fit( self )
	124	self.SetupScrolling()
1e4a197e	125
1fded56b	126	EVT_BUTTON( self, buttonChange.GetId(), self.OnButtonClick )
1e4a197e RD	127	EVT_TIMEUPDATE( self, self.time12.GetId(), self.OnTimeChange )
	128	EVT_TIMEUPDATE( self, self.time24.GetId(), self.OnTimeChange )
	129	EVT_TIMEUPDATE( self, self.spinless_ctrl.GetId(), self.OnTimeChange )
	130
1fded56b RD	131
	132	EVT_CHECKBOX( self, self.set_bounds.GetId(), self.OnBoundsCheck )
	133	EVT_CHECKBOX( self, self.limit_check.GetId(), self.SetTargetMinMax )
	134	EVT_TIMEUPDATE( self, self.min.GetId(), self.SetTargetMinMax )
	135	EVT_TIMEUPDATE( self, self.max.GetId(), self.SetTargetMinMax )
	136	EVT_TIMEUPDATE( self, self.target_ctrl.GetId(), self.OnTimeChange )
	137
1e4a197e RD	138
	139
	140	def OnTimeChange( self, event ):
1fded56b RD	141	timectrl = self.FindWindowById( event.GetId() )
	142	ib_str = [ " (out of bounds)", "" ]
	143
	144	self.log.write('%s time = %s%s\n' % ( timectrl.GetName(), timectrl.GetValue(), ib_str[ timectrl.IsInBounds() ] ) )
	145
1e4a197e RD	146
	147	def OnButtonClick( self, event ):
	148	if self.radio12to24.GetValue():
	149	self.time24.SetValue( self.time12.GetValue() )
	150
	151	elif self.radio24to12.GetValue():
	152	self.time12.SetValue( self.time24.GetValue() )
	153
	154	elif self.radioWx.GetValue():
	155	now = wxDateTime_Now()
1fded56b RD	156	self.time12.SetValue( now )
	157	# (demonstrates that G/SetValue returns/takes a wxDateTime)
	158	self.time24.SetValue( self.time12.GetValue(as_wxDateTime=True) )
	159
	160	# (demonstrates that G/SetValue returns/takes a wxTimeSpan)
	161	self.spinless_ctrl.SetValue( self.time12.GetValue(as_wxTimeSpan=True) )
1e4a197e RD	162
	163	elif self.radioMx.GetValue():
	164	from mx import DateTime
	165	now = DateTime.now()
1fded56b RD	166	self.time12.SetValue( now )
	167
	168	# (demonstrates that G/SetValue returns/takes a DateTime)
	169	self.time24.SetValue( self.time12.GetValue(as_mxDateTime=True) )
	170
	171	# (demonstrates that G/SetValue returns/takes a DateTimeDelta)
	172	self.spinless_ctrl.SetValue( self.time12.GetValue(as_mxDateTimeDelta=True) )
	173
	174
	175	def OnBoundsCheck( self, event ):
	176	self.min.Enable( self.set_bounds.GetValue() )
	177	self.max.Enable( self.set_bounds.GetValue() )
	178	self.SetTargetMinMax()
	179
	180
	181	def SetTargetMinMax( self, event=None ):
	182	min = max = None
	183
	184	if self.set_bounds.GetValue():
	185	min = self.min.GetWxDateTime()
	186	max = self.max.GetWxDateTime()
	187	else:
	188	min, max = None, None
	189
	190	cur_min, cur_max = self.target_ctrl.GetBounds()
	191
	192	if min != cur_min: self.target_ctrl.SetMin( min )
	193	if max != cur_max: self.target_ctrl.SetMax( max )
	194
	195	self.target_ctrl.SetLimited( self.limit_check.GetValue() )
	196
	197	if min != cur_min or max != cur_max:
	198	new_min, new_max = self.target_ctrl.GetBounds()
	199	if new_min and new_max:
	200	self.log.write( "current min, max: (%s, %s)\n" % ( new_min.FormatTime(), new_max.FormatTime() ) )
	201	else:
	202	self.log.write( "current min, max: (None, None)\n" )
1e4a197e RD	203
	204	#----------------------------------------------------------------------
	205
	206	def runTest( frame, nb, log ):
	207	win = TestPanel( nb, log )
	208	return win
	209
	210	#----------------------------------------------------------------------
	211
1fded56b	212	overview = overviewdoc
1e4a197e RD	213
	214	if __name__ == '__main__':
	215	import sys,os
	216	import run
	217	run.main(['', os.path.basename(sys.argv[0])])
	218