How to create a calculator (Phoenix)

Keywords : Calculator, GridSizer, CustomButton.


Demonstrating :

Tested py3.x, wx4.x and Win10.

Are you ready to use some samples ? ;)

Test, modify, correct, complete, improve and share your discoveries ! (!)


Sample one

img_sample_one.png

   1 # sample_one.py
   2 
   3 """
   4 
   5 Purpose : Create a customized calculator
   6 Author  : Jan Bodnar (zetcode.com)
   7         : Modified By Ecco - May 2021
   8 Link    : https://zetcode.com/wxpython/layout/
   9 
  10 """
  11 
  12 import os
  13 import wx
  14 
  15 # class MyCalculator
  16 # class MyFrame
  17 
  18 #-------------------------------------------------------------------------------
  19 
  20 class MyCalculator(wx.Frame):
  21     def __init__(self, parent, id, title):
  22         wx.Frame.__init__(self, parent,
  23                           -1, title,
  24                           style=wx.DEFAULT_FRAME_STYLE)
  25 
  26         #------------
  27         
  28         self.parent = parent
  29         self.formula = False
  30         
  31         #------------
  32         
  33         # Simplified init method
  34         self.SetProperties()
  35         self.CreateCtrls()
  36         self.MakeMenuBar()
  37         self.BindEvents()
  38         self.DoLayout()        
  39 
  40         #------------
  41 
  42         self.CenterOnParent()
  43         self.GetParent().Enable(False)
  44         self.Show(True)
  45 
  46         self.__eventLoop = wx.GUIEventLoop()
  47         self.__eventLoop.Run()
  48         
  49     #---------------------------------------------------------------------------
  50 
  51     def SetProperties(self):
  52         """
  53         Set the dialog properties (title, icon...).
  54         """
  55 
  56         # Set frame icon. 
  57         self.SetIcon(wx.Icon('icons/wxwin.ico'))
  58         self.SetSize((420, 300))
  59         self.SetMinSize((430, 310))
  60 
  61 
  62     def MakeMenuBar(self):
  63         """
  64         Make menu data.
  65         """
  66 
  67         menubar = wx.MenuBar()
  68 
  69         #------------
  70         
  71         menuFile = wx.Menu()
  72 
  73         #------------
  74 
  75         # Add a bitmap to "exitItem" menu.
  76         bmp = wx.Bitmap("bitmaps/item_quit.png", wx.BITMAP_TYPE_PNG)     
  77 
  78         exitItem = wx.MenuItem(parentMenu=menuFile,
  79                                id=22,
  80                                text="&Quit\tCtrl+Q",
  81                                helpString="Exit Calculator.",
  82                                kind=wx.ITEM_NORMAL,
  83                                subMenu=None)
  84         exitItem.SetBitmap(bmp)
  85         menuFile.Append(exitItem)
  86         
  87         #------------
  88         
  89         menubar.Append(menuFile, '&File')
  90 
  91         #------------
  92         
  93         self.SetMenuBar(menubar)
  94 
  95         
  96     def CreateCtrls(self):
  97         """
  98         ...    
  99         """
 100 
 101         # wx.Font(pointSize, family, style, weight, underline, faceName)
 102         font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
 103         font.SetWeight(wx.BOLD)
 104 
 105         #------------
 106         
 107         self.panel = wx.Panel(self, -1)
 108         
 109         self.display = wx.TextCtrl(self.panel,
 110                                    -1, '',
 111                                    style=wx.TE_RIGHT)
 112         self.display.SetBackgroundColour("#fded68") 
 113         self.display.SetForegroundColour("#0326f9")
 114         self.display.SetFocus()
 115         
 116         #------------
 117 
 118         self.btn1 = wx.Button(self.panel, 20, 'Clr')
 119         self.btn2 = wx.Button(self.panel, 21, 'Bck')
 120         self.txt3 = wx.StaticText(self.panel, -1, '')
 121         self.btn4 = wx.Button(self.panel, 22, '&Close')
 122         self.btn5 = wx.Button(self.panel, 1, '7')
 123         self.btn6 = wx.Button(self.panel, 2, '8')
 124         self.btn7 = wx.Button(self.panel, 3, '9')
 125         self.btn8 = wx.Button(self.panel, 4, '/')
 126         self.btn9 = wx.Button(self.panel, 5, '4')
 127         self.btn10 = wx.Button(self.panel, 6, '5')
 128         self.btn11 = wx.Button(self.panel, 7, '6')
 129         self.btn12 = wx.Button(self.panel, 8, '*')
 130         self.btn13 = wx.Button(self.panel, 9, '1')
 131         self.btn14 = wx.Button(self.panel, 10, '2')
 132         self.btn15 = wx.Button(self.panel, 11, '3')
 133         self.btn16 = wx.Button(self.panel, 12, '-')
 134         self.btn17 = wx.Button(self.panel, 13, '0')
 135         self.btn18 = wx.Button(self.panel, 14, '.')
 136         self.btn19 = wx.Button(self.panel, 15, '=')
 137         self.btn20 = wx.Button(self.panel, 16, '+')
 138 
 139         self.btn1.SetForegroundColour("#008B00")
 140         self.btn4.SetForegroundColour("red")
 141         self.btn5.SetForegroundColour("blue")
 142         self.btn6.SetForegroundColour("blue")
 143         self.btn7.SetForegroundColour("blue")
 144         self.btn8.SetForegroundColour("blue")
 145         self.btn9.SetForegroundColour("blue")
 146         self.btn10.SetForegroundColour("blue")
 147         self.btn11.SetForegroundColour("blue")
 148         self.btn12.SetForegroundColour("blue")
 149         self.btn13.SetForegroundColour("blue")
 150         self.btn14.SetForegroundColour("blue")
 151         self.btn15.SetForegroundColour("blue")
 152         self.btn16.SetForegroundColour("blue")
 153         self.btn17.SetForegroundColour("blue")
 154         self.btn18.SetForegroundColour("blue")
 155         self.btn20.SetForegroundColour("blue")
 156 
 157         self.panel.SetBackgroundColour("#cce8f2")        
 158         
 159         self.btn1.SetFont(font)
 160         self.btn2.SetFont(font)
 161         self.btn4.SetFont(font)
 162         self.btn19.SetFont(font)
 163         
 164         self.btn19.SetDefault()
 165         
 166 
 167     def BindEvents(self):
 168         """
 169         ...  
 170         """
 171         
 172         self.Bind(wx.EVT_BUTTON, self.OnClear, id=20)
 173         self.Bind(wx.EVT_BUTTON, self.OnBackspace, id=21)
 174         self.Bind(wx.EVT_BUTTON, self.OnClose, id=22)
 175         self.Bind(wx.EVT_BUTTON, self.OnSeven, id=1)
 176         self.Bind(wx.EVT_BUTTON, self.OnEight, id=2)
 177         self.Bind(wx.EVT_BUTTON, self.OnNine, id=3)
 178         self.Bind(wx.EVT_BUTTON, self.OnDivide, id=4)
 179         self.Bind(wx.EVT_BUTTON, self.OnFour, id=5)
 180         self.Bind(wx.EVT_BUTTON, self.OnFive, id=6)
 181         self.Bind(wx.EVT_BUTTON, self.OnSix, id=7)
 182         self.Bind(wx.EVT_BUTTON, self.OnMultiply, id=8)
 183         self.Bind(wx.EVT_BUTTON, self.OnOne, id=9)
 184         self.Bind(wx.EVT_BUTTON, self.OnTwo, id=10)
 185         self.Bind(wx.EVT_BUTTON, self.OnThree, id=11)
 186         self.Bind(wx.EVT_BUTTON, self.OnMinus, id=12)
 187         self.Bind(wx.EVT_BUTTON, self.OnZero, id=13)
 188         self.Bind(wx.EVT_BUTTON, self.OnDot, id=14)
 189         self.Bind(wx.EVT_BUTTON, self.OnEqual, id=15)
 190         self.Bind(wx.EVT_BUTTON, self.OnPlus, id=16)
 191 
 192         self.Bind(wx.EVT_MENU, self.OnClose, id=22)
 193 
 194         self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUp)
 195         
 196         # (Allows frame's title-bar close to work)
 197         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) 
 198         
 199 
 200     def DoLayout(self):
 201         """
 202         ...    
 203         """
 204 
 205         # Sizers         
 206         # MainSizer is the top-level one that manages everything   
 207         mainSizer = wx.BoxSizer(wx.VERTICAL)
 208         gridSizer = wx.GridSizer(5, 4, 5, 5)
 209 
 210         #------------
 211 
 212         # Assign widgets to sizers
 213         mainSizer.Add(self.display, 0, wx.EXPAND | wx.ALL, 5)
 214 
 215         gridSizer.AddMany([(self.btn1, 1, wx.EXPAND),
 216                            (self.btn2, 1, wx.EXPAND),
 217                            (self.txt3, 1, wx.EXPAND),
 218                            (self.btn4, 1, wx.EXPAND),
 219                            (self.btn5, 1, wx.EXPAND),
 220                            (self.btn6, 1, wx.EXPAND),
 221                            (self.btn7, 1, wx.EXPAND),
 222                            (self.btn8, 1, wx.EXPAND),
 223                            (self.btn9, 1, wx.EXPAND),
 224                            (self.btn10, 1, wx.EXPAND),
 225                            (self.btn11, 1, wx.EXPAND),
 226                            (self.btn12, 1, wx.EXPAND),
 227                            (self.btn13, 1, wx.EXPAND),
 228                            (self.btn14, 1, wx.EXPAND),
 229                            (self.btn15, 1, wx.EXPAND),
 230                            (self.btn16, 1, wx.EXPAND),
 231                            (self.btn17, 1, wx.EXPAND),
 232                            (self.btn18, 1, wx.EXPAND),
 233                            (self.btn19, 1, wx.EXPAND),
 234                            (self.btn20, 1, wx.EXPAND)])
 235 
 236         # Assign to mainSizer the other sizers
 237         mainSizer.Add(gridSizer, 1, wx.EXPAND | wx.ALL, 5)
 238 
 239         #------------
 240         
 241         self.panel.SetSizer(mainSizer)
 242         mainSizer.Fit(self)
 243 
 244 
 245     def OnClear(self, event):
 246         """
 247         ...    
 248         """
 249                 
 250         self.display.Clear()
 251         self.display.SetFocus()
 252         
 253 
 254     def OnBackspace(self, event):
 255         """
 256         ...    
 257         """
 258         
 259         formula = self.display.GetValue()
 260         self.display.Clear()
 261         self.display.SetValue(formula[:-1])
 262         self.display.SetFocus()
 263         
 264 
 265     def OnDivide(self, event):
 266         """
 267         ...    
 268         """
 269         
 270         if self.formula:
 271             return
 272         self.display.AppendText('*')
 273         self.display.SetFocus()
 274         
 275 
 276     def OnMultiply(self, event):
 277         """
 278         ...    
 279         """
 280         
 281         if self.formula:
 282             return
 283         self.display.AppendText('*')
 284         self.display.SetFocus()
 285         
 286 
 287     def OnMinus(self, event):
 288         """
 289         ...    
 290         """
 291         
 292         if self.formula:
 293             return
 294         self.display.AppendText('-')
 295         self.display.SetFocus()
 296         
 297 
 298     def OnPlus(self, event):
 299         """
 300         ...    
 301         """
 302         
 303         if self.formula:
 304             return
 305         self.display.AppendText('+')
 306         self.display.SetFocus()
 307         
 308 
 309     def OnDot(self, event):
 310         """
 311         ...    
 312         """
 313         
 314         if self.formula:
 315             return
 316         self.display.AppendText('.')
 317         self.display.SetFocus()
 318         
 319 
 320     def OnEqual(self, event):
 321         """
 322         ...    
 323         """
 324         
 325         if self.formula:
 326             return
 327         formula = self.display.GetValue()
 328         self.formula = False
 329         try:
 330             self.display.Clear()
 331             output = eval(formula)
 332             self.display.AppendText(str(output))
 333         except StandardError:
 334             self.display.AppendText("Error")
 335             self.display.SetFocus()
 336 
 337     def OnZero(self, event):
 338         """
 339         ...    
 340         """
 341         
 342         if self.formula:
 343             self.display.Clear()
 344             self.formula = False
 345         self.display.AppendText('0')
 346         self.display.SetFocus()
 347         
 348 
 349     def OnOne(self, event):
 350         """
 351         ...    
 352         """
 353         
 354         if self.formula:
 355             self.display.Clear()
 356             self.formula = False
 357         self.display.AppendText('1')
 358         self.display.SetFocus()
 359         
 360 
 361     def OnTwo(self, event):
 362         """
 363         ...    
 364         """
 365         
 366         if self.formula:
 367             self.display.Clear()
 368             self.formula = False
 369         self.display.AppendText('2')
 370         self.display.SetFocus()
 371         
 372 
 373     def OnThree(self, event):
 374         """
 375         ...    
 376         """
 377         
 378         if self.formula:
 379             self.display.Clear()
 380             self.formula = False
 381         self.display.AppendText('3')
 382         self.display.SetFocus()
 383         
 384 
 385     def OnFour(self, event):
 386         """
 387         ...    
 388         """
 389         
 390         if self.formula:
 391             self.display.Clear()
 392             self.formula = False
 393         self.display.AppendText('4')
 394         self.display.SetFocus()
 395         
 396 
 397     def OnFive(self, event):
 398         """
 399         ...    
 400         """
 401         
 402         if self.formula:
 403             self.display.Clear()
 404             self.formula = False
 405         self.display.AppendText('5')
 406         self.display.SetFocus()
 407         
 408 
 409     def OnSix(self, event):
 410         """
 411         ...    
 412         """
 413         
 414         if self.formula:
 415             self.display.Clear()
 416             self.formula = False
 417         self.display.AppendText('6')
 418         self.display.SetFocus()
 419         
 420 
 421     def OnSeven(self, event):
 422         """
 423         ...    
 424         """
 425         
 426         if self.formula:
 427             self.display.Clear()
 428             self.formula = False
 429         self.display.AppendText('7')
 430         self.display.SetFocus()
 431         
 432 
 433     def OnEight(self, event):
 434         """
 435         ...    
 436         """
 437         
 438         if self.formula:
 439             self.display.Clear()
 440             self.formula = False
 441         self.display.AppendText('8')
 442         self.display.SetFocus()
 443         
 444 
 445     def OnNine(self, event):
 446         """
 447         ...    
 448         """
 449         
 450         if self.formula:
 451             self.display.Clear()
 452             self.formula = False
 453         self.display.AppendText('9')
 454         self.display.SetFocus()
 455         
 456 
 457     def OnKeyUp(self, event):
 458         """
 459         Handles the wx.EVT_CHAR_HOOK event for the dialog.
 460         """
 461 
 462         if event.GetKeyCode() == wx.WXK_ESCAPE:
 463             # Close the dialog, no action
 464             self.OnClose(event)
 465 
 466         event.Skip()
 467 
 468         
 469     def OnClose(self, event):
 470         """
 471         ...    
 472         """
 473         
 474         self.Close()
 475 
 476         
 477     def OnCloseWindow(self, event):
 478         """
 479         ...    
 480         """
 481         
 482         self.GetParent().Enable(True)
 483         self.__eventLoop.Exit()
 484         self.Destroy()
 485 
 486 #-------------------------------------------------------------------------------
 487 
 488 class MyFrame(wx.Frame):
 489     def __init__(self):
 490         super(MyFrame, self).__init__(None,
 491                                       -1,
 492                                       title="")
 493 
 494         #------------
 495 
 496         # Simplified init method.
 497         self.SetProperties()
 498         self.CreateCtrls()
 499         self.BindEvents()
 500         self.DoLayout()
 501 
 502         #------------
 503 
 504         self.CenterOnScreen()
 505 
 506     #-----------------------------------------------------------------------
 507 
 508     def SetProperties(self):
 509         """
 510         ...
 511         """
 512 
 513         self.SetTitle("Sample one")
 514         self.SetIcon(wx.Icon('icons/wxwin.ico'))
 515 
 516 
 517     def CreateCtrls(self):
 518         """
 519         ...
 520         """
 521 
 522         self.panel = wx.Panel(self, -1)
 523 
 524         self.btnDlg = wx.Button(self.panel,
 525                                 -1,
 526                                 "&Show customized calculator frame")
 527 
 528         self.btnClose = wx.Button(self.panel,
 529                                   -1,
 530                                   "&Close")
 531 
 532 
 533     def BindEvents(self):
 534         """
 535         Bind some events to an events handler.
 536         """
 537 
 538         # Bind the buttons event to an event handler.
 539         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 540 
 541         self.Bind(wx.EVT_BUTTON, self.OnThanksDlg, self.btnDlg)
 542         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
 543 
 544 
 545     def DoLayout(self):
 546         """
 547         ...
 548         """
 549 
 550         # mainSizer is the top-level one that manages everything.
 551         mainSizer = wx.BoxSizer(wx.VERTICAL)
 552 
 553         # wx.BoxSizer(window, proportion, flag, border)
 554         # wx.BoxSizer(sizer, proportion, flag, border)
 555         mainSizer.Add(self.btnDlg, 1, wx.EXPAND | wx.ALL, 10)
 556         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 557 
 558         # Finally, tell the panel to use the sizer for layout.
 559         self.panel.SetAutoLayout(True)
 560         self.panel.SetSizer(mainSizer)
 561 
 562         mainSizer.Fit(self.panel)
 563 
 564 
 565     def OnCloseMe(self, event):
 566         """
 567         ...
 568         """
 569 
 570         self.Close(True)
 571 
 572 
 573     def OnThanksDlg(self, event):
 574         """
 575         ...
 576         """
 577 
 578         frame = MyCalculator(self, -1, 'Calculator')
 579         
 580 
 581     def OnCloseWindow(self, event):
 582         """
 583         ...
 584         """
 585 
 586         self.Destroy()
 587 
 588 #-------------------------------------------------------------------------------
 589 
 590 class MyApp(wx.App):
 591     """
 592     ...
 593     """
 594     def OnInit(self):
 595 
 596         #------------
 597 
 598         frame = MyFrame()
 599         self.SetTopWindow(frame)
 600         frame.Show(True)
 601 
 602         return True
 603 
 604 #---------------------------------------------------------------------------
 605 
 606 def main():
 607     app = MyApp(False)
 608     app.MainLoop()
 609 
 610 #---------------------------------------------------------------------------
 611 
 612 if __name__ == "__main__" :
 613     main()


Sample two

img_sample_two.png

   1 # sample_two.py
   2 
   3 """
   4 
   5 Purpose  : Create a customized calculator
   6 Author   : Jan Bodnar (zetcode.com)
   7          : Modified By Ecco - May 2021
   8 Thank to : Daniel Ramos (custom_button)
   9 Link     : https://zetcode.com/wxpython/layout/
  10 
  11 """
  12 
  13 import os
  14 import sys
  15 import wx
  16 from   custom_button import CustomButton as CustomBtn
  17 
  18 # class MyCalculator
  19 # class MyFrame
  20 
  21 #-------------------------------------------------------------------------------
  22 
  23 class MyCalculator(wx.Frame):
  24     def __init__(self, parent, id, title):
  25         wx.Frame.__init__(self, parent,
  26                           -1, title,
  27                           style=wx.DEFAULT_FRAME_STYLE)
  28 
  29         #------------
  30        
  31         if wx.Platform == "__WXMSW__":
  32             self.SetDoubleBuffered(True)
  33         
  34         #------------
  35             
  36         self.parent = parent
  37         self.formula = False
  38         
  39         #------------
  40 
  41         # Return icons folder.
  42         self.icon_dir = wx.GetApp().GetIconDir()
  43         # Return bitmaps folder. 
  44         self.bitmap_dir = wx.GetApp().GetBitmapDir()
  45         
  46         #------------
  47         
  48         # Simplified init method
  49         self.SetProperties()
  50         self.CreateCtrls()
  51         self.MakeMenuBar()
  52         self.BindEvents()
  53         self.DoLayout()        
  54 
  55         #------------
  56 
  57         self.CenterOnParent()
  58         self.GetParent().Enable(False)
  59         self.Show(True)
  60 
  61         self.__eventLoop = wx.GUIEventLoop()
  62         self.__eventLoop.Run()
  63         
  64     #---------------------------------------------------------------------------
  65 
  66     def SetProperties(self):
  67         """
  68         Set the dialog properties (title, icon...).
  69         """
  70 
  71         # Set frame icon. 
  72         frameicon = wx.Icon(os.path.join(self.icon_dir,
  73                                          "wxwin.ico"),
  74                             type=wx.BITMAP_TYPE_ICO)
  75 
  76         self.SetIcon(frameicon)
  77         self.SetSize((420, 300))
  78         self.SetMinSize((430, 310))
  79         
  80 
  81     def MakeMenuBar(self):
  82         """
  83         Make menu data.
  84         """
  85 
  86         menubar = wx.MenuBar()
  87 
  88         #------------
  89         
  90         menuFile = wx.Menu()
  91 
  92         #------------
  93 
  94         # Add a bitmap to "exitItem" menu.
  95         bmp = wx.Bitmap(os.path.join(self.bitmap_dir,
  96                                      "item_quit.png"),
  97                         type=wx.BITMAP_TYPE_PNG)     
  98 
  99         exitItem = wx.MenuItem(parentMenu=menuFile, 
 100                                id=22,
 101                                text="&Quit\tCtrl+Q",
 102                                helpString="Exit Calculator.",
 103                                kind=wx.ITEM_NORMAL,
 104                                subMenu=None)
 105         exitItem.SetBitmap(bmp)
 106         menuFile.Append(exitItem)
 107         
 108         #------------
 109         
 110         menubar.Append(menuFile, '&File')
 111 
 112         #------------
 113         
 114         self.SetMenuBar(menubar)
 115 
 116         
 117     def CreateCtrls(self):
 118         """
 119         ...    
 120         """
 121         
 122         self.panel = wx.Panel(self, -1)
 123 
 124         #------------
 125         
 126         self.display = wx.TextCtrl(self.panel, -1,
 127                                    "",
 128                                    style=wx.TE_RIGHT|
 129                                          wx.TE_PROCESS_ENTER)
 130         self.display.SetBackgroundColour("#fded68") 
 131         self.display.SetForegroundColour("#0326f9") 
 132         self.display.SetFocus()
 133         
 134         #------------
 135         
 136         self.btn1 = CustomBtn(self.panel, 20, 'Clr')
 137         self.btn1.set_font(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.BOLD, 0, ""))
 138         self.btn1.set_foreground_color('#008B00')
 139         self.btn1.set_text_shadow((1, 1, '#ffffff'))
 140         self.btn1.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 141         self.btn1.set_border((1, '#3076A9', 3))
 142         self.btn1.set_padding((5, 10, 5, 10))
 143         self.btn1.center_content(True)
 144         
 145         self.btn2 = CustomBtn(self.panel, 21, 'Bck')
 146         self.btn2.set_font(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.BOLD, 0, ""))
 147         self.btn2.set_foreground_color('#0e4e0e')
 148         self.btn2.set_text_shadow((1, 1, '#ffffff'))
 149         self.btn2.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 150         self.btn2.set_border((1, '#3076A9', 3))
 151         self.btn2.set_padding((5, 10, 5, 10))
 152         self.btn2.center_content(True)
 153 
 154         self.txt3 = wx.StaticText(self.panel, -1, '')
 155 
 156         self.btn4 = CustomBtn(self.panel, 22, 'Close')
 157         self.btn4.set_font(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.BOLD, 0, ""))
 158         self.btn4.set_foreground_color('red')
 159         self.btn4.set_text_shadow((1, 1, '#ffffff'))
 160         self.btn4.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 161         self.btn4.set_border((1, '#3076A9', 3))
 162         self.btn4.set_padding((5, 10, 5, 10))
 163         self.btn4.center_content(True)
 164 
 165         self.btn5 = CustomBtn(self.panel, 1, '7')
 166         self.btn5.set_foreground_color('#000000')
 167         self.btn5.set_text_shadow((1, 1, '#ffffff'))
 168         self.btn5.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 169         self.btn5.set_border((1, '#3076A9', 3))
 170         self.btn5.set_padding((5, 10, 5, 10))
 171         self.btn5.center_content(True)
 172 
 173         self.btn6 = CustomBtn(self.panel, 2, '8')
 174         self.btn6.set_foreground_color('#000000')
 175         self.btn6.set_text_shadow((1, 1, '#ffffff'))
 176         self.btn6.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 177         self.btn6.set_border((1, '#3076A9', 3))
 178         self.btn6.set_padding((5, 10, 5, 10))
 179         self.btn6.center_content(True)
 180 
 181         self.btn7 = CustomBtn(self.panel, 3, '9')
 182         self.btn7.set_foreground_color('#000000')
 183         self.btn7.set_text_shadow((1, 1, '#ffffff'))
 184         self.btn7.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 185         self.btn7.set_border((1, '#3076A9', 3))
 186         self.btn7.set_padding((5, 10, 5, 10))
 187         self.btn7.center_content(True)
 188         
 189         self.btn8 = CustomBtn(self.panel, 4, '/')
 190         self.btn8.set_foreground_color('#000000')
 191         self.btn8.set_text_shadow((1, 1, '#ffffff'))
 192         self.btn8.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 193         self.btn8.set_border((1, '#3076A9', 3))
 194         self.btn8.set_padding((5, 10, 5, 10))
 195         self.btn8.center_content(True)
 196         
 197         self.btn9 = CustomBtn(self.panel, 5, '4')
 198         self.btn9.set_foreground_color('#000000')
 199         self.btn9.set_text_shadow((1, 1, '#ffffff'))
 200         self.btn9.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 201         self.btn9.set_border((1, '#3076A9', 3))
 202         self.btn9.set_padding((5, 10, 5, 10))
 203         self.btn9.center_content(True)
 204         
 205         self.btn10 = CustomBtn(self.panel, 6, '5')
 206         self.btn10.set_foreground_color('#000000')
 207         self.btn10.set_text_shadow((1, 1, '#ffffff'))
 208         self.btn10.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 209         self.btn10.set_border((1, '#3076A9', 3))
 210         self.btn10.set_padding((5, 10, 5, 10))
 211         self.btn10.center_content(True)
 212         
 213         self.btn11 = CustomBtn(self.panel, 7, '6')
 214         self.btn11.set_foreground_color('#000000')
 215         self.btn11.set_text_shadow((1, 1, '#ffffff'))
 216         self.btn11.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 217         self.btn11.set_border((1, '#3076A9', 3))
 218         self.btn11.set_padding((5, 10, 5, 10))
 219         self.btn11.center_content(True)
 220         
 221         self.btn12 = CustomBtn(self.panel, 8, '*')
 222         self.btn12.set_foreground_color('#000000')
 223         self.btn12.set_text_shadow((1, 1, '#ffffff'))
 224         self.btn12.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 225         self.btn12.set_border((1, '#3076A9', 3))
 226         self.btn12.set_padding((5, 10, 5, 10))
 227         self.btn12.center_content(True)
 228         
 229         self.btn13 = CustomBtn(self.panel, 9, '1')
 230         self.btn13.set_foreground_color('#000000')
 231         self.btn13.set_text_shadow((1, 1, '#ffffff'))
 232         self.btn13.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 233         self.btn13.set_border((1, '#3076A9', 3))
 234         self.btn13.set_padding((5, 10, 5, 10))
 235         self.btn13.center_content(True)
 236         
 237         self.btn14 = CustomBtn(self.panel, 10, '2')
 238         self.btn14.set_foreground_color('#000000')
 239         self.btn14.set_text_shadow((1, 1, '#ffffff'))
 240         self.btn14.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 241         self.btn14.set_border((1, '#3076A9', 3))
 242         self.btn14.set_padding((5, 10, 5, 10))
 243         self.btn14.center_content(True)
 244         
 245         self.btn15 = CustomBtn(self.panel, 11, '3')
 246         self.btn15.set_foreground_color('#000000')
 247         self.btn15.set_text_shadow((1, 1, '#ffffff'))
 248         self.btn15.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 249         self.btn15.set_border((1, '#3076A9', 3))
 250         self.btn15.set_padding((5, 10, 5, 10))
 251         self.btn15.center_content(True)
 252         
 253         self.btn16 = CustomBtn(self.panel, 12, '-')
 254         self.btn16.set_foreground_color('#000000')
 255         self.btn16.set_text_shadow((1, 1, '#ffffff'))
 256         self.btn16.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 257         self.btn16.set_border((1, '#3076A9', 3))
 258         self.btn16.set_padding((5, 10, 5, 10))
 259         self.btn16.center_content(True)
 260         
 261         self.btn17 = CustomBtn(self.panel, 13, '0')
 262         self.btn17.set_foreground_color('#000000')
 263         self.btn17.set_text_shadow((1, 1, '#ffffff'))
 264         self.btn17.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 265         self.btn17.set_border((1, '#3076A9', 3))
 266         self.btn17.set_padding((5, 10, 5, 10))
 267         self.btn17.center_content(True)
 268 
 269         self.btn18 = CustomBtn(self.panel, 14, '.')
 270         self.btn18.set_foreground_color('#000000')
 271         self.btn18.set_text_shadow((1, 1, '#ffffff'))
 272         self.btn18.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 273         self.btn18.set_border((1, '#3076A9', 3))
 274         self.btn18.set_padding((5, 10, 5, 10))
 275         self.btn18.center_content(True)
 276         
 277         self.btn19 = CustomBtn(self.panel, 15, '=')
 278         self.btn19.set_foreground_color('#000000')
 279         self.btn19.set_text_shadow((1, 1, '#ffffff'))
 280         self.btn19.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 281         self.btn19.set_border((1, '#3076A9', 3))
 282         self.btn19.set_padding((5, 10, 5, 10))
 283         self.btn19.center_content(True)
 284         
 285         self.btn20 = CustomBtn(self.panel, 16, '+')
 286         self.btn20.set_foreground_color('#000000')
 287         self.btn20.set_text_shadow((1, 1, '#ffffff'))
 288         self.btn20.set_bg_gradient(('#CEE3F2', '#438FC9'), ('#ABCEE9', '#3279AD'))
 289         self.btn20.set_border((1, '#3076A9', 3))
 290         self.btn20.set_padding((5, 10, 5, 10))
 291         self.btn20.center_content(True)
 292 
 293         self.panel.SetBackgroundColour("#cce8f2")        
 294         
 295 
 296     def BindEvents(self):
 297         """
 298         ...  
 299         """
 300 
 301         self.display.Bind(wx.EVT_TEXT_ENTER, self.OnTextEnter)
 302         
 303         self.Bind(wx.EVT_BUTTON, self.OnClear, id=20)
 304         self.Bind(wx.EVT_BUTTON, self.OnBackspace, id=21)
 305         self.Bind(wx.EVT_BUTTON, self.OnClose, id=22)
 306         self.Bind(wx.EVT_BUTTON, self.OnSeven, id=1)
 307         self.Bind(wx.EVT_BUTTON, self.OnEight, id=2)
 308         self.Bind(wx.EVT_BUTTON, self.OnNine, id=3)
 309         self.Bind(wx.EVT_BUTTON, self.OnDivide, id=4)
 310         self.Bind(wx.EVT_BUTTON, self.OnFour, id=5)
 311         self.Bind(wx.EVT_BUTTON, self.OnFive, id=6)
 312         self.Bind(wx.EVT_BUTTON, self.OnSix, id=7)
 313         self.Bind(wx.EVT_BUTTON, self.OnMultiply, id=8)
 314         self.Bind(wx.EVT_BUTTON, self.OnOne, id=9)
 315         self.Bind(wx.EVT_BUTTON, self.OnTwo, id=10)
 316         self.Bind(wx.EVT_BUTTON, self.OnThree, id=11)
 317         self.Bind(wx.EVT_BUTTON, self.OnMinus, id=12)
 318         self.Bind(wx.EVT_BUTTON, self.OnZero, id=13)
 319         self.Bind(wx.EVT_BUTTON, self.OnDot, id=14)
 320         self.Bind(wx.EVT_BUTTON, self.OnEqual, id=15)
 321         self.Bind(wx.EVT_BUTTON, self.OnPlus, id=16)
 322 
 323         self.Bind(wx.EVT_MENU, self.OnClose, id=22)
 324 
 325         self.Bind(wx.EVT_CHAR_HOOK, self.OnKeyUp)
 326         
 327         # (Allows frame's title-bar close to work)
 328         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow) 
 329         
 330 
 331     def DoLayout(self):
 332         """
 333         ...    
 334         """
 335 
 336         # Sizers         
 337         # MainSizer is the top-level one that manages everything   
 338         mainSizer = wx.BoxSizer(wx.VERTICAL)
 339         gridSizer = wx.GridSizer(5, 4, 5, 5)
 340 
 341         #------------
 342 
 343         # Assign widgets to sizers 
 344         mainSizer.Add(self.display, 0, wx.EXPAND | wx.ALL, 5)
 345 
 346         gridSizer.AddMany([(self.btn1, 1, wx.EXPAND),
 347                            (self.btn2, 1, wx.EXPAND),
 348                            (self.txt3, 1, wx.EXPAND),
 349                            (self.btn4, 1, wx.EXPAND),
 350                            (self.btn5, 1, wx.EXPAND),
 351                            (self.btn6, 1, wx.EXPAND),
 352                            (self.btn7, 1, wx.EXPAND),
 353                            (self.btn8, 1, wx.EXPAND),
 354                            (self.btn9, 1, wx.EXPAND),
 355                            (self.btn10, 1, wx.EXPAND),
 356                            (self.btn11, 1, wx.EXPAND),
 357                            (self.btn12, 1, wx.EXPAND),
 358                            (self.btn13, 1, wx.EXPAND),
 359                            (self.btn14, 1, wx.EXPAND),
 360                            (self.btn15, 1, wx.EXPAND),
 361                            (self.btn16, 1, wx.EXPAND),
 362                            (self.btn17, 1, wx.EXPAND),
 363                            (self.btn18, 1, wx.EXPAND),
 364                            (self.btn19, 1, wx.EXPAND),
 365                            (self.btn20, 1, wx.EXPAND)])
 366 
 367         # Assign to mainSizer the other sizers
 368         mainSizer.Add(gridSizer, 1, wx.EXPAND | wx.ALL, 5)
 369 
 370         #------------
 371         
 372         self.panel.SetSizer(mainSizer)
 373         mainSizer.Fit(self)
 374         
 375 
 376     def OnTextEnter(self, event):
 377         """
 378         ...    
 379         """
 380 
 381         self.OnEqual(event)
 382         
 383 
 384     def OnClear(self, event):
 385         """
 386         ...    
 387         """
 388                 
 389         self.display.Clear()
 390         self.display.SetFocus()
 391         
 392 
 393     def OnBackspace(self, event):
 394         """
 395         ...    
 396         """
 397         
 398         formula = self.display.GetValue()
 399         self.display.Clear()
 400         self.display.SetValue(formula[:-1])
 401         self.display.SetFocus()
 402         
 403 
 404     def OnDivide(self, event):
 405         """
 406         ...    
 407         """
 408         
 409         if self.formula:
 410             return
 411         self.display.AppendText('*')
 412         self.display.SetFocus()
 413         
 414 
 415     def OnMultiply(self, event):
 416         """
 417         ...    
 418         """
 419         
 420         if self.formula:
 421             return
 422         self.display.AppendText('*')
 423         self.display.SetFocus()
 424         
 425 
 426     def OnMinus(self, event):
 427         """
 428         ...    
 429         """
 430         
 431         if self.formula:
 432             return
 433         self.display.AppendText('-')
 434         self.display.SetFocus()
 435         
 436 
 437     def OnPlus(self, event):
 438         """
 439         ...    
 440         """
 441         
 442         if self.formula:
 443             return
 444         self.display.AppendText('+')
 445         self.display.SetFocus()
 446         
 447 
 448     def OnDot(self, event):
 449         """
 450         ...    
 451         """
 452         
 453         if self.formula:
 454             return
 455         self.display.AppendText('.')
 456         self.display.SetFocus()
 457         
 458 
 459     def OnEqual(self, event):
 460         """
 461         ...    
 462         """
 463         
 464         if self.formula:
 465             return
 466         formula = self.display.GetValue()
 467         self.formula = False
 468 
 469         self.display.Clear()
 470         output = eval(formula)
 471         self.display.AppendText(str(output))
 472         self.display.SetFocus()
 473 
 474 
 475     def OnZero(self, event):
 476         """
 477         ...    
 478         """
 479         
 480         if self.formula:
 481             self.display.Clear()
 482             self.formula = False
 483         self.display.AppendText('0')
 484         self.display.SetFocus()
 485         
 486 
 487     def OnOne(self, event):
 488         """
 489         ...    
 490         """
 491         
 492         if self.formula:
 493             self.display.Clear()
 494             self.formula = False
 495         self.display.AppendText('1')
 496         self.display.SetFocus()
 497         
 498 
 499     def OnTwo(self, event):
 500         """
 501         ...    
 502         """
 503         
 504         if self.formula:
 505             self.display.Clear()
 506             self.formula = False
 507         self.display.AppendText('2')
 508         self.display.SetFocus()
 509         
 510 
 511     def OnThree(self, event):
 512         """
 513         ...    
 514         """
 515         
 516         if self.formula:
 517             self.display.Clear()
 518             self.formula = False
 519         self.display.AppendText('3')
 520         self.display.SetFocus()
 521         
 522 
 523     def OnFour(self, event):
 524         """
 525         ...    
 526         """
 527         
 528         if self.formula:
 529             self.display.Clear()
 530             self.formula = False
 531         self.display.AppendText('4')
 532         self.display.SetFocus()
 533         
 534 
 535     def OnFive(self, event):
 536         """
 537         ...    
 538         """
 539         
 540         if self.formula:
 541             self.display.Clear()
 542             self.formula = False
 543         self.display.AppendText('5')
 544         self.display.SetFocus()
 545         
 546 
 547     def OnSix(self, event):
 548         """
 549         ...    
 550         """
 551         
 552         if self.formula:
 553             self.display.Clear()
 554             self.formula = False
 555         self.display.AppendText('6')
 556         self.display.SetFocus()
 557         
 558 
 559     def OnSeven(self, event):
 560         """
 561         ...    
 562         """
 563         
 564         if self.formula:
 565             self.display.Clear()
 566             self.formula = False
 567         self.display.AppendText('7')
 568         self.display.SetFocus()
 569         
 570 
 571     def OnEight(self, event):
 572         """
 573         ...    
 574         """
 575         
 576         if self.formula:
 577             self.display.Clear()
 578             self.formula = False
 579         self.display.AppendText('8')
 580         self.display.SetFocus()
 581         
 582 
 583     def OnNine(self, event):
 584         """
 585         ...    
 586         """
 587         
 588         if self.formula:
 589             self.display.Clear()
 590             self.formula = False
 591         self.display.AppendText('9')
 592         self.display.SetFocus()
 593         
 594 
 595     def OnKeyUp(self, event):
 596         """
 597         Handles the wx.EVT_CHAR_HOOK event for the dialog.
 598         """
 599 
 600         if event.GetKeyCode() == wx.WXK_ESCAPE:
 601             # Close the dialog, no action
 602             self.OnClose(event)
 603 
 604         event.Skip()
 605 
 606         
 607     def OnClose(self, event):
 608         """
 609         ...    
 610         """
 611         
 612         self.Close()
 613 
 614         
 615     def OnCloseWindow(self, event):
 616         """
 617         ...    
 618         """
 619         
 620         self.GetParent().Enable(True)
 621         self.__eventLoop.Exit()
 622         self.Destroy()
 623         
 624 #-------------------------------------------------------------------------------
 625 
 626 class MyFrame(wx.Frame):
 627     def __init__(self):
 628         super(MyFrame, self).__init__(None,
 629                                       -1,
 630                                       title="")
 631 
 632         #------------
 633 
 634         # Simplified init method.
 635         self.SetProperties()
 636         self.CreateCtrls()
 637         self.BindEvents()
 638         self.DoLayout()
 639 
 640         #------------
 641 
 642         self.CenterOnScreen()
 643 
 644     #-----------------------------------------------------------------------
 645 
 646     def SetProperties(self):
 647         """
 648         ...
 649         """
 650 
 651         self.SetTitle("Sample one")
 652         self.SetIcon(wx.Icon('icon/wxwin.ico'))
 653 
 654 
 655     def CreateCtrls(self):
 656         """
 657         ...
 658         """
 659 
 660         self.panel = wx.Panel(self, -1)
 661 
 662         self.btnDlg = wx.Button(self.panel,
 663                                 -1,
 664                                 "&Show customized calculator frame")
 665 
 666         self.btnClose = wx.Button(self.panel,
 667                                   -1,
 668                                   "&Close")
 669 
 670 
 671     def BindEvents(self):
 672         """
 673         Bind some events to an events handler.
 674         """
 675 
 676         # Bind the close event to an event handler.
 677         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 678 
 679         # Bind the buttons event to an event handler.
 680         self.Bind(wx.EVT_BUTTON, self.OnScreenshot, self.btnDlg)
 681         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
 682 
 683 
 684     def DoLayout(self):
 685         """
 686         ...
 687         """
 688 
 689         # mainSizer is the top-level one that manages everything.
 690         mainSizer = wx.BoxSizer(wx.VERTICAL)
 691 
 692         # wx.BoxSizer(window, proportion, flag, border)
 693         # wx.BoxSizer(sizer, proportion, flag, border)
 694         mainSizer.Add(self.btnDlg, 1, wx.EXPAND | wx.ALL, 10)
 695         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 696 
 697         # Finally, tell the panel to use the sizer for layout.
 698         self.panel.SetAutoLayout(True)
 699         self.panel.SetSizer(mainSizer)
 700 
 701         mainSizer.Fit(self.panel)
 702 
 703 
 704     def OnCloseMe(self, event):
 705         """
 706         ...
 707         """
 708 
 709         self.Close(True)
 710 
 711 
 712     def OnScreenshot(self, event):
 713         """
 714         ...
 715         """
 716 
 717         frmCal = MyCalculator(self, -1, 'Calculator')
 718         
 719 
 720     def OnCloseWindow(self, event):
 721         """
 722         ...
 723         """
 724 
 725         self.Destroy()
 726 
 727 #-------------------------------------------------------------------------------
 728 
 729 class MyApp(wx.App):
 730     def OnInit(self):
 731 
 732         #------------
 733         
 734         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 735 
 736         #------------
 737         
 738         frame = MyFrame()
 739         self.SetTopWindow(frame)
 740         frame.Show(True)
 741 
 742         return True
 743 
 744     #-----------------------------------------------------------------------
 745     
 746     def GetInstallDir(self):
 747         """
 748         Return the installation directory for my application.
 749         """
 750 
 751         return self.installDir
 752 
 753 
 754     def GetIconDir(self):
 755         """
 756         Return the icons directory for my application.
 757         """
 758 
 759         icon_dir = os.path.join(self.installDir, "icon")
 760         return icon_dir
 761 
 762 
 763     def GetBitmapDir(self):
 764         """
 765         Return the bitmaps directory for my application.
 766         """
 767 
 768         bitmap_dir = os.path.join(self.installDir, "bitmap")
 769         return bitmap_dir
 770     
 771 #---------------------------------------------------------------------------
 772 
 773 def main():
 774     app = MyApp(False)
 775     app.MainLoop()
 776 
 777 #---------------------------------------------------------------------------
 778 
 779 if __name__ == "__main__" :
 780     main()


Sample three

img_sample_three.png

   1 # sample_three.py
   2 
   3 """
   4 
   5 https://vcansimplify.wordpress.com/category/python-2/wxpython-python/
   6 
   7 """
   8 
   9 import wx 
  10 from math import *  # To enable writing sin(13) instead of math.sin(13)
  11 
  12 # class MyFrame
  13 # class MyCalcFrame
  14 # class MyApp
  15 
  16 #---------------------------------------------------------------------------
  17 
  18 class MyFrame(wx.Frame):
  19     """
  20     Frame and widgets to handle input and output of mortgage calc.
  21     """
  22     def __init__(self, parent):
  23         wx.Frame.__init__(self, parent, -1, "Math.sin calculator")
  24 
  25         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))
  26 
  27         #------------
  28         
  29         # Add panel, labels, text and sizer widgets.
  30         panel = wx.Panel(self, -1)
  31 
  32         self.text = wx.TextCtrl(panel, -1,
  33                                 size=(290, 100),
  34                                 style=wx.TE_MULTILINE)
  35         
  36         solveBtn = wx.Button(panel, -1, "&Solve")
  37         solveBtn.Bind(wx.EVT_BUTTON, self.solveFunc)
  38 
  39         clearBtn = wx.Button(panel, -1, "&Clear")
  40         clearBtn.Bind(wx.EVT_BUTTON, self.clearFunc)
  41             
  42         # Use boxsizer to add border around sizer.
  43         border = wx.BoxSizer(wx.VERTICAL)
  44         border.Add(self.text, 1, wx.EXPAND | wx.ALL, 5)
  45         border.Add(solveBtn, 1, wx.EXPAND | wx.ALL, 5)
  46         border.Add(clearBtn, 1, wx.EXPAND | wx.ALL, 5)
  47         
  48         panel.SetSizerAndFit(border)
  49         self.Fit()
  50 
  51     #-----------------------------------------------------------------------
  52         
  53     def solveFunc(self, event):
  54         """
  55         What to when 'Solve' is clicked
  56         wx calls this function with and 'event' object.
  57         """
  58 
  59         try:
  60             # Evaluate the string in 'text' and put the answer back.
  61             ans = eval(self.text.GetValue())
  62             self.text.SetValue(str(ans))
  63         except Exception:
  64             print('error')
  65 
  66 
  67     def clearFunc(self,event):
  68         """
  69         Put a blank string in text when 'Clear' is clicked.
  70         """
  71         
  72         self.text.SetValue(str(''))
  73 
  74 #---------------------------------------------------------------------------
  75         
  76 class MyCalcFrame(MyFrame):
  77     """
  78     Constructor.
  79     Inherit from the MainFrame created in wxFowmBuilder and create CalcFrame.
  80     """
  81     def __init__(self, parent):
  82         # Initialize parent class.
  83         MyFrame.__init__(self, parent)
  84         
  85 #---------------------------------------------------------------------------
  86 
  87 class MyApp(wx.App):    
  88     def OnInit(self):
  89 
  90         #------------
  91 
  92         # Create an object of MyCalcFrame.
  93         frame = MyCalcFrame(None)
  94         self.SetTopWindow(frame)
  95         # Show the frame.
  96         frame.Show(True)
  97 
  98         return True
  99     
 100 #---------------------------------------------------------------------------
 101 
 102 def main():
 103     # Mandatory in wx, create an app, False stands for not 
 104     # deteriction stdin/stdout refer manual for details.
 105     app = MyApp(False)
 106     # Start the applications.
 107     app.MainLoop()
 108 
 109 #---------------------------------------------------------------------------
 110 
 111 if __name__ == "__main__" :
 112     main()


Sample four

img_sample_four.png

   1 # sample_four.py
   2 
   3 """
   4 
   5 Author :  BridgeGuy
   6 Beta Version
   7 Uses Reverse Polish Notation similar to HP calculators
   8 Stores up to 4 values in the stack
   9 Base units is feet.
  10 Can convert from decimal feet to imperial units (ft-in)
  11 Conversion to imperial units is to nearest 1/8"
  12 Can convert to inches
  13 Will accept any decimal input
  14 Imperial units input must be in the form of #'# #,# (5'3 1,2) ==> 5'-3 1/2"
  15 There is only a space between the inches numeral and numerator of the inch fraction.
  16 
  17 https://github.com/BridgeGuy/wxCalculator
  18 
  19 """
  20 
  21 import wx
  22 import math
  23 from fractions import Fraction
  24 
  25 DISP_COLOR = wx.Colour(243, 248, 205) # Yellowish
  26 STACK4 = 0
  27 STACK3 = 0
  28 STACK2 = 0
  29 STACK1 = 0
  30 
  31 # class MainFrame
  32 # class CalcPanel
  33 
  34 #---------------------------------------------------------------------------
  35 
  36 class MainFrame(wx.Frame):
  37     """
  38     Main calculator frame
  39     """
  40     def __init__(self, *args, **kwargs):
  41         kwargs.setdefault('title', "Feet-Inch calculator")
  42         wx.Frame.__init__(self, *args, **kwargs)
  43 
  44         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))
  45 
  46         #------------
  47         
  48         self.calcPanel = CalcPanel(self)
  49         fsizer = wx.BoxSizer(wx.VERTICAL)
  50         fsizer.Add(self.calcPanel, 1, wx.EXPAND, 10)
  51         self.CenterOnScreen()
  52         self.SetSizerAndFit(fsizer)
  53 
  54 #---------------------------------------------------------------------------
  55         
  56 class CalcPanel(wx.Panel):
  57     """
  58     Panel containing display, conversion radiobox and buttons
  59     """
  60     def __init__(self, *args, **kwargs):
  61         wx.Panel.__init__(self, *args, **kwargs)
  62         
  63         sizer = wx.GridBagSizer(3,2)
  64 
  65         #------------- Display ------------------
  66         self.display4 = wx.StaticText(self, -1, str(STACK4),
  67                                       style=wx.ALIGN_RIGHT|wx.ST_NO_AUTORESIZE)
  68         self.display3 = wx.StaticText(self, -1, str(STACK3), 
  69                                       style=wx.ALIGN_RIGHT|wx.ST_NO_AUTORESIZE)
  70         self.display2 = wx.StaticText(self, -1, str(STACK2),
  71                                       style=wx.ALIGN_RIGHT|wx.ST_NO_AUTORESIZE)
  72         self.display1 = wx.StaticText(self, -1, str(STACK1),
  73                                       style=wx.ALIGN_RIGHT|wx.ST_NO_AUTORESIZE)
  74         self.display = wx.TextCtrl(self, -1, style=wx.TE_RIGHT|wx.WANTS_CHARS)
  75         self.display.Bind(wx.EVT_KEY_DOWN, self.OnKeyPress)
  76         self.text4 = wx.StaticText(self, -1, "4:")
  77         self.text3 = wx.StaticText(self, -1, "3:")
  78         self.text2 = wx.StaticText(self, -1, "2:")
  79         self.text1 = wx.StaticText(self, -1, "1:")
  80         sizer.Add(self.text4, (0,0), (1,1), wx.EXPAND|wx.LEFT|wx.TOP, 10)
  81         sizer.Add(self.text3, (1,0), (1,1), wx.EXPAND|wx.LEFT, 10)
  82         sizer.Add(self.text2, (2,0), (1,1), wx.EXPAND|wx.LEFT, 10)
  83         sizer.Add(self.text1, (3,0), (1,1), wx.EXPAND|wx.LEFT, 10)
  84         sizer.Add(self.display4, (0,1), (1,1), wx.EXPAND|wx.RIGHT|wx.TOP, 10)
  85         sizer.Add(self.display3, (1,1), (1,1), wx.EXPAND|wx.RIGHT, 10)
  86         sizer.Add(self.display2, (2,1), (1,1), wx.EXPAND|wx.RIGHT, 10)
  87         sizer.Add(self.display1, (3,1), (1,1), wx.EXPAND|wx.RIGHT, 10)
  88         sizer.Add(self.display, (4,0), (1,2), wx.EXPAND|wx.RIGHT|wx.LEFT, 10)
  89 
  90         #------------- Conversion RadioBox --------------
  91         self.rbox = wx.RadioBox(self, label= "Conversion",
  92                            choices=["Feet", "Inches", "Decimal"],
  93                            majorDimension=3, style=wx.RA_SPECIFY_COLS)
  94         self.rbox.SetSelection(0)
  95         sizer.Add(self.rbox, (5,0), (1,2), wx.ALIGN_LEFT|wx.EXPAND|wx.RIGHT|wx.LEFT, 10)
  96         self.rbox.Bind(wx.EVT_RADIOBOX, self.conversion)
  97 
  98         #-------------- Buttons -----------------
  99         gsizer1 = wx.GridSizer(5,3,2,2)
 100         buttons1 = (('7', '8', '9'),
 101                     ('4', '5', '6'),
 102                     ('3', '2', '1'),
 103                     ('C', '0', '.'))
 104         gsizer2 = wx.GridSizer(5,2,2,2)
 105         buttons2 = (("Swap", "Del"),
 106                     ("/", "'"),
 107                     ("*", "^"),
 108                     ("-", "sqrt"),
 109                     ("+", "Enter"))
 110         gsizer1.Add((1,1), 1, wx.EXPAND)
 111         gsizer1.Add((1,1), 1, wx.EXPAND)
 112         gsizer1.Add((1,1), 1, wx.EXPAND)
 113         for row in buttons1:
 114             for label in row:
 115                 b = wx.Button(self, label=label, size=(40,-1))
 116                 gsizer1.Add(b)
 117                 b.Bind(wx.EVT_BUTTON, self.OnButton)                
 118         sizer.Add(gsizer1, (6,0),(1,1), wx.EXPAND|wx.LEFT|wx.BOTTOM|wx.ALIGN_BOTTOM, 10)
 119 
 120         for row in buttons2:
 121             for label in row:
 122                 b = wx.Button(self, label=label, size=(60,-1))
 123                 gsizer2.Add(b)
 124                 b.Bind(wx.EVT_BUTTON, self.OnButton)                
 125         sizer.Add(gsizer2, (6,1),(1,1), wx.EXPAND|wx.LEFT|wx.RIGHT|wx.BOTTOM, 10)
 126         self.SetSizerAndFit(sizer)
 127 
 128     #-----------------------------------------------------------------------
 129         
 130     def OnKeyPress(self, event):
 131         """
 132         ...
 133         """
 134         
 135         keycode = event.GetKeyCode()
 136         if keycode in (13, 370):
 137             self.enter()
 138         elif keycode in (43, 388):
 139             self.add()
 140         elif keycode in (45, 390):
 141             self.sub()
 142         elif keycode in (42, 387):
 143             self.mult()
 144         elif keycode in (47, 392):
 145             self.div()
 146         else:
 147             event.Skip()
 148 
 149         
 150     def OnButton(self, event):
 151         """
 152         ...
 153         """
 154         
 155         # Get title of clicked button
 156         global STACK1, STACK2, STACK3, STACK4, STATE, TEMP_NUM
 157         label = event.GetEventObject().GetLabel()
 158 
 159         if label == 'Enter':
 160             self.enter()
 161 
 162         elif label == '+':
 163             self.add()
 164 
 165         elif label == '-':
 166             self.sub()
 167 
 168         elif label == '/':
 169             self.div()
 170 
 171         elif label == '*':
 172             self.mult()
 173 
 174         elif label == 'sqrt':
 175             self.sqrt()
 176 
 177         elif label == '^':
 178             self.power()
 179 
 180         elif label == 'Swap':
 181             self.swap()
 182 
 183         elif label == 'Del':
 184             self.delete()
 185 
 186         elif label == 'C':
 187             self.display.SetValue('')
 188 
 189         else:
 190             self.display.SetValue(self.display.GetValue() + label)
 191 
 192             
 193     def enter(self):
 194         """
 195         Enter a new number to the stack
 196         """
 197         
 198         global STACK1, STACK2, STACK3, STACK4
 199         if self.display.GetValue() != "":
 200             STACK4 = STACK3
 201             STACK3 = STACK2
 202             STACK2 = STACK1
 203             STACK1 = self.frac_to_decimal()
 204             self.updateDisplay()
 205         else:
 206             STACK4 = STACK3
 207             STACK3 = STACK2
 208             STACK2 = STACK1
 209             STACK1 = 0
 210             self.updateDisplay()
 211 
 212                         
 213     def swap(self):
 214         """
 215         Swap contents of stack1 and stack2
 216         """
 217         
 218         global STACK1, STACK2
 219         STACK1, STACK2 = STACK2, STACK1
 220         self.updateDisplay()
 221 
 222 
 223     def delete(self):
 224         """
 225         Delete number from stack1 display and shift remaining results down stack
 226         """
 227         
 228         global STACK1, STACK2, STACK3, STACK4
 229         STACK1 = STACK2
 230         STACK2 = STACK3
 231         STACK3 = STACK4
 232         STACK4 = 0
 233         self.updateDisplay()
 234 
 235         
 236     def add(self):
 237         """
 238         Add stack1 and display or contents of stack
 239         """
 240         
 241         global STACK1, STACK2, STACK3, STACK4
 242         if self.display.GetValue() != "":
 243             STACK1 = STACK1 + self.frac_to_decimal()
 244             self.updateDisplay()
 245         else:
 246             STACK1 = STACK2 + STACK1
 247             STACK2 = STACK3
 248             STACK3 = STACK4
 249             STACK4 = 0
 250             self.updateDisplay()
 251 
 252                             
 253     def sub(self):
 254         """
 255         Subtract stack1 and display or contents of stack
 256         """
 257         
 258         global STACK1, STACK2, STACK3, STACK4
 259         if self.display.GetValue() != "":
 260             STACK1 = STACK1 - self.frac_to_decimal()
 261             self.updateDisplay()
 262         else:
 263             STACK1 = STACK2 - STACK1
 264             STACK2 = STACK3
 265             STACK3 = STACK4
 266             STACK4 = 0
 267             self.updateDisplay()
 268 
 269    
 270     def mult(self):
 271         """
 272         Multiply stack1 and display or contents of stack
 273         """
 274         
 275         global STACK1, STACK2, STACK3, STACK4
 276         if self.display.GetValue() != "":
 277             STACK1 = STACK1 * self.frac_to_decimal()
 278             self.updateDisplay()
 279         else:
 280             STACK1 = STACK2 * STACK1
 281             STACK2 = STACK3
 282             STACK3 = STACK4
 283             STACK4 = 0
 284             self.updateDisplay()
 285 
 286 
 287     def div(self):
 288         """
 289         Divide stack1 and display or contents of stack
 290         """
 291         
 292         global STACK1, STACK2, STACK3, STACK4
 293         if self.display.GetValue() != "":
 294             STACK1 = STACK1 / self.frac_to_decimal()
 295             self.updateDisplay()
 296         else:
 297             STACK1 = STACK2 / STACK1
 298             STACK2 = STACK3
 299             STACK3 = STACK4
 300             STACK4 = 0
 301             self.updateDisplay()
 302 
 303 
 304     def sqrt(self):
 305         """
 306         Take the square root of display or stack1
 307         """
 308         
 309         global STACK1, STACK2, STACK3, STACK4
 310         if self.display.GetValue() != "":
 311             if self.display.GetValue() >= 0:
 312                 STACK4 = STACK3
 313                 STACK3 = STACK2
 314                 STACK2 = STACK1
 315                 STACK1 = math.sqrt(self.frac_to_decimal())
 316                 self.updateDisplay()
 317             else:
 318                 dlg = wx.MessageDialog(self, "Neg numbers not valid",
 319                                        wx.OK|wx.CANCEL)
 320                 dlg.ShowModal()
 321                 dlg.Destroy()
 322         else:
 323             if STACK1 >= 0:
 324                 STACK1 = math.sqrt(STACK1)
 325                 self.updateDisplay()
 326             else:
 327                 dlg = wx.MessageDialog(self, "Neg numbers not valid",
 328                                        wx.OK|wx.CANCEL)
 329                 dlg.ShowModal()
 330                 dlg.Destroy()
 331 
 332 
 333     def power(self):
 334         """
 335         Raise to the power
 336         """
 337         
 338         global STACK1, STACK2, STACK3, STACK4
 339         if self.display.GetValue() != "":
 340             STACK1 = STACK1 ** self.frac_to_decimal()
 341             self.updateDisplay()
 342         else:
 343             STACK1 = STACK2 ** STACK1
 344             STACK2 = STACK3
 345             STACK3 = STACK4
 346             STACK4 = 0
 347             self.updateDisplay()            
 348 
 349             
 350     def updateDisplay(self):
 351         """
 352         Update display
 353         """
 354         
 355         global STACK1, STACK2, STACK3, STACK4
 356         if self.rbox.GetSelection() == 0:
 357             S4 = self.fraction_str(STACK4)
 358             S3 = self.fraction_str(STACK3)
 359             S2 = self.fraction_str(STACK2)
 360             S1 = self.fraction_str(STACK1)
 361         elif self.rbox.GetSelection() == 1:
 362             S4 = str(STACK4 * 12)
 363             S3 = str(STACK3 * 12)
 364             S2 = str(STACK2 * 12)
 365             S1 = str(STACK1 * 12)
 366         else:
 367             S4 = str(STACK4)
 368             S3 = str(STACK3)
 369             S2 = str(STACK2)
 370             S1 = str(STACK1)
 371             
 372         self.display4.SetLabel(S4)
 373         self.display3.SetLabel(S3)
 374         self.display2.SetLabel(S2)
 375         self.display1.SetLabel(S1)
 376         self.display.SetValue('')
 377         self.display.SetFocus()
 378 
 379 
 380     def frac_to_decimal(self):
 381         """
 382         Convert feet-inch input to decimal feet
 383         """
 384         
 385         s = self.display.GetValue()
 386         s.strip()
 387         if s.find("'") == -1:
 388             dec_ft = float(s)
 389         else:
 390             if s.find(',') == -1:
 391                 ft_index = s.find("'")
 392                 ft = int(s[:ft_index])
 393                 inch = int(s[(ft_index+1):])
 394                 dec_ft = ft + inch/12.0
 395             else:
 396                 ft_index = s.find("'")
 397                 in_index = s.find(' ')
 398                 fr_index = s.find(',')
 399                 ft = int(s[:ft_index])
 400                 inch = int(s[(ft_index+1):in_index])
 401                 frac = float(Fraction(s[(in_index+1):fr_index] + "/" + s[(fr_index+1):]))
 402                 dec_ft = ft + (inch + frac)/12
 403         return dec_ft
 404 
 405 
 406     def fraction_str(self, num):
 407         """
 408         Convert decimal ft to ft-in string
 409         """
 410         
 411         ft_int = int(num)
 412         inch = (num - int(num))* 12
 413         inch_int = int(inch)
 414         frac = (inch - inch_int) * 8
 415         numerator = int(frac)
 416         if numerator == 0:
 417             frac_text = ""
 418         elif inch >= (11 + (7.4999/8)):
 419             ft_int = ft_int + 1
 420             inch_int = 0
 421             frac_text = ""
 422         elif numerator == 8:
 423             inch_int = inch_int + 1
 424             frac_text = ""
 425         else:
 426             denominator = 8
 427             if (frac - numerator) < 0.5:
 428                 while numerator % 2 == 0:
 429                     numerator = numerator / 2
 430                     denominator = denominator / 2
 431             else:
 432                 numerator = numerator + 1
 433                 while numerator % 2 == 0:
 434                     numerator = numerator / 2
 435                     denominator = denominator / 2
 436             frac_text = str(numerator) + '/' + str(denominator)
 437         frac_str = str(ft_int) + "' " + str(inch_int) + " " + frac_text
 438         return frac_str
 439 
 440 
 441     def conversion(self, event):
 442         self.updateDisplay()
 443                 
 444 #---------------------------------------------------------------------------
 445         
 446 if __name__ == '__main__':
 447     calculator = wx.App(False)
 448     calc = MainFrame(None)
 449     calc.Show(True)
 450     calculator.MainLoop()


Sample five

img_sample_five.png

   1 # sample_five.py
   2 
   3 """
   4 
   5 Author : Sneekula
   6 Do some simple math operations with
   7 wx.Choice(parent,id,pos,size,choices,style)
   8 https://www.daniweb.com/programming/software-development/threads/128350/starting-wxpython-gui-code/3#post1823238
   9 
  10 
  11 """
  12 
  13 import wx
  14 from math import *
  15 
  16 #---------------------------------------------------------------------------
  17 
  18 # List of math operations Python understands
  19 # x and/or y values are pulled from the edit boxes
  20 
  21 operation_list = [
  22 'x + y',
  23 'x - y',
  24 'x * y',
  25 'x / y',
  26 'x**y',
  27 'sqrt(x)',
  28 'exp(x)', 
  29 'log(x)', 
  30 'log10(x)', 
  31 'degrees(x)',
  32 'radians(x)',
  33 'sin(x)',
  34 'cos(x)',
  35 'tan(x)',
  36 'asin(x)',
  37 'acos(x)',
  38 'atan(x)'
  39 ]
  40 
  41 # class MyFrame
  42 
  43 #---------------------------------------------------------------------------
  44 
  45 class MyFrame(wx.Frame):
  46     def __init__(self, parent, title, operation_list):
  47         wx.Frame.__init__(self, parent, wx.ID_ANY, title, size=(350, 270))
  48 
  49         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))
  50 
  51         #------------
  52         
  53         self.SetBackgroundColour('green')
  54 
  55         #------------
  56         
  57         # Create choice widget for the math operations
  58         self.choice = wx.Choice(self, wx.ID_ANY, choices=operation_list)
  59         # Select item 0 (first item) in choices list to show
  60         self.choice.SetSelection(0)
  61         self.choice.SetToolTip(wx.ToolTip('Select one math operation'))
  62         # Bind the checkbox events to action
  63         self.choice.Bind(wx.EVT_CHOICE, self.onAction)
  64         
  65         edit_label1 = wx.StaticText(self, wx.ID_ANY, 'Enter x :')
  66         self.edit1 = wx.TextCtrl(self, wx.ID_ANY, value="1", size=(200, 20))
  67         
  68         edit_label2 = wx.StaticText(self, wx.ID_ANY, 'Enter y :')
  69         self.edit2 = wx.TextCtrl(self, wx.ID_ANY, value="1", size=(200, 20))
  70             
  71         edit_label3 = wx.StaticText(self, wx.ID_ANY, 'Result :')
  72         self.edit3 = wx.TextCtrl(self, wx.ID_ANY, value="", size=(200, 20))
  73         self.edit3.SetToolTip(wx.ToolTip('Double click to move data to x'))
  74         self.edit3.Bind(wx.EVT_LEFT_DCLICK, self.onDoubleClick)
  75         
  76         self.button = wx.Button(self, wx.ID_ANY, label='Calculate')
  77         # Bind mouse event to action
  78         self.button.Bind(wx.EVT_BUTTON, self.onAction)
  79 
  80         #------------
  81         
  82         # Hgap is between columns, vgap between rows
  83         sizer = wx.GridBagSizer(vgap=0, hgap=0)
  84         
  85         # Pos=(row, column)
  86         sizer.Add(edit_label1, pos=(0,0), flag=wx.ALL|wx.EXPAND, border=10)
  87         sizer.Add(self.edit1, pos=(0,1), flag=wx.ALL|wx.EXPAND, border=10)
  88         sizer.Add(edit_label2, pos=(1,0), flag=wx.ALL|wx.EXPAND, border=10)
  89         sizer.Add(self.edit2, pos=(1,1), flag=wx.ALL|wx.EXPAND, border=10)
  90         # Span=(rowspan, columnspan)
  91         sizer.Add(self.choice, pos=(2,0), span=(1, 2), flag=wx.ALL|wx.EXPAND, border=10)
  92         sizer.Add(self.button, pos=(3,0), span=(1, 2), flag=wx.ALL|wx.EXPAND, border=10)
  93         sizer.Add(edit_label3, pos=(4,0), flag=wx.ALL|wx.EXPAND, border=10)
  94         sizer.Add(self.edit3, pos=(4,1), flag=wx.ALL|wx.EXPAND, border=10)
  95 
  96         self.SetSizerAndFit(sizer)
  97 
  98     #-----------------------------------------------------------------------
  99         
 100     def onAction(self, event):
 101         """
 102         ...
 103         """
 104         
 105         op = self.choice.GetStringSelection()
 106         x = float(self.edit1.GetValue())
 107         y = float(self.edit2.GetValue())
 108         
 109         if y == 0.0 and op == 'x / y' :
 110             result = 'division by zero error'
 111         else:
 112             result = eval(op)
 113             
 114         # Print result, type(result)
 115         self.edit3.SetValue(str(result))
 116 
 117         
 118     def onDoubleClick(self, event):
 119         """
 120         If edit3 has been doubleclicked, transfer value to edit1
 121         """
 122         
 123         val = self.edit3.GetValue()
 124         self.edit1.ChangeValue(val)
 125 
 126 #---------------------------------------------------------------------------
 127 
 128 app = wx.App(0)
 129 # Create the MyFrame instance and show it
 130 MyFrame(None, 'Do math stuff', operation_list).Show()
 131 app.MainLoop()


Sample six

img_sample_six.png

   1 # sample_six.py
   2 
   3 """
   4 
   5 Create a calulator button layout with wx.GridSizer().
   6 Then add a few things to form a tiny wxPython calculator.
   7 https://stackoverflow.com/questions/16435607/range-object-does-not-support-item-assignment-trying-to-use-old-python-code
   8 
   9 """
  10 
  11 import wx
  12 
  13 # class MyFrame
  14 
  15 #---------------------------------------------------------------------------
  16 
  17 class MyFrame(wx.Frame):
  18     """
  19     Make a frame, inherits wx.Frame.
  20     """
  21     def __init__(self):
  22         # Create a frame/window, no parent
  23         wx.Frame.__init__(self, None, wx.ID_ANY, 'Tiny calculator',
  24                           pos=(300, 150), size=(300, 200))
  25 
  26         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))
  27         self.SetBackgroundColour('purple')
  28 
  29         #------------
  30         
  31         # Main sizer
  32         vsizer = wx.BoxSizer(wx.VERTICAL)
  33 
  34         self.edit = wx.TextCtrl(self, -1, value="", size=(165, 20))
  35 
  36         # Follows layout of calculator keys
  37         self.btn_list = [
  38         '7', '8', '9', '/', 'c',
  39         '4', '5', '6', '*', 'bs',
  40         '1', '2', '3', '-', '**',
  41         '0', '.', '=', '+', 'neg'
  42         ]
  43 
  44         #------------
  45         
  46         # wx.GridSizer(rows, cols, vgap, hgap)
  47         gsizer = wx.GridSizer(4, 5, 2, 2)
  48 
  49         self.btn = list(range(len(self.btn_list)))
  50         for ix, b_label in enumerate(self.btn_list):
  51             # Set up a consecutive unique id for each button
  52             id = 1000 + ix
  53             self.btn[ix] = wx.Button(self, id, label=b_label, size=(20, 20))
  54             # The gridsizer fills left to right one row at a time
  55             gsizer.Add(self.btn[ix], 0, wx.ALL|wx.EXPAND, border=2)
  56             self.btn[ix].Bind(wx.EVT_BUTTON, self.btnClick)
  57 
  58         #------------
  59             
  60         # Now add the whole thing to the main sizer and set it
  61         vsizer.Add(self.edit, 0, wx.EXPAND)
  62         vsizer.Add(gsizer, 1, wx.EXPAND)
  63         self.SetSizer(vsizer)
  64 
  65     #-----------------------------------------------------------------------
  66 
  67     def btnClick(self, event):
  68         """
  69         ...
  70         """
  71         
  72         # Get the label of the button clicked
  73         label = self.btn_list[event.GetId() - 1000]
  74         e_list = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
  75             '+', '-', '*', '/', '**', '.']
  76         
  77         if label in e_list:
  78             self.edit.SetValue(self.edit.GetValue() + label)
  79         elif label == 'neg':
  80             # Negate, note eval() takes care of double negate
  81             self.edit.SetValue('-' + self.edit.GetValue())
  82         elif label == 'c':
  83             # Cclear
  84             self.edit.SetValue('')
  85         elif label == 'bs':
  86             # Backspace
  87             self.edit.SetValue(self.edit.GetValue()[:-1])
  88         elif label == '=':
  89             str1 = self.edit.GetValue()
  90             # Prevent folks from being nasty with eval()
  91             if not str1 or str1[0] not in '0123456789-+.':
  92                 self.edit.SetValue('unrecognized operation')
  93                 return
  94             while str1[0] == '0':
  95                 # Avoid leading zero (octal) error with eval()
  96                 str1 = str1[1:]
  97             if '/' in str1 and '.' not in str1:
  98                 # Turn into floating point division
  99                 str1 = str1 + '.0'
 100             try:
 101                 self.edit.SetValue(str(eval(str1)))
 102             except ZeroDivisionError:
 103                 self.edit.SetValue('division by zero error')
 104         else:
 105             self.edit.SetValue('unrecognized operation')
 106 
 107 #---------------------------------------------------------------------------
 108             
 109 app = wx.App(0)
 110 # Create MyFrame instance and show the frame
 111 MyFrame().Show()
 112 app.MainLoop()


Sample seven

img_sample_seven.png

   1 # sample_seven.py
   2 
   3 """
   4 
   5 Author : Sneekula
   6 Use slider inputs to calculate cost of petrol in the USA and Europe.
   7 https://www.daniweb.com/programming/software-development/threads/128350/starting-wxpython-gui-code/2#post1823238
   8 
   9 """
  10 
  11 import wx
  12 
  13 # class MyFrame
  14 
  15 #---------------------------------------------------------------------------
  16 
  17 class MyFrame(wx.Frame):
  18     def __init__(self, parent, mytitle, mysize):
  19         wx.Frame.__init__(self, parent, wx.ID_ANY, mytitle, size=mysize)
  20 
  21         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))        
  22         self.SetBackgroundColour("yellow")
  23 
  24         #------------
  25         
  26         # Create input widgets
  27 
  28         self.panel = wx.Panel(self, wx.ID_ANY)
  29         self.panel.SetDoubleBuffered(True)  # No flickering
  30         
  31         # Label for slider1
  32         label_s1 = wx.StaticText(self.panel, wx.ID_ANY, "US cents per US Gallon :")
  33         
  34         # Can only use integer values!!!
  35         # Initial value = 450, min value = 300, max value = 600
  36         self.slider1 = wx.Slider(self.panel, wx.ID_ANY, 450, 300, 600, size=(320, 40),
  37             style=wx.SL_HORIZONTAL|wx.SL_LABELS)
  38         
  39         # Label for slider2
  40         label_s2 = wx.StaticText(self.panel, wx.ID_ANY, "Euro cents per Liter :")
  41         
  42         # Initial value = 150, min value = 100, max value = 200
  43         self.slider2 = wx.Slider(self.panel, wx.ID_ANY, 150, 100, 200, size=(320, 40),
  44             style=wx.SL_HORIZONTAL|wx.SL_LABELS)
  45         
  46         # Label for slider3
  47         label_s3 = wx.StaticText(self.panel, wx.ID_ANY, "US cents per Euro :")
  48         
  49         # Initial value = 160, min value = 100, max value = 200
  50         self.slider3 = wx.Slider(self.panel, wx.ID_ANY, 160, 100, 200, size=(320, 40),
  51             style=wx.SL_HORIZONTAL|wx.SL_LABELS)
  52 
  53         # Bind all mouse slider marker drags to the same action
  54         self.Bind(wx.EVT_SLIDER, self.onAction)
  55 
  56         # Create an output widget
  57         self.label = wx.StaticText(self.panel, wx.ID_ANY, "")
  58 
  59         #------------
  60         
  61         # Use a vertical boxsizer for the widget placement
  62         sizer_v = wx.BoxSizer(wx.VERTICAL)
  63         sizer_h = wx.BoxSizer(wx.HORIZONTAL)
  64         sizer_v.Add(label_s1, 0, flag=wx.LEFT|wx.RIGHT|wx.EXPAND, border=10)
  65         sizer_v.Add(self.slider1, 0, flag=wx.ALL|wx.EXPAND, border=5)
  66         sizer_v.Add(label_s2, 0, flag=wx.LEFT|wx.RIGHT|wx.EXPAND, border=10)
  67         sizer_v.Add(self.slider2, 0, flag=wx.ALL|wx.EXPAND, border=5)
  68         sizer_v.Add(label_s3, 0, flag=wx.LEFT|wx.RIGHT|wx.EXPAND, border=10)
  69         sizer_v.Add(self.slider3, 0, flag=wx.ALL|wx.EXPAND, border=5)
  70         sizer_v.Add(self.label, 0, flag=wx.ALL|wx.EXPAND, border=10)
  71         sizer_h.Add(sizer_v, 0, flag=wx.ALL|wx.EXPAND, border=15)        
  72 
  73         self.panel.SetSizer(sizer_h)
  74 
  75         # Show opening result
  76         self.onAction(None)
  77 
  78     #-----------------------------------------------------------------------
  79 
  80     def onAction(self, event):
  81         """
  82         Some action code.
  83         """
  84         
  85         s = "The result... \n\n"
  86         
  87         # Gives integer cents values, convert to $ and Euro
  88         us_price = self.slider1.GetValue()/100.0
  89         euro_price = self.slider2.GetValue()/100.0
  90         euro_cost = self.slider3.GetValue()/100.0
  91         
  92         # 1 US gal = 3.785 liters
  93         s1 = "In the USA $%.2f/gal = $%.2f/liter = %.2f Euro/liter\n" % \
  94             (us_price, us_price/3.785, us_price/(3.785*euro_cost))
  95         s2 = "In Europe  $%.2f/gal = $%.2f/liter = %.2f Euro/liter" % \
  96             (euro_price*euro_cost*3.785, euro_price*euro_cost, euro_price)
  97         
  98         self.label.SetLabel(s + s1 + s2)
  99 
 100 #---------------------------------------------------------------------------
 101         
 102 app = wx.App()
 103 # Create the MyFrame instance and then show the frame
 104 frm = MyFrame(None, 'The petrol sliders', (380, 345))
 105 frm.Show(True)
 106 app.MainLoop()


Sample eight

img_sample_eight.png

   1 # sample_eight.py
   2 
   3 """
   4 
   5 A simple mortgage calulator using wxPython.
   6 Author : Lardmeister
   7 Checked it out with the online mortgage calculator at:
   8 http://www.mortgage-calc.com/mortgage/simple.php
   9 https://www.daniweb.com/programming/software-development/threads/128350/starting-wxpython-gui-code#post626319
  10 
  11 """
  12 
  13 import wx
  14 import math
  15 
  16 # class MyFrame
  17 
  18 #---------------------------------------------------------------------------
  19 
  20 class MyFrame(wx.Frame):
  21     """
  22     Frame and widgets to handle input and output of mortgage calc.
  23     """
  24     def __init__(self, parent, id, title):
  25         wx.Frame.__init__(self, parent, id, title)
  26 
  27         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))
  28 
  29         #------------
  30         
  31         # Add panel, labels, text and sizer widgets
  32         panel = wx.Panel(self, -1)
  33         panel.SetBackgroundColour('orange')
  34         
  35         label1 = wx.StaticText(panel, -1, "Enter total loan amount :")
  36         label2 = wx.StaticText(panel, -1, "Enter annual interest (%) :")
  37         label3 = wx.StaticText(panel, -1, "Enter years to pay :")
  38 
  39         label1.SetForegroundColour('white')
  40         label2.SetForegroundColour('white')
  41         label3.SetForegroundColour('white')
  42         
  43         self.loan = wx.TextCtrl(panel, -1, "100000")
  44         self.interest = wx.TextCtrl(panel, -1, "6.5")
  45         self.years = wx.TextCtrl(panel, -1, "30")
  46         
  47         self.calc_btn = wx.Button(panel, -1, ' Perform Mortgage Calculation ')
  48         self.calc_btn.SetBackgroundColour('light blue')
  49         self.calc_btn.Bind(wx.EVT_BUTTON, self.onCalc)
  50         
  51         info = "Modify the above data to your needs !"
  52         self.result = wx.TextCtrl(panel, -1, info, size=(290, 100),
  53                                   style=wx.TE_MULTILINE)
  54 
  55         #------------
  56         
  57         # Use gridbagsizer for layout of widgets
  58         sizer = wx.GridBagSizer(vgap=5, hgap=10)
  59         sizer.Add(label1, pos=(0, 0))
  60         sizer.Add(self.loan, pos=(0, 1))  # row 0, column 1
  61         sizer.Add(label2, pos=(1, 0))
  62         sizer.Add(self.interest, pos=(1, 1))
  63         sizer.Add(label3, pos=(2, 0))
  64         sizer.Add(self.years, pos=(2, 1))
  65         sizer.Add(self.calc_btn, pos=(3, 0), span=(1, 2))
  66         # Span=(1, 2) --> allow to span over 2 columns 
  67         sizer.Add(self.result, pos=(4, 0), span=(1, 2))
  68         
  69         # Use boxsizer to add border around sizer
  70         border = wx.BoxSizer()
  71         border.Add(sizer, 0, wx.ALL, 20)
  72         panel.SetSizerAndFit(border)
  73         
  74         self.Fit()
  75 
  76     #-----------------------------------------------------------------------
  77         
  78     def onCalc(self, event):
  79         """
  80         Do the mortgage calcuations.
  81         """
  82         
  83         # Get the values from the input widgets
  84         principal = float(self.loan.GetValue())
  85         interest = float(self.interest.GetValue())
  86         years = float(self.years.GetValue())
  87         
  88         # Calculate        
  89         interestRate = interest/(100 * 12)
  90         paymentNum = years * 12
  91         paymentVal = principal * \
  92                      (interestRate/(1-math.pow((1+interestRate), (-paymentNum))))
  93 
  94         # Show the result
  95         resultStr1 = "Your monthly payment will be $%.2f for\n" % paymentVal
  96         resultStr2 = "a %.1f year $%.2f loan at %.2f%s interest" % \
  97                      (years, principal, interest, '%') 
  98         self.result.SetValue(resultStr1 + resultStr2) 
  99         
 100 #---------------------------------------------------------------------------
 101         
 102 app = wx.App()
 103 frame = MyFrame(None, -1, "Mortgage calculator")
 104 frame.Show()
 105 app.MainLoop()


Sample nine

img_sample_nine.png

   1 # sample_nine.py
   2 
   3 """
   4 
   5 Experiments with wxPython's wx.Notebook() widget.
   6 Author : Vegaseat
   7 Converting distance, area and volume units
   8 Tested with Python25 and wxPython28 - 11aug2008
   9 Tested with Python3.x and wxPython4.x
  10 
  11 """
  12 
  13 import wx
  14 
  15 # class MyNotebook
  16 # class MyPage
  17 
  18 #---------------------------------------------------------------------------
  19         
  20 # These are the conversion dictionaries ...
  21 # (note that units won't appear in that order)
  22 distD ={}
  23 
  24 # All scale factors are relative to the first unit below
  25 distD['meter'] = 1.0
  26 distD['micron'] = 1000000.0
  27 distD['millimeter'] = 1000.0
  28 distD['centimeter'] = 100.0
  29 distD['kilometer'] = 0.001
  30 distD['inch'] = 100.0/2.54
  31 distD['foot'] = 100.0/30.48
  32 distD['yard'] = 100.0/91.44
  33 distD['mile'] = 0.001/1.609344
  34 distD['rod'] = 1.0/5.029
  35 
  36 
  37 areaD = {}
  38 
  39 # All scale factors are relative to the first unit below
  40 areaD['sq meter'] = 1.0
  41 areaD['sq millimeter'] = 1000000.0
  42 areaD['sq centimeter'] = 10000.0
  43 areaD['sq kilometer']  = 0.000001
  44 areaD['hectare'] = 0.0001
  45 areaD['sq inch'] = 1550.003
  46 areaD['sq foot'] = 10.76391
  47 areaD['sq yard'] = 1.19599
  48 areaD['acre'] = 0.0002471054
  49 areaD['sq mile'] = 0.0000003861022
  50 
  51 
  52 volD = {}
  53 
  54 # All scale factors are relative to the first unit below
  55 volD['cubic meter'] = 1.0
  56 volD['microliter'] = 1000000000.0
  57 volD['milliliter'] = 1000000.0
  58 volD['liter'] = 1000.0
  59 volD['pint(US)'] = 2113.376
  60 volD['quart(US)'] = 1056.688
  61 volD['gallon(US)'] = 264.172
  62 volD['cubic inch'] = 61023.74
  63 volD['cubic foot'] = 35.31467
  64 volD['cubic yard'] = 1.307951
  65 
  66 #---------------------------------------------------------------------------
  67 
  68 class MyNotebook(wx.Frame):
  69     def __init__(self, parent, title, distD, areaD, volD):
  70         wx.Frame.__init__(self, parent, wx.ID_ANY, title,
  71                           size=(490, 400))
  72 
  73         self.SetIcon(wx.Icon('./icons/wxwin.ico', wx.BITMAP_TYPE_ICO))
  74 
  75         #------------
  76         
  77         # style=wx.NB_TOP is default
  78         # Could use style=wx.NB_BOTTOM
  79         nb = wx.Notebook(self, wx.ID_ANY)
  80         
  81         # MyPage(parent, conversion dictionary, preselected choice)
  82         self.page1 = MyPage(nb, distD, 3)
  83         self.page2 = MyPage(nb, areaD, 2)
  84         self.page3 = MyPage(nb, volD, 0)
  85         nb.AddPage(self.page1, "Distance Conversion")
  86         nb.AddPage(self.page2, "Area Conversion")
  87         nb.AddPage(self.page3, "Volume Conversion")
  88         
  89         # Start with page1 active
  90         self.page1.SetFocus()
  91 
  92 #---------------------------------------------------------------------------
  93         
  94 class MyPage(wx.Panel):
  95     """
  96     each panel instance creates the notbook page content
  97     from the given conversion dictionary convD
  98     """
  99     def __init__(self, parent, convD, preselect):
 100         wx.Panel.__init__(self, parent, wx.ID_ANY)
 101         
 102         oatmeal3 = '#FCFFE1'
 103         self.SetBackgroundColour(oatmeal3)
 104 
 105         self.convD = convD
 106         # print("convD :", self.convD)
 107 
 108         #------------
 109         
 110         # Create list of possible units
 111         items = convD.keys()
 112         self.options = (list(items))
 113         
 114         self.radiobox1 = wx.RadioBox(self, wx.ID_ANY,
 115                                      "Select a unit to convert from",
 116                                      choices=self.options, style=wx.VERTICAL)
 117         # Set radio button 1 as selected (first button is 0)
 118