1 # sample_one.py
   2 
   3 import sys
   4 import os
   5 import platform
   6 import time
   7 import wx
   8 import wx.adv
   9 import wx.lib.fancytext as fancytext
  10 
  11 # class MyAboutDlg
  12 # class MyWindow
  13 # class MyButtonBox
  14 # class MyPanel
  15 # class MyFrame
  16 # class MyApp
  17 
  18 #-------------------------------------------------------------------------------
  19 
  20 class MyAboutDlg(wx.Frame):
  21     """
  22     Thanks to Robin Dunn.
  23     """
  24     def __init__(self, parent):
  25         style = (wx.FRAME_SHAPED | wx.SIMPLE_BORDER |
  26                  wx.CLIP_CHILDREN | wx.STAY_ON_TOP |
  27                  wx.SYSTEM_MENU | wx.CLOSE_BOX |
  28                  wx.NO_FULL_REPAINT_ON_RESIZE)
  29         wx.Frame.__init__(self,
  30                           parent,
  31                           id=-1,
  32                           title="About...",
  33                           style=style)
  34 
  35         #------------
  36 
  37         # Attributes.
  38         self.SetTransparent(0)
  39         self.opacity_in = 0
  40         self.opacity_out = 255
  41         self.deltaN = -70
  42         self.hasShape = False
  43         self.delta = wx.Point(0,0)
  44 
  45         #------------
  46 
  47         # Return application name.
  48         self.app_name = wx.GetApp().GetAppName()
  49         # Return bitmaps folder.
  50         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
  51         # Return icons folder.
  52         self.icons_dir = wx.GetApp().GetIconsDir()
  53 
  54         #------------
  55 
  56         # Simplified init method.
  57         self.SetProperties()
  58         self.OnTimerIn(self)
  59         self.CreateCtrls()
  60         self.BindEvents()
  61 
  62         #------------
  63 
  64         self.CenterOnParent(wx.BOTH)
  65         self.GetParent().Enable(False)
  66 
  67         #------------
  68 
  69         self.Show(True)
  70 
  71         #------------
  72 
  73         self.eventLoop = wx.GUIEventLoop()
  74         self.eventLoop.Run()
  75 
  76     #---------------------------------------------------------------------------
  77 
  78     def SetProperties(self):
  79         """
  80         Set the dialog properties (title, icon, transparency...).
  81         """
  82 
  83         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  84                                          "icon_wxWidgets.ico"),
  85                             type=wx.BITMAP_TYPE_ICO)
  86         self.SetIcon(frameIcon)
  87 
  88 
  89     def OnTimerIn(self, evt):
  90         """
  91         Thanks to Pascal Faut.
  92         """
  93 
  94         self.timer1 = wx.Timer(self, -1)
  95         self.timer1.Start(1)
  96         self.Bind(wx.EVT_TIMER, self.AlphaCycle1, self.timer1)
  97 
  98         print("Fade-in was launched.")
  99 
 100 
 101     def OnTimerOut(self, evt):
 102         """
 103         Thanks to Pascal Faut.
 104         """
 105 
 106         self.timer2 = wx.Timer(self, -1)
 107         self.timer2.Start(1)
 108         self.Bind(wx.EVT_TIMER, self.AlphaCycle2, self.timer2)
 109 
 110         print("Fade-out was launched.")
 111 
 112 
 113     def AlphaCycle1(self, *args):
 114         """
 115         Thanks to Pascal Faut.
 116         """
 117 
 118         self.opacity_in += self.deltaN
 119         if self.opacity_in <= 0:
 120             self.deltaN = -self.deltaN
 121             self.opacity_in = 0
 122 
 123         if self.opacity_in >= 255:
 124             self.deltaN = -self.deltaN
 125             self.opacity_in = 255
 126 
 127             self.timer1.Stop()
 128 
 129         self.SetTransparent(self.opacity_in)
 130 
 131         print("Fade in = {}/255".format(self.opacity_in))
 132 
 133 
 134     def AlphaCycle2(self, *args):
 135         """
 136         Thanks to Pascal Faut.
 137         """
 138 
 139         self.opacity_out += self.deltaN
 140         if self.opacity_out >= 255:
 141             self.deltaN = -self.deltaN
 142             self.opacity_out = 255
 143 
 144         if self.opacity_out <= 0:
 145             self.deltaN = -self.deltaN
 146             self.opacity_out = 0
 147 
 148             self.timer2.Stop()
 149 
 150             wx.CallAfter(self.Destroy)
 151 
 152         self.SetTransparent(self.opacity_out)
 153 
 154         print("Fade out = {}/255".format(self.opacity_out))
 155 
 156 
 157     def CreateCtrls(self):
 158         """
 159         Make widgets for my dialog.
 160         """
 161 
 162         # Load a background bitmap.
 163         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 164                                           "skin_about_1.png"),
 165                              type=wx.BITMAP_TYPE_PNG)
 166         mask = wx.Mask(self.bmp, wx.RED)
 167         self.bmp.SetMask(mask)
 168 
 169         #------------
 170 
 171         self.SetClientSize((self.bmp.GetWidth(), self.bmp.GetHeight()))
 172 
 173         #------------
 174 
 175         if wx.Platform == "__WXGTK__":
 176             # wxGTK requires that the window be created before you can
 177             # set its shape, so delay the call to SetWindowShape until
 178             # this event.
 179             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 180         else:
 181             # On wxMSW and wxMac the window has already
 182             # been created, so go for it.
 183             self.SetWindowShape()
 184 
 185 
 186     def BindEvents(self):
 187         """
 188         Bind all the events related to my dialog.
 189         """
 190 
 191         # Bind some events to an events handler.
 192         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
 193         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
 194         self.Bind(wx.EVT_RIGHT_UP, self.OnCloseWindow)  # Panel right clic.
 195         self.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)  # View mask.
 196         self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
 197         self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 198         self.Bind(wx.EVT_MOTION, self.OnMouseMove)
 199         self.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
 200         self.Bind(wx.EVT_PAINT, self.OnPaint)
 201         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 202 
 203 
 204     def SetWindowShape(self, event=None):
 205         """
 206         ...
 207         """
 208 
 209         # Use the bitmap's mask to determine the region.
 210         r = wx.Region(self.bmp)
 211         self.hasShape = self.SetShape(r)
 212 
 213 
 214     def OnEraseBackground(self, event):
 215         """
 216         ...
 217         """
 218 
 219         dc = event.GetDC()
 220         if not dc:
 221             dc = wx.ClientDC(self)
 222             rect = self.GetUpdateRegion().GetBox()
 223             dc.SetClippingRect(rect)
 224 
 225 
 226     def OnDoubleClick(self, event):
 227         """
 228         ...
 229         """
 230 
 231         if self.hasShape:
 232             self.SetShape(wx.Region())
 233             self.hasShape = False
 234         else:
 235             self.SetWindowShape()
 236 
 237 
 238     def OnLeftDown(self, event):
 239         """
 240         ...
 241         """
 242 
 243         self.CaptureMouse()
 244         x, y = self.ClientToScreen(event.GetPosition())
 245         originx, originy = self.GetPosition()
 246         dx = x - originx
 247         dy = y - originy
 248         self.delta = ((dx, dy))
 249 
 250 
 251     def OnLeftUp(self, evt):
 252         """
 253         ...
 254         """
 255 
 256         if self.HasCapture():
 257             self.ReleaseMouse()
 258 
 259 
 260     def OnMouseMove(self, event):
 261         """
 262         ...
 263         """
 264 
 265         if event.Dragging() and event.LeftIsDown():
 266             x, y = self.ClientToScreen(event.GetPosition())
 267             fp = (x - self.delta[0], y - self.delta[1])
 268             self.Move(fp)
 269 
 270 
 271     def OnPaint(self, event):
 272         """
 273         ...
 274         """
 275 
 276         dc = wx.AutoBufferedPaintDCFactory(self)
 277         dc.DrawBitmap(self.bmp, -1, -1, True)
 278 
 279         #------------
 280 
 281         # These are strings.
 282         py_version = sys.version.split()[0]
 283 
 284         str1 = (('<font style="normal" family="default" color="yellow" size="10" weight="bold">'
 285                  'Programming : </font>'
 286                  '<font style="normal" family="default" color="white" size="10" weight="normal">'
 287                  'Python {}</font>').format(py_version))   # Python 3.6.5
 288 
 289         str2 = (('<font style="normal" family="default" color="red" size="10" weight="bold">'
 290                  'GUI toolkit : </font>'
 291                  '<font style="normal" family="default" color="white" size="10" weight="normal">'
 292                  'wxPython {}</font>').format(wx.VERSION_STRING))  # wxPython 4.0.2
 293 
 294         str3 = (('<font style="normal" family="default" color="brown" size="10" weight="bold">'
 295                  'Library : </font>'
 296                  '<font style="normal" family="default" color="white" size="10" weight="normal">'
 297                  '{}</font>').format(wx.GetLibraryVersionInfo().VersionString))   # wxWidgets 3.0.5
 298 
 299         str4 = (('<font style="normal" family="default" color="cyan" size="10" weight="bold">'
 300                  'Operating system : </font>'
 301                  '<font style="normal" family="default" color="white" size="10" weight="normal">'
 302                  '{}</font>').format(platform.system()))   # Windows
 303 
 304         str5 = (('<font style="normal" family="default" color="gray" size="9" weight="normal">'
 305                  '{}</font>').format(self.app_name))   # Custom Gui 1
 306 
 307         str6 = (('<font style="normal" family="default" color="White" size="8" weight="normal">'
 308                  'Right clic or Esc for Exit</font>'))
 309 
 310         #------------
 311 
 312         # Return main image size.
 313         bw, bh = self.bmp.GetWidth(), self.bmp.GetHeight()
 314 
 315         # Draw text.
 316         # Need width to calculate x position of str1.
 317         tw, th = fancytext.GetExtent(str1, dc)
 318         # Centered text.
 319         fancytext.RenderToDC(str1, dc, (bw-tw)/2, 50)
 320 
 321         #------------
 322 
 323         # Need width to calculate x position of str2.
 324         tw, th = fancytext.GetExtent(str2, dc)
 325         # Centered text.
 326         fancytext.RenderToDC(str2, dc, (bw-tw)/2, 70)
 327 
 328         #------------
 329 
 330         # Need width to calculate x position of str3.
 331         tw, th = fancytext.GetExtent(str3, dc)
 332         # Centered text.
 333         fancytext.RenderToDC(str3, dc, (bw-tw)/2, 90)
 334 
 335         #------------
 336 
 337         # Need width to calculate x position of str4.
 338         tw, th = fancytext.GetExtent(str4, dc)
 339         # Centered text.
 340         fancytext.RenderToDC(str4, dc, (bw-tw)/2, 110)
 341 
 342         #------------
 343 
 344         # Need width to calculate x position of str5.
 345         tw, th = fancytext.GetExtent(str5, dc)
 346         # Centered text.
 347         fancytext.RenderToDC(str5, dc, (bw-tw)/2, 150)
 348 
 349         #------------
 350 
 351         # Need width to calculate x position of str6.
 352         tw, th = fancytext.GetExtent(str6, dc)
 353         # Centered text.
 354         fancytext.RenderToDC(str6, dc, (bw-tw)/2, 185)
 355 
 356 
 357     def OnKeyUp(self, event):
 358         """
 359         ...
 360         """
 361 
 362         if event.GetKeyCode() == wx.WXK_ESCAPE:
 363             self.OnCloseWindow(event)
 364 
 365         event.Skip()
 366 
 367 
 368     def OnCloseWindow(self, event):
 369         """
 370         ...
 371         """
 372 
 373         self.GetParent().Enable(True)
 374         self.eventLoop.Exit()
 375         #self.Destroy()
 376         self.OnTimerOut(self)
 377 
 378 #-------------------------------------------------------------------------------
 379 
 380 class MyWindow(wx.Control):
 381     """
 382     Thanks to Cody Precord.
 383     """
 384     def __init__(self, parent, label,
 385                  foreground, background,
 386                  normal, pressed=None, disabled=None):
 387         super(MyWindow, self).__init__(parent, -1,
 388                                        style=wx.BORDER_NONE)
 389 
 390         #------------
 391 
 392         # Attributes.
 393         self.label = label
 394         self.foreground = foreground
 395         self.background = background
 396 
 397         if wx.Platform == "__WXGTK__":
 398             self.color = "#9e9d9d"
 399 
 400         else:
 401             self.color = "#b1b1b0"
 402 
 403         self.normal = normal
 404         self.pressed = pressed
 405         self.disabled = disabled
 406 
 407         self._clicked = False
 408 
 409         #------------
 410 
 411         self.region = wx.Region(normal, wx.Colour(0, 0, 0, 0))
 412 
 413         #------------
 414 
 415         # Simplified init method.
 416         self.SetProperties(label, foreground, background)
 417         self.BindEvents()
 418 
 419     #---------------------------------------------------------------------------
 420 
 421     def SetProperties(self, label, foreground, background):
 422         """
 423         ...
 424         """
 425 
 426         self.label = label
 427         self.foreground = foreground
 428         self.background = background
 429         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 430 
 431 
 432     def BindEvents(self):
 433         """
 434         Bind some events to an events handler.
 435         """
 436 
 437         self.Bind(wx.EVT_SET_FOCUS, self.OnSetFocus)
 438         self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
 439         self.Bind(wx.EVT_PAINT, self.OnPaint)
 440         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
 441         self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDclick)
 442         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
 443         self.Bind(wx.EVT_MOTION, self.OnMotion)
 444         self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeave)
 445         self.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
 446 
 447 
 448     def SetLabel(self, label):
 449         """
 450         ...
 451         """
 452 
 453         self.label = label
 454         self.Refresh()
 455 
 456 
 457     def DoGetBestSize(self):
 458         """
 459         ...
 460         """
 461 
 462         return self.normal.GetSize()
 463 
 464 
 465     def GetLabel(self):
 466         """
 467         ...
 468         """
 469 
 470         return self.label
 471 
 472 
 473     def GetLabelColor(self):
 474         """
 475         ...
 476         """
 477 
 478         return self.foreground
 479 
 480 
 481     def Enable(self, *args, **kwargs):
 482         """
 483         ...
 484         """
 485 
 486         super(MyWindow, self).Enable(*args, **kwargs)
 487         self.Refresh()
 488 
 489 
 490     def Disable(self, *args, **kwargs):
 491         """
 492         ...
 493         """
 494 
 495         super(MyWindow, self).Disable(*args, **kwargs)
 496         self.Refresh()
 497 
 498 
 499     def PostEvent(self):
 500         """
 501         ...
 502         """
 503 
 504         event = wx.CommandEvent()
 505         event.SetEventObject(self)
 506         event.SetEventType(wx.EVT_BUTTON.typeId)
 507         wx.PostEvent(self, event)
 508 
 509 
 510     def OnSize(self, event):
 511         """
 512         ...
 513         """
 514 
 515         event.Skip()
 516         self.Refresh()
 517 
 518 
 519     def Getbackground(self):
 520         """
 521         ...
 522         """
 523 
 524         return self.background
 525 
 526 
 527     def OnPaint(self, event):
 528         """
 529         ...
 530         """
 531 
 532         dc = wx.BufferedPaintDC(self)
 533         dc.Clear()
 534         gcdc = wx.GCDC(dc)
 535 
 536         # Set the background color.
 537         if wx.Platform == "__WXGTK__":
 538             gcdc.SetBackground(wx.Brush("grey55"))
 539         else:
 540             gcdc.SetBackground(wx.Brush(self.background))
 541 
 542         gcdc.Clear()
 543 
 544         # Get the working rectangle we can draw in.
 545         rect = self.GetClientRect()
 546 
 547         # Font size and style.
 548         fontSize = self.GetFont().GetPointSize()
 549 
 550         if wx.Platform == "__WXGTK__":
 551             boldFont = wx.Font(fontSize-1, wx.DEFAULT,
 552                                wx.NORMAL, wx.NORMAL, False, "")
 553         else:
 554             boldFont = wx.Font(fontSize+2, wx.DEFAULT,
 555                                wx.NORMAL, wx.BOLD, False, "")
 556 
 557         if wx.Platform == "__WXMSW__":
 558             pen = wx.Pen(self.color, 1, wx.SOLID)
 559 
 560         else:
 561             pen = wx.Pen(self.color, 1, wx.SOLID)
 562 
 563         gcdc.SetPen(pen)
 564 
 565         x, y = self.GetSize()
 566         # x, y , width, height, radius
 567         gcdc.DrawRoundedRectangle (0, 0, 71, 25, 3)
 568 
 569         bitmap = self.normal
 570 
 571         w, h = bitmap.GetWidth(), bitmap.GetHeight()
 572 
 573         if self.clicked:
 574             bitmap = self.pressed or bitmap
 575         if not self.IsEnabled():
 576             bitmap = self.normal or bitmap
 577 
 578         # Draw a bitmap with an alpha channel.
 579         # image, x, y, transparency.
 580         dc.DrawBitmap(bitmap, 0, 0, True)
 581 
 582         if wx.Platform == "__WXGTK__":
 583             # Add the Caption.
 584             # White text - Shadow.
 585             rect = wx.Rect(rect.x, rect.y+3,
 586                            rect.width, 22)
 587 
 588         else:
 589             rect = wx.Rect(rect.x, rect.y+3,
 590                            rect.width, 20)
 591 
 592         dc.SetFont(boldFont)
 593         dc.SetTextForeground(wx.WHITE)
 594         dc.DrawLabel(self.label, rect, wx.ALIGN_CENTER)
 595 
 596         if wx.Platform == "__WXGTK__":
 597             # Add the Caption.
 598             # Black text.
 599             rect = wx.Rect(rect.x, rect.y,
 600                            rect.width, 21)
 601 
 602         else:
 603             rect = wx.Rect(rect.x, rect.y,
 604                            rect.width, 19)
 605 
 606         gcdc.SetFont(boldFont)
 607         # Get the text color.
 608         dc.SetTextForeground(self.foreground)
 609         dc.DrawLabel(self.label, rect, wx.ALIGN_CENTER)
 610 
 611 
 612     def SetClicked(self, clicked):
 613         """
 614         ...
 615         """
 616 
 617         if clicked != self._clicked:
 618             self._clicked = clicked
 619             self.Refresh()
 620 
 621 
 622     def GetClicked(self):
 623         """
 624         ...
 625         """
 626 
 627         return self._clicked
 628 
 629 
 630     clicked = property(GetClicked, SetClicked)
 631     def OnLeftDown(self, event):
 632         """
 633         ...
 634         """
 635 
 636         x, y = event.GetPosition()
 637         if self.region.Contains(x, y):
 638             self.clicked = True
 639             self.SetFocus()
 640 
 641 
 642     def OnLeftDclick(self, event):
 643         """
 644         ...
 645         """
 646 
 647         self.OnLeftDown(event)
 648 
 649 
 650     def OnLeftUp(self, event):
 651         """
 652         ...
 653         """
 654 
 655         if self.clicked:
 656             x, y = event.GetPosition()
 657             if self.region.Contains(x, y):
 658                 self.PostEvent()
 659         self.clicked = False
 660 
 661 
 662     def OnMotion(self, event):
 663         """
 664         ...
 665         """
 666 
 667         if self.clicked:
 668             x, y = event.GetPosition()
 669             if not self.region.Contains(x, y):
 670                 self.clicked = False
 671 
 672 
 673     def OnLeave(self, event):
 674         """
 675         ...
 676         """
 677 
 678         self.clicked = False
 679 
 680 
 681     def OnSetFocus(self, event):
 682         """
 683         ...
 684         """
 685 
 686         self.color = "white"
 687         self.Refresh()
 688 
 689 
 690     def OnKillFocus(self, event):
 691         """
 692         ...
 693         """
 694 
 695         if wx.Platform == "__WXGTK__":
 696             self.color = "#9e9d9d"
 697 
 698         else:
 699             self.color = "#b1b1b0"
 700 
 701         self.Refresh()
 702 
 703 
 704     def OnKeyUp(self, event):
 705         """
 706         ...
 707         """
 708 
 709         if event.GetKeyCode() == wx.WXK_SPACE:
 710             self.PostEvent()
 711             return
 712 
 713         elif event.GetKeyCode() == wx.WXK_ESCAPE:
 714             self.GetTopLevelParent().OnCloseWindow(True)
 715 
 716         event.Skip()
 717 
 718 #-------------------------------------------------------------------------------
 719 
 720 class MyButtonBox(wx.Panel):
 721     """
 722     Thanks to Cody Precord.
 723     """
 724     def __init__(self, parent, caption):
 725         super(MyButtonBox, self).__init__(parent,
 726                                            style=wx.NO_BORDER |
 727                                            wx.TAB_TRAVERSAL)
 728 
 729         #------------
 730 
 731         # Attributes.
 732         self._caption = caption
 733 
 734         #------------
 735 
 736         # Simplified init method.
 737         self.DoLayout()
 738 
 739     #---------------------------------------------------------------------------
 740 
 741     def DoLayout(self):
 742         """
 743         ...
 744         """
 745 
 746         self._csizer = wx.BoxSizer(wx.VERTICAL)
 747         msizer = wx.BoxSizer(wx.HORIZONTAL)
 748         msizer.Add(self._csizer, 0 )
 749         self.SetSizer(msizer)
 750 
 751 
 752     def DoGetBestSize(self):
 753         """
 754         ...
 755         """
 756 
 757         size = super(MyButtonBox, self).DoGetBestSize()
 758 
 759         # Compensate for wide caption labels.
 760         tw = self.GetTextExtent(self._caption)[0]
 761         size.SetWidth(max(size.width, size.height))
 762         return size
 763 
 764 
 765     def AddItem(self, item):
 766         """
 767         Add a window or sizer item to the MyButtonBox.
 768         """
 769 
 770         self._csizer.Add(item, 0 )
 771 
 772 #-------------------------------------------------------------------------------
 773 
 774 class MyPanel(wx.Panel):
 775     """
 776     Thanks to Cody Precord.
 777     """
 778     def __init__(self, parent):
 779         wx.Panel.__init__(self, parent)
 780 
 781         #------------
 782 
 783         # Return bitmaps folder.
 784         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 785 
 786         #------------
 787 
 788         # Create a timer.
 789         self.timer = wx.Timer(self)
 790         self.timer.Start(1000)
 791         self.Bind(wx.EVT_TIMER, self.OnTimer, self.timer)
 792 
 793         #------------
 794 
 795         # Simplified init method.
 796         self.SetProperties()
 797         self.CreateCtrls()
 798         self.BindEvents()
 799 
 800     #---------------------------------------------------------------------------
 801 
 802     def SetProperties(self):
 803         """
 804         ...
 805         """
 806 
 807         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 808 
 809 
 810     def CreateCtrls(self):
 811         """
 812         ...
 813         """
 814 
 815         # Load an background bitmap.
 816         self.bitmap = wx.Bitmap(os.path.join(self.bitmaps_dir,
 817                                              "skin_main_1.png"),
 818                                 type=wx.BITMAP_TYPE_PNG)
 819 
 820         #------------
 821 
 822         # Buttons box.
 823         self.box1 = MyButtonBox(self, "")   # Button About.
 824         self.box2 = MyButtonBox(self, "")   # Button Quit.
 825 
 826         #------------
 827 
 828         # Buttons bitmap.
 829         bmp1 = wx.Bitmap(os.path.join(self.bitmaps_dir,
 830                                       "btn_exit_normal.png"),
 831                          type=wx.BITMAP_TYPE_PNG)
 832 
 833         bmp2 = wx.Bitmap(os.path.join(self.bitmaps_dir,
 834                                       "btn_exit_pressed.png"),
 835                          type=wx.BITMAP_TYPE_PNG)
 836 
 837         bmp3 = wx.Bitmap(os.path.join(self.bitmaps_dir,
 838                                       "btn_exit_disabled.png"),
 839                          type=wx.BITMAP_TYPE_PNG)
 840 
 841         bmpA = wx.Bitmap(os.path.join(self.bitmaps_dir,
 842                                       "btn_about_normal.png"),
 843                          type=wx.BITMAP_TYPE_PNG)
 844 
 845         bmpB = wx.Bitmap(os.path.join(self.bitmaps_dir,
 846                                       "btn_about_pressed.png"),
 847                          type=wx.BITMAP_TYPE_PNG)
 848 
 849         bmpC = wx.Bitmap(os.path.join(self.bitmaps_dir,
 850                                       "btn_about_disabled.png"),
 851                          type=wx.BITMAP_TYPE_PNG)
 852 
 853         # Buttons panel.
 854         self.btn1 = MyWindow(self.box1, "", "black", "#9e9d9d", bmpA, bmpB, bmpC)
 855         self.btn1.SetToolTip("This is a customized button.")
 856         self.btn1.Bind(wx.EVT_BUTTON, self.OnBtnAbout)
 857         self.btn1.SetFocus() # Necessary for Linux.
 858 
 859         self.btn2 = MyWindow(self.box2, "", "black", "#9e9d9d", bmp1, bmp2, bmp3)
 860         self.btn2.SetToolTip("This is a customized button.")
 861         self.btn2.Bind(wx.EVT_BUTTON, self.OnBtnClose)
 862         # self.btn2.Enable(False)
 863 
 864         # Return main image size.
 865         bw, bh = self.bitmap.GetWidth(), self.bitmap.GetHeight()
 866 
 867         self.box1.AddItem(self.btn1)
 868         self.box2.AddItem(self.btn2)
 869 
 870         self.box1.SetPosition((int((bw-21+170)/2), int(50)))
 871         self.box1.SetSize((21, 21))
 872 
 873         self.box2.SetPosition((int((bw-50)/2), int(415)))
 874         self.box2.SetSize((50, 50))
 875 
 876 
 877     def BindEvents(self):
 878         """
 879         Bind some events to an events handler.
 880         """
 881 
 882         self.Bind(wx.EVT_PAINT, self.OnPaint)
 883         self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
 884 
 885 
 886     def OnEraseBackground(self, event):
 887         """
 888         ...
 889         """
 890 
 891         dc = event.GetDC()
 892         if not dc:
 893             dc = wx.ClientDC(self)
 894             rect = self.GetUpdateRegion().GetBox()
 895             dc.SetClippingRect(rect)
 896 
 897 
 898     def OnBtnAbout(self, event):
 899         """
 900         ...
 901         """
 902 
 903         self.GetParent().OnAbout(True)
 904 
 905         print("About button was clicked.")
 906 
 907 
 908     def OnBtnClose(self, event):
 909         """
 910         ...
 911         """
 912 
 913         self.GetParent().OnCloseWindow(self)
 914 
 915         print("Close button was clicked.")
 916 
 917 
 918     def Draw(self, dc):
 919         """
 920         ...
 921         """
 922 
 923         # Draw a bitmap with an alpha channel
 924         # on top of the last group.
 925         # image, x, y, transparence
 926         dc.DrawBitmap(self.bitmap, 0, 0, True)
 927 
 928         #------------
 929 
 930         fontSize = self.GetFont().GetPointSize()
 931 
 932         # wx.Font(pointSize, family, style, weight, underline, faceName)
 933         if wx.Platform == "__WXMAC__":
 934             self.normalBoldFont = wx.Font(fontSize-1,
 935                                           wx.DEFAULT, wx.NORMAL,
 936                                           wx.NORMAL, False, "")
 937             self.normalFont = wx.Font(fontSize-2,
 938                                           wx.DEFAULT, wx.NORMAL,
 939                                       wx.NORMAL, False, "")
 940 
 941         elif wx.Platform == "__WXGTK__":
 942             self.normalBoldFont = wx.Font(fontSize-1,
 943                                           wx.DEFAULT, wx.NORMAL,
 944                                           wx.NORMAL, False, "")
 945             self.normalFont = wx.Font(fontSize-2,
 946                                       wx.DEFAULT, wx.NORMAL,
 947                                       wx.NORMAL, False, "")
 948 
 949         else:
 950             self.normalBoldFont = wx.Font(fontSize+23,
 951                                           wx.DEFAULT, wx.NORMAL,
 952                                           wx.NORMAL, False, "")
 953             self.normalFont = wx.Font(fontSize+1,
 954                                       wx.DEFAULT, wx.NORMAL,
 955                                       wx.NORMAL, False, "")
 956 
 957         dc.SetFont(self.normalFont)
 958         dc.SetFont(self.normalBoldFont)
 959 
 960         #------------
 961 
 962         # Return main image size.
 963         bw, bh = self.bitmap.GetWidth(), self.bitmap.GetHeight()
 964 
 965         # Draw text.
 966         dc.SetTextForeground("#8e8e8e")
 967         dc.SetFont(self.normalFont)
 968         date = time.strftime("%A %d %B %Y")
 969         tw, th = dc.GetTextExtent(date)
 970         dc.DrawText(date, (int((bw-tw)/2), int(143)))
 971 
 972         dc.SetTextForeground(wx.WHITE)
 973         dc.SetFont(self.normalBoldFont)
 974         hour = time.strftime("%H:%M:%S")  # "%I:%M:%S %p"
 975         tw, th = dc.GetTextExtent(hour)
 976         dc.DrawText(hour, (int((bw-tw)/2), int(100)))
 977 
 978 
 979     def OnTimer(self, event):
 980         """
 981         ...
 982         """
 983 
 984         dc = wx.BufferedDC(wx.ClientDC(self))
 985         self.Draw(dc)
 986         self.Refresh()   # Mac
 987 
 988 
 989     def OnPaint(self, event):
 990         """
 991         ...
 992         """
 993 
 994         dc = wx.BufferedPaintDC(self)
 995         dc.Clear()
 996 
 997         self.Draw(dc)
 998 
 999 #-------------------------------------------------------------------------------
1000 
1001 class MyFrame(wx.Frame):
1002     """
1003     Thanks to Robin Dunn.
1004     """
1005     def __init__(self):
1006         style = (wx.CLIP_CHILDREN | wx.CLOSE_BOX |
1007                  wx.MINIMIZE_BOX | wx.SYSTEM_MENU |
1008                  wx.NO_BORDER | wx.FRAME_SHAPED |
1009                  wx.NO_FULL_REPAINT_ON_RESIZE)
1010         wx.Frame.__init__(self, None, -1, title="", style=style)
1011 
1012         #------------
1013 
1014         # Attributes.
1015         self.SetTransparent(0)
1016         self.opacity_in = 0
1017         self.opacity_out = 250
1018         self.deltaN = -5
1019         self.hasShape = False
1020         self.delta = wx.Point(0,0)
1021 
1022         #------------
1023 
1024         # Return application name.
1025         self.app_name = wx.GetApp().GetAppName()
1026         # Return bitmaps folder.
1027         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
1028         # Return icons folder.
1029         self.icons_dir = wx.GetApp().GetIconsDir()
1030 
1031         #------------
1032 
1033         # Simplified init method.
1034         self.SetProperties()
1035         self.OnTimerIn(self)
1036         self.CreateCtrls()
1037         self.BindEvents()
1038         self.DoLayout()
1039 
1040         #------------
1041 
1042         self.CenterOnScreen(wx.BOTH)
1043 
1044         #------------
1045 
1046         self.Show(True)
1047 
1048     #---------------------------------------------------------------------------
1049 
1050     def OnTimerIn(self, evt):
1051         """
1052         Thanks to Pascal Faut.
1053         """
1054 
1055         self.timer1 = wx.Timer(self, -1)
1056         self.timer1.Start(1)
1057         self.Bind(wx.EVT_TIMER, self.AlphaCycle1, self.timer1)
1058 
1059         print("Fade-in was launched.")
1060 
1061 
1062     def OnTimerOut(self, evt):
1063         """
1064         Thanks to Pascal Faut.
1065         """
1066 
1067         self.timer2 = wx.Timer(self, -1)
1068         self.timer2.Start(1)
1069         self.Bind(wx.EVT_TIMER, self.AlphaCycle2, self.timer2)
1070 
1071         print("Fade-out was launched.")
1072 
1073 
1074     def AlphaCycle1(self, *args):
1075         """
1076         Thanks to Pascal Faut.
1077         """
1078 
1079         self.opacity_in += self.deltaN
1080         if self.opacity_in <= 0:
1081             self.deltaN = -self.deltaN
1082             self.opacity_in = 0
1083 
1084         if self.opacity_in >= 250:
1085             self.deltaN = -self.deltaN
1086             self.opacity_in = 250
1087 
1088             self.timer1.Stop()
1089 
1090         self.SetTransparent(self.opacity_in)
1091 
1092         print("Fade in = {}/255".format(self.opacity_in))
1093 
1094 
1095     def AlphaCycle2(self, *args):
1096         """
1097         Thanks to Pascal Faut.
1098         """
1099 
1100         self.opacity_out += self.deltaN
1101         if self.opacity_out >= 250:
1102             self.deltaN = -self.deltaN
1103             self.opacity_out = 250
1104 
1105         if self.opacity_out <= 0:
1106             self.deltaN = -self.deltaN
1107             self.opacity_out = 0
1108 
1109             self.timer2.Stop()
1110             wx.CallAfter(self.Destroy)
1111             wx.Exit()
1112 
1113         self.SetTransparent(self.opacity_out)
1114 
1115         print("Fade out = {}/255".format(self.opacity_out))
1116 
1117 
1118     def SetProperties(self):
1119         """
1120         ...
1121         """
1122 
1123         self.SetTitle(self.app_name)
1124         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
1125 
1126         frameIcon = wx.Icon(os.path.join(self.icons_dir,
1127                                          "icon_wxWidgets.ico"),
1128                             type=wx.BITMAP_TYPE_ICO)
1129         self.SetIcon(frameIcon)
1130 
1131 
1132     def CreateCtrls(self):
1133         """
1134         ...
1135         """
1136 
1137         self.panel = MyPanel(self)
1138 
1139         #------------
1140 
1141         # Load a background bitmap.
1142         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
1143                                           "skin_main_1.png"),
1144                              type=wx.BITMAP_TYPE_PNG)
1145         mask = wx.Mask(self.bmp, wx.RED)
1146         self.bmp.SetMask(mask)
1147 
1148         self.SetClientSize((self.bmp.GetWidth(), self.bmp.GetHeight()))
1149 
1150         #------------
1151 
1152         if wx.Platform == "__WXGTK__":
1153             # wxGTK requires that the window be created before you can
1154             # set its shape, so delay the call to SetWindowShape until
1155             # this event.
1156             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
1157         else:
1158             # On wxMSW and wxMac the window has
1159             # already been created, so go for it.
1160             self.SetWindowShape()
1161 
1162         # Create an accelerator table.
1163         self.accel_tbl = wx.AcceleratorTable([(wx.ACCEL_CTRL, ord('X'), wx.ID_EXIT),
1164                                               (wx.ACCEL_CTRL, ord('A'), wx.ID_ABOUT)
1165                                              ])
1166         self.SetAcceleratorTable(self.accel_tbl)
1167 
1168 
1169     def BindEvents(self):
1170         """
1171         Bind some events to an events handle.
1172         """
1173 
1174         self.panel.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)  # View mask.
1175         self.panel.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
1176         self.panel.Bind(wx.EVT_RIGHT_UP, self.OnCloseWindow)  # Panel right clic.
1177 
1178         self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
1179         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
1180         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
1181         self.Bind(wx.EVT_MOTION, self.OnMouseMove)
1182 
1183         self.Bind(wx.EVT_MENU, self.OnCloseWindow, id=wx.ID_EXIT)  # Ctrl+X.
1184         self.Bind(wx.EVT_MENU, self.OnAbout, id=wx.ID_ABOUT)
1185 
1186 
1187     def DoLayout(self):
1188         """
1189         ...
1190         """
1191 
1192         sizer = wx.BoxSizer(wx.VERTICAL)
1193         sizer.Add(self.panel, 1, wx.EXPAND)
1194         self.SetSizer(sizer)
1195 
1196 
1197     def OnAbout(self, event):
1198         """
1199         ...
1200         """
1201 
1202         self.dialog = MyAboutDlg(self)
1203 
1204 
1205     def SetWindowShape(self, *evt):
1206         """
1207         ...
1208         """
1209 
1210         # Use the bitmap's mask to determine the region.
1211         r = wx.Region(self.bmp)
1212         self.hasShape = self.SetShape(r)
1213 
1214 
1215     def OnEraseBackground(self, event):
1216         """
1217         ...
1218         """
1219 
1220         dc = event.GetDC()
1221         if not dc:
1222             dc = wx.ClientDC(self)
1223             rect = self.GetUpdateRegion().GetBox()
1224             dc.SetClippingRect(rect)
1225 
1226 
1227     def OnDoubleClick(self, event):
1228         """
1229         ...
1230         """
1231 
1232         if self.hasShape:
1233             self.SetShape(wx.Region())
1234             self.hasShape = False
1235         else:
1236             self.SetWindowShape()
1237 
1238 
1239     def OnLeftDown(self, event):
1240         """
1241         ...
1242         """
1243 
1244         self.CaptureMouse()
1245         x, y = self.ClientToScreen(event.GetPosition())
1246         originx, originy = self.GetPosition()
1247         dx = x - originx
1248         dy = y - originy
1249         self.delta = ((dx, dy))
1250 
1251 
1252     def OnLeftUp(self, evt):
1253         """
1254         ...
1255         """
1256 
1257         if self.HasCapture():
1258             self.ReleaseMouse()
1259 
1260 
1261     def OnMouseMove(self, event):
1262         """
1263         ...
1264         """
1265 
1266         if event.Dragging() and event.LeftIsDown():
1267             x, y = self.ClientToScreen(event.GetPosition())
1268             fp = (x - self.delta[0], y - self.delta[1])
1269             self.Move(fp)
1270 
1271 
1272     def OnIconize(self, event):
1273         """
1274         ...
1275         """
1276 
1277         self.Iconize()
1278 
1279 
1280     def OnCloseWindow(self, event):
1281         """
1282         Quit this application.
1283         """
1284 
1285         # self.Destroy()
1286         self.OnTimerOut(self)
1287 
1288         print("Exit application.")
1289 
1290 #-------------------------------------------------------------------------------
1291 
1292 class MyApp(wx.App):
1293     """
1294     Thanks to Andrea Gavana.
1295     """
1296     def OnInit(self):
1297 
1298         #------------
1299 
1300         self.locale = wx.Locale(wx.LANGUAGE_FRENCH)
1301 
1302         #------------
1303 
1304         self.SetAppName("Custom Gui 1")
1305 
1306         #------------
1307 
1308         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
1309 
1310         #------------
1311 
1312         frame = MyFrame()
1313         self.SetTopWindow(frame)
1314         frame.Show(True)
1315 
1316         return True
1317 
1318     #---------------------------------------------------------------------------
1319 
1320     def GetInstallDir(self):
1321         """
1322         Returns the installation directory for my application.
1323         """
1324 
1325         return self.installDir
1326 
1327 
1328     def GetIconsDir(self):
1329         """
1330         Returns the icons directory for my application.
1331         """
1332 
1333         icons_dir = os.path.join(self.installDir, "icons")
1334         return icons_dir
1335 
1336 
1337     def GetBitmapsDir(self):
1338         """
1339         Returns the bitmaps directory for my application.
1340         """
1341 
1342         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
1343         return bitmaps_dir
1344 
1345 #-------------------------------------------------------------------------------
1346 
1347 def main():
1348     app = MyApp(False)
1349     app.MainLoop()
1350 
1351 #-------------------------------------------------------------------------------
1352 
1353 if __name__ == "__main__" :
1354     main()