How to create a customized splash screen (Phoenix)

Keywords : Splashscreen, Mask, Timeout, Shaped frame, Bitmap, Timer, Gauge, Throbber, Animated gif, Fade in, CallLater, ScreenDC, Alpha.


Demonstrating :

Tested py3.x, wx4.x and Win10.

Are you ready to use some samples ? ;)

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


With gauge :

First example

img_sample_one_a.png

   1 # sample_one_a.py
   2 
   3 import sys
   4 import os
   5 import wx
   6 from   wx.adv import SplashScreen as SplashScreen
   7 
   8 # class MyFrame
   9 # class MySplash
  10 # class MyApp
  11 
  12 #---------------------------------------------------------------------------
  13 
  14 class MyFrame(wx.Frame):
  15     """
  16     ...
  17     """
  18     def __init__(self):
  19         super(MyFrame, self).__init__(None,
  20                                       -1,
  21                                       title="")
  22 
  23         #------------
  24 
  25         # Return application name.
  26         self.app_name = wx.GetApp().GetAppName()
  27         # Return icons folder.
  28         self.icons_dir = wx.GetApp().GetIconsDir()
  29 
  30         #------------
  31 
  32         # Simplified init method.
  33         self.SetProperties()
  34         self.CreateCtrls()
  35         self.BindEvents()
  36         self.DoLayout()
  37 
  38         #------------
  39 
  40         self.CenterOnScreen(wx.BOTH)
  41 
  42         #------------
  43 
  44         self.Show(True)
  45 
  46     #-----------------------------------------------------------------------
  47 
  48     def SetProperties(self):
  49         """
  50         ...
  51         """
  52 
  53         self.SetTitle(self.app_name)
  54         self.SetSize((340, 250))
  55 
  56         #------------
  57 
  58         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  59                                          "icon_wxWidgets.ico"),
  60                             type=wx.BITMAP_TYPE_ICO)
  61         self.SetIcon(frameIcon)
  62 
  63 
  64     def CreateCtrls(self):
  65         """
  66         ...
  67         """
  68 
  69         # Create a panel.
  70         self.panel = wx.Panel(self, -1)
  71 
  72         #------------
  73 
  74         # Add a button.
  75         self.btnClose = wx.Button(self.panel,
  76                                   -1,
  77                                   "&Close")
  78 
  79 
  80     def BindEvents(self):
  81         """
  82         Bind some events to an event handler.
  83         """
  84 
  85         # Bind events to an events handler.
  86         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  87         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  88 
  89 
  90     def DoLayout(self):
  91         """
  92         ...
  93         """
  94 
  95         # MainSizer is the top-level one that manages everything.
  96         mainSizer = wx.BoxSizer(wx.VERTICAL)
  97 
  98         # wx.BoxSizer(window, proportion, flag, border).
  99         # wx.BoxSizer(sizer, proportion, flag, border).
 100         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 101 
 102         # Finally, tell the panel to use the sizer for layout.
 103         self.panel.SetAutoLayout(True)
 104         self.panel.SetSizer(mainSizer)
 105 
 106         mainSizer.Fit(self.panel)
 107 
 108 
 109     def OnCloseMe(self, event):
 110         """
 111         ...
 112         """
 113 
 114         self.Close(True)
 115 
 116 
 117     def OnCloseWindow(self, event):
 118         """
 119         ...
 120         """
 121 
 122         self.Destroy()
 123 
 124 #---------------------------------------------------------------------------
 125 
 126 class MySplash(SplashScreen):
 127     """
 128     ...
 129     """
 130     def __init__(self):
 131 
 132         #--------------
 133 
 134         screen = wx.ScreenDC()
 135 
 136         # Screen size.
 137         ws, hs = screen.GetSize()
 138 
 139         #--------------
 140 
 141         # Return bitmaps folder.
 142         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 143 
 144         # Load a background bitmap.
 145         bitmap = wx.Bitmap(os.path.join(self.bitmaps_dir,
 146                                         "python.png"),
 147                            type=wx.BITMAP_TYPE_PNG)
 148 
 149         # Determine size of bitmap.
 150         wi, hi = bitmap.GetWidth(), bitmap.GetHeight()
 151         print("\n... Bitmap size : %sx%s px" % (wi, hi))
 152 
 153         x = int((ws-wi)/2)
 154         y = int((hs-hi)/2)
 155 
 156         #--------------
 157 
 158         super(MySplash, self).__init__(bitmap=bitmap,
 159                                        splashStyle=wx.adv.SPLASH_CENTRE_ON_SCREEN |
 160                                                    wx.adv.SPLASH_TIMEOUT,
 161                                        milliseconds=8000,
 162                                        parent=None,
 163                                        id=-1,
 164                                        pos=(x, y),
 165                                        size=(wi, hi),
 166                                        style=wx.STAY_ON_TOP |
 167                                              wx.BORDER_NONE)
 168 
 169         #------------
 170 
 171         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 172 
 173         self.count = 0
 174 
 175         wx.Sleep(1)
 176 
 177         #------------
 178 
 179         # Simplified init method.
 180         self.CreateCtrls()
 181         self.BindEvents()
 182 
 183         #------------
 184 
 185         # Create a timer for my gauge.
 186         self.timer = wx.Timer(self)
 187 
 188         # Gauge speed. Simulate long startup time.
 189         self.timer.Start(90)
 190 
 191         self.Bind(wx.EVT_TIMER, self.TimerHandler, self.timer)
 192 
 193         #------------
 194 
 195         print("\n... Display the splashScreen")
 196 
 197         #--------------
 198 
 199         wx.BeginBusyCursor()
 200 
 201     #-----------------------------------------------------------------------
 202 
 203     def CreateCtrls(self):
 204         """
 205         Create some controls for my splash screen.
 206         """
 207 
 208         #------------
 209 
 210         # Put text.
 211         self.text = wx.StaticText(parent=self,
 212                                   id=-1,
 213                                   label="Loading...",
 214                                   pos=(4, 231),
 215                                   size=(252, 18),
 216                                   style=wx.ALIGN_CENTRE_HORIZONTAL)
 217         self.text.SetBackgroundColour(wx.WHITE)
 218 
 219         #------------
 220 
 221         # Put gauge.
 222         self.gauge = wx.Gauge(self,
 223                               id=-1,
 224                               range=50,
 225                               size=(-1, 20))
 226 
 227         #------------
 228 
 229         # Cody Precord... thank you !
 230         rect = self.GetClientRect()
 231         new_size = (rect.width, 20)
 232         self.gauge.SetSize(new_size)
 233         self.SetSize((rect.width, rect.height+20))
 234         self.gauge.SetPosition((0, rect.height))
 235 
 236 
 237     def BindEvents(self):
 238         """
 239         Bind all the events related to my splash screen.
 240         """
 241 
 242         # Bind events to an events handler.
 243         self.Bind(wx.EVT_CLOSE, self.OnClose)
 244 
 245 
 246     def TimerHandler(self, event):
 247         """
 248         ...
 249         """
 250 
 251         self.count = self.count + 1
 252 
 253         if self.count >= 90:
 254             self.count = 0
 255 
 256         self.gauge.SetValue(self.count)
 257         # or
 258         # self.gauge.Pulse()
 259 
 260 
 261     def OnClose(self, event):
 262         """
 263         Close the splash screen.
 264         This method will be called under 2 cases :
 265         1. time-limit is up, called automatically,
 266         2. you left-click on the splash-bitmap.
 267         """
 268 
 269         # Make sure the default handler runs
 270         # too so this window gets destroyed.
 271         # Tell the event system to continue
 272         # looking for an event handler, so the
 273         # default handler will get called.
 274         event.Skip()
 275         self.Hide()
 276 
 277         #------------
 278 
 279         if self.timer.IsRunning():
 280             # Stop the gauge timer.
 281             self.timer.Stop()
 282             # del self.timer
 283             self.ShowMainFrame()
 284 
 285 
 286     def ShowMainFrame(self):
 287         """
 288         ...
 289         """
 290 
 291         print("\n... Close the splash screen")
 292         print("\n... Create and display the main frame")
 293 
 294         #------------
 295 
 296         wx.CallAfter(wx.EndBusyCursor)
 297 
 298         #------------
 299 
 300         # Create an instance of the MyFrame class.
 301         frame = MyFrame()
 302 
 303 #---------------------------------------------------------------------------
 304 
 305 class MyApp(wx.App):
 306     """
 307     ...
 308     """
 309     def OnInit(self):
 310 
 311         #------------
 312 
 313         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 314 
 315         #------------
 316 
 317         self.SetAppName("Main frame")
 318 
 319         #------------
 320 
 321         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 322 
 323         #------------
 324 
 325         splash = MySplash()
 326         splash.Show(True)
 327 
 328         return True
 329 
 330     #-----------------------------------------------------------------------
 331 
 332     def GetInstallDir(self):
 333         """
 334         Returns the installation directory for my application.
 335         """
 336 
 337         return self.installDir
 338 
 339 
 340     def GetIconsDir(self):
 341         """
 342         Returns the icons directory for my application.
 343         """
 344 
 345         icons_dir = os.path.join(self.installDir, "icons")
 346         return icons_dir
 347 
 348 
 349     def GetBitmapsDir(self):
 350         """
 351         Returns the bitmaps directory for my application.
 352         """
 353 
 354         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 355         return bitmaps_dir
 356 
 357 #---------------------------------------------------------------------------
 358 
 359 def main():
 360     app = MyApp(False)
 361     app.MainLoop()
 362 
 363 #---------------------------------------------------------------------------
 364 
 365 if __name__ == "__main__" :
 366     main()


Second example

img_sample_one_b.png

   1 # sample_one_b.py
   2 
   3 import os
   4 import sys
   5 import platform
   6 import wx
   7 
   8 # class MyFrame
   9 # class MyCaptionBox
  10 # class MyPanel
  11 # class MySplash
  12 # class MyApp
  13 
  14 #---------------------------------------------------------------------------
  15 
  16 class MyFrame(wx.Frame):
  17     """
  18     ...
  19     """
  20     def __init__(self):
  21         super(MyFrame, self).__init__(None,
  22                                       -1,
  23                                       title="")
  24 
  25         #------------
  26 
  27         # Return application name.
  28         self.app_name = wx.GetApp().GetAppName()
  29         # Return icons folder.
  30         self.icons_dir = wx.GetApp().GetIconsDir()
  31 
  32         #------------
  33 
  34         # Simplified init method.
  35         self.SetProperties()
  36         self.CreateCtrls()
  37         self.BindEvents()
  38         self.DoLayout()
  39 
  40         #------------
  41 
  42         self.CenterOnScreen(wx.BOTH)
  43 
  44         #------------
  45 
  46         self.Show(True)
  47 
  48     #-----------------------------------------------------------------------
  49 
  50     def SetProperties(self):
  51         """
  52         ...
  53         """
  54 
  55         self.SetTitle(self.app_name)
  56         self.SetSize((340, 250))
  57 
  58         #------------
  59 
  60         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  61                                          "icon_wxWidgets.ico"),
  62                             type=wx.BITMAP_TYPE_ICO)
  63         self.SetIcon(frameIcon)
  64 
  65 
  66     def CreateCtrls(self):
  67         """
  68         ...
  69         """
  70 
  71         # Create a panel.
  72         self.panel = wx.Panel(self, -1)
  73 
  74         #------------
  75 
  76         # Add a buttons.
  77         self.btnClose = wx.Button(self.panel,
  78                                   -1,
  79                                   "&Close")
  80 
  81 
  82     def BindEvents(self):
  83         """
  84         Bind some events to an events handler.
  85         """
  86 
  87         # Bind events to an events handler.
  88         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  89         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  90 
  91 
  92     def DoLayout(self):
  93         """
  94         ...
  95         """
  96 
  97         # MainSizer is the top-level one that manages everything.
  98         mainSizer = wx.BoxSizer(wx.VERTICAL)
  99 
 100         # wx.BoxSizer(window, proportion, flag, border)
 101         # wx.BoxSizer(sizer, proportion, flag, border)
 102         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 103 
 104         # Finally, tell the panel to use the sizer for layout.
 105         self.panel.SetAutoLayout(True)
 106         self.panel.SetSizer(mainSizer)
 107 
 108         mainSizer.Fit(self.panel)
 109 
 110 
 111     def OnCloseMe(self, event):
 112         """
 113         ...
 114         """
 115 
 116         self.Close(True)
 117 
 118 
 119     def OnCloseWindow(self, event):
 120         """
 121         ...
 122         """
 123 
 124         self.Destroy()
 125         wx.Exit()
 126 
 127 #---------------------------------------------------------------------------
 128 
 129 class MyCaptionBox(wx.Panel):
 130     """
 131     ...
 132     """
 133     def __init__(self, parent, caption):
 134         super(MyCaptionBox, self).__init__(parent,
 135                                            style=wx.NO_BORDER |
 136                                                  wx.TAB_TRAVERSAL)
 137 
 138         #------------
 139 
 140         self.SetBackgroundColour("#344050")
 141 
 142         #------------
 143 
 144         # Attributes.
 145         self._caption = caption
 146         self._csizer = wx.BoxSizer(wx.VERTICAL)
 147 
 148         #------------
 149 
 150         # Simplified init method.
 151         self.BindEvents()
 152         self.DoLayout()
 153 
 154     #-----------------------------------------------------------------------
 155 
 156     def BindEvents(self):
 157         """
 158         ...
 159         """
 160 
 161         # Bind events to an events handler.
 162         self.Bind(wx.EVT_PAINT, self.OnPaint)
 163 
 164 
 165     def DoLayout(self):
 166         """
 167         ...
 168         """
 169 
 170         msizer = wx.BoxSizer(wx.HORIZONTAL)
 171         self._csizer.AddSpacer(15) # Extra space for caption.
 172         msizer.Add(self._csizer, 0, wx.EXPAND|wx.ALL, 0)
 173         self.SetSizer(msizer)
 174 
 175 
 176     def DoGetBestSize(self):
 177         """
 178         ...
 179         """
 180 
 181         size = super(MyCaptionBox, self).DoGetBestSize()
 182         # Compensate for wide caption labels.
 183         tw = self.GetTextExtent(self._caption)[0]
 184         size.SetWidth(max(size.width, tw))
 185         return size
 186 
 187 
 188     def AddItem(self, item):
 189         """
 190         Add a window or sizer item to the caption box.
 191         """
 192 
 193         self._csizer.Add(item, 0, wx.ALL, 5)
 194 
 195 
 196     def OnPaint(self, event):
 197         """
 198         Draws the Caption and border around the controls.
 199         """
 200 
 201         dc = wx.BufferedPaintDC(self)
 202         dc.SetBackground(wx.Brush(wx.BLACK))
 203         dc.Clear()
 204         gcdc = wx.GCDC(dc)
 205 
 206         # Get the working rectangle we can draw in.
 207         rect = self.GetClientRect()
 208 
 209         # Get the sytem color to draw the caption.
 210         ss = wx.SystemSettings
 211         color = ss.GetColour(wx.SYS_COLOUR_3DDKSHADOW)
 212         gcdc.SetTextForeground(wx.WHITE)
 213 
 214         # Draw the border.
 215         rect.Inflate(-0, -0)
 216         gcdc.SetPen(wx.Pen(color))
 217         gcdc.SetBrush(wx.Brush(wx.Colour(70, 70, 70, 255)))
 218         gcdc.DrawRoundedRectangle(rect, 5)
 219 
 220         # Font size and style.
 221         font = self.GetFont().GetPointSize()
 222         font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
 223         font.SetWeight(wx.BOLD)
 224 
 225         # Add the Caption.
 226         rect = wx.Rect(rect.x, rect.y, rect.width, 20)
 227         rect.Inflate(-5, 0)
 228         gcdc.SetFont(font)
 229         gcdc.DrawLabel(self._caption, rect, wx.ALIGN_CENTER)
 230 
 231 #---------------------------------------------------------------------------
 232 
 233 class MyPanel(wx.Panel):
 234     """
 235     ...
 236     """
 237     def __init__(self, parent):
 238         wx.Panel.__init__(self, parent)
 239 
 240         #------------
 241 
 242         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 243 
 244         #------------
 245 
 246         # Return bitmaps folder.
 247         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 248 
 249         # Load a background bitmap.
 250         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 251                                           "rocket.png"),
 252                              type=wx.BITMAP_TYPE_PNG)
 253 
 254         #------------
 255 
 256         # Attributes.
 257         self.box1 = MyCaptionBox(self, "Loading...")
 258 
 259         #------------
 260 
 261         # Put a gauge in the box.
 262         self.count = 0
 263 
 264         self.gauge = wx.Gauge(self.box1,
 265                               id=-1,
 266                               range=20,
 267                               size=(155, 15))
 268         self.box1.AddItem(self.gauge)
 269 
 270         #------------
 271 
 272         # Create a timer for my gauge.
 273         self.timer = wx.Timer(self)
 274 
 275         # Gauge speed. Simulate long startup time.
 276         self.timer.Start(90)
 277 
 278         self.Bind(wx.EVT_TIMER, self.TimerHandler, self.timer)
 279 
 280         #------------
 281 
 282         # Simplified init method.
 283         self.BindEvents()
 284         self.DoLayout()
 285 
 286         #------------
 287 
 288         self.SetClientSize((514, 386))
 289 
 290     #-----------------------------------------------------------------------
 291 
 292     def BindEvents(self):
 293         """
 294         ...
 295         """
 296 
 297         # Bind event to an events handler.
 298         self.Bind(wx.EVT_PAINT, self.OnPaint)
 299         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
 300         self.box1.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 301         self.gauge.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 302 
 303 
 304     def DoLayout(self):
 305         """
 306         ...
 307         """
 308 
 309         hsizer = wx.BoxSizer(wx.HORIZONTAL)
 310         vsizer = wx.BoxSizer(wx.VERTICAL)
 311 
 312         #------------
 313 
 314         # Add the box to the panel.
 315         hsizer.AddStretchSpacer()
 316         hsizer.Add(self.box1, 0, wx.EXPAND)
 317         hsizer.AddSpacer(0)
 318         vsizer.AddStretchSpacer()
 319         vsizer.Add(hsizer, 0, wx.EXPAND|wx.ALL, 15)
 320 
 321         self.SetSizer(vsizer)
 322 
 323 
 324     def OnPaint(self, event):
 325         """
 326         ...
 327         """
 328 
 329         dc = wx.BufferedPaintDC(self)
 330         dc.Clear()
 331         gcdc = wx.GCDC(dc)
 332         gcdc.Clear()
 333 
 334         # Draw a bitmap with an alpha channel
 335         # on top of the last group.
 336         gcdc.DrawBitmap(self.bmp, 0, 0, False)
 337 
 338 
 339     def TimerHandler(self, event):
 340         """
 341         ...
 342         """
 343 
 344         self.count = self.count + 1
 345 
 346         if self.count >= 90:
 347             self.count = 0
 348 
 349         self.gauge.SetValue(self.count)
 350         # or
 351         # self.gauge.Pulse()
 352 
 353 
 354     def OnMouseEvents(self, event):
 355         """
 356         Handles the wx.EVT_MOUSE_EVENTS for AdvancedSplash.
 357         This reproduces the behavior of wx.SplashScreen.
 358         """
 359 
 360         if event.LeftDown() or event.RightDown():
 361             splash = wx.GetApp().GetTopWindow()
 362             splash.OnClose(event)
 363 
 364         event.Skip()
 365 
 366 
 367     def OnDestroy(self, event):
 368         """
 369         ...
 370         """
 371 
 372         event.Skip()
 373 
 374 #---------------------------------------------------------------------------
 375 
 376 class MySplash(wx.Frame):
 377     """
 378     ...
 379     """
 380     def __init__(self):
 381 
 382         #--------------
 383 
 384         screen = wx.ScreenDC()
 385 
 386         # Screen size.
 387         ws, hs = screen.GetSize()
 388 
 389         #--------------
 390 
 391         # Return bitmaps folder.
 392         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 393 
 394         # Load a background bitmap.
 395         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 396                                           "rocket.png"),
 397                              type=wx.BITMAP_TYPE_PNG)
 398 
 399         mask = wx.Mask(self.bmp, wx.RED)
 400         self.bmp.SetMask(mask)
 401 
 402         # Determine size of bitmap.
 403         wi, hi = self.bmp.GetWidth(), self.bmp.GetHeight()
 404         print("\n... Bitmap size : %sx%s px" % (wi, hi))
 405 
 406         x = int((ws-wi)/2)
 407         y = int((hs-hi)/2)
 408 
 409         #--------------
 410 
 411         super(MySplash, self).__init__(parent=None,
 412                                        id=-1,
 413                                        title="SplashScreen",
 414                                        pos=(x, y),
 415                                        size=(wi, hi),
 416                                        style=wx.FRAME_SHAPED |
 417                                              wx.BORDER_NONE |
 418                                              wx.FRAME_NO_TASKBAR |
 419                                              wx.STAY_ON_TOP)
 420 
 421         #--------------
 422 
 423         self.SetBackgroundColour("#344050")
 424 
 425         #--------------
 426 
 427         # Attributes.
 428         self.SetTransparent(0)
 429         self.opacity_in = 0
 430         self.deltaN = -30
 431         self.hasShape = False
 432 
 433         #--------------
 434 
 435         if wx.Platform != "__WXMAC__":
 436             # wxMac clips the tooltip to the window shape, YUCK!!!
 437             self.SetToolTip("Right-click to close the window\n"
 438                             "Double-click the image to set/unset the window shape")
 439 
 440         if wx.Platform == "__WXGTK__":
 441             # wxGTK requires that the window be created before you can
 442             # set its shape, so delay the call to SetWindowShape until
 443             # this event.
 444             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 445         else:
 446             # On wxMSW and wxMac the window has already
 447             # been created, so go for it.
 448             self.SetWindowShape()
 449 
 450         #--------------
 451 
 452         # Starts the Timer. Once Expired, splash is Destroyed.
 453         self.timer = wx.Timer(self)
 454 
 455         # Simulate long startup time.
 456         self.timer.Start(4000)
 457 
 458         self.Bind(wx.EVT_TIMER, self.TimeOut, self.timer)
 459 
 460         #--------------
 461 
 462         # Show main frame after 3000 ms.
 463         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 464 
 465         #--------------
 466 
 467         self.CenterOnScreen(wx.BOTH)
 468         self.Show(True)
 469 
 470         #--------------
 471 
 472         # Simplified init method.
 473         self.OnTimerIn(self)
 474         self.CreateCtrls()
 475         self.DoLayout()
 476 
 477         #--------------
 478 
 479         print("\n... Display the splashScreen")
 480 
 481         #--------------
 482 
 483         self.SetClientSize((wi, hi))
 484         wx.BeginBusyCursor()
 485 
 486     #-----------------------------------------------------------------------
 487 
 488     def OnTimerIn(self, evt):
 489         """
 490         Thanks to Pascal Faut.
 491         """
 492 
 493         self.timer1 = wx.Timer(self, -1)
 494         self.timer1.Start(1)
 495         self.Bind(wx.EVT_TIMER, self.AlphaCycle1, self.timer1)
 496 
 497         print("Fade-in was launched.")
 498 
 499 
 500     def AlphaCycle1(self, *args):
 501         """
 502         Thanks to Pascal Faut.
 503         """
 504 
 505         self.opacity_in += self.deltaN
 506         if self.opacity_in <= 0:
 507             self.deltaN = -self.deltaN
 508             self.opacity_in = 0
 509 
 510         if self.opacity_in >= 255:
 511             self.deltaN = -self.deltaN
 512             self.opacity_in = 255
 513 
 514             self.timer1.Stop()
 515 
 516         self.SetTransparent(self.opacity_in)
 517 
 518         print("Fade in = {}/255".format(self.opacity_in))
 519 
 520 
 521     def CreateCtrls(self):
 522         """
 523         ...
 524         """
 525 
 526         self.panel = MyPanel(self)
 527 
 528 
 529     def BindEvents(self):
 530         """
 531         Bind all the events related to my app.
 532         """
 533 
 534         # Bind some events to an events handler.
 535         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 536         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 537         self.panel.Bind(wx.EVT_LEFT_DOWN, self.OnClose)
 538 
 539 
 540     def DoLayout(self):
 541         """
 542         ...
 543         """
 544 
 545         sizer = wx.BoxSizer(wx.VERTICAL)
 546         sizer.Add(self.panel, 1, wx.EXPAND)
 547         self.SetSizer(sizer)
 548 
 549 
 550     def SetWindowShape(self, *evt):
 551         """
 552         ...
 553         """
 554 
 555         # Use the bitmap's mask to determine the region.
 556         r = wx.Region(self.bmp)
 557         self.hasShape = self.SetShape(r)
 558 
 559 
 560     def OnCharEvents(self, event):
 561         """
 562         Handles the wx.EVT_CHAR for Splash.
 563         This reproduces the behavior of wx.SplashScreen.
 564         """
 565 
 566         self.OnClose(event)
 567 
 568 
 569     def TimeOut(self, event):
 570         """
 571         ...
 572         """
 573 
 574         self.Close(True)
 575 
 576 
 577     def OnCloseWindow(self, event):
 578         """
 579         ...
 580         """
 581 
 582         print("\n... Close timer")
 583 
 584         #--------------
 585 
 586         if hasattr(self, "timer"):
 587             self.Show(False)
 588             self.timer.Stop()
 589             del self.timer
 590 
 591 
 592     def OnClose(self, event):
 593         """
 594         Handles the wx.EVT_CLOSE event for SplashScreen.
 595         """
 596 
 597         # Make sure the default handler runs
 598         # too so this window gets destroyed.
 599         # Tell the event system to continue
 600         # looking for an event handler, so the
 601         # default handler will get called.
 602         event.Skip()
 603         self.Hide()
 604 
 605         #------------
 606 
 607         # If the timer is still running then go
 608         # ahead and show the main frame now.
 609         if self.fc.IsRunning():
 610             # Stop the wx.CallLater timer.
 611             # Stop the splash screen timer
 612             # and close it.
 613             self.fc.Stop()
 614             self.ShowMainFrame()
 615 
 616 
 617     def ShowMainFrame(self):
 618         """
 619         ...
 620         """
 621 
 622         print("\n... Close the splash screen")
 623         print("\n... Create and display the main frame")
 624 
 625         #------------
 626 
 627         wx.CallAfter(wx.EndBusyCursor)
 628 
 629         #------------
 630 
 631         if self.fc.IsRunning():
 632             # Stop the splash screen
 633             # timer and close it.
 634             self.Raise()
 635 
 636         #------------
 637 
 638         # Create an instance of the MyFrame class.
 639         frame = MyFrame()
 640 
 641 #---------------------------------------------------------------------------
 642 
 643 class MyApp(wx.App):
 644     """
 645     ...
 646     """
 647     def OnInit(self):
 648 
 649         #------------
 650 
 651         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 652 
 653         #------------
 654 
 655         self.SetAppName("Main frame")
 656 
 657         #------------
 658 
 659         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 660 
 661         #------------
 662 
 663         splash = MySplash()
 664         splash.BindEvents()
 665         splash.CenterOnScreen(wx.BOTH)
 666 
 667         return True
 668 
 669     #-----------------------------------------------------------------------
 670 
 671     def GetInstallDir(self):
 672         """
 673         Returns the installation directory for my application.
 674         """
 675 
 676         return self.installDir
 677 
 678 
 679     def GetIconsDir(self):
 680         """
 681         Returns the icons directory for my application.
 682         """
 683 
 684         icons_dir = os.path.join(self.installDir, "icons")
 685         return icons_dir
 686 
 687 
 688     def GetBitmapsDir(self):
 689         """
 690         Returns the bitmaps directory for my application.
 691         """
 692 
 693         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 694         return bitmaps_dir
 695 
 696 #---------------------------------------------------------------------------
 697 
 698 def main():
 699     app = MyApp(False)
 700     app.MainLoop()
 701 
 702 #---------------------------------------------------------------------------
 703 
 704 if __name__ == "__main__" :
 705     main()


With shadow

img_sample_two.png

   1 # sample_two.py
   2 
   3 import sys
   4 import os
   5 import wx
   6 from   wx.adv import SplashScreen as SplashScreen
   7 
   8 # class MyFrame
   9 # class MySplash
  10 # class MyApp
  11 
  12 #---------------------------------------------------------------------------
  13 
  14 class MyFrame(wx.Frame):
  15     """
  16     ...
  17     """
  18     def __init__(self):
  19         super(MyFrame, self).__init__(None,
  20                                       -1,
  21                                       title="")
  22 
  23         #------------
  24 
  25         # Return application name.
  26         self.app_name = wx.GetApp().GetAppName()
  27         # Return icons folder.
  28         self.icons_dir = wx.GetApp().GetIconsDir()
  29 
  30         #------------
  31 
  32         # Simplified init method.
  33         self.SetProperties()
  34         self.CreateCtrls()
  35         self.BindEvents()
  36         self.DoLayout()
  37 
  38         #------------
  39 
  40         self.CenterOnScreen(wx.BOTH)
  41 
  42         #------------
  43 
  44         self.Show(True)
  45 
  46     #-----------------------------------------------------------------------
  47 
  48     def SetProperties(self):
  49         """
  50         ...
  51         """
  52 
  53         self.SetTitle(self.app_name)
  54         self.SetSize((340, 250))
  55 
  56         #------------
  57 
  58         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  59                                          "icon_wxWidgets.ico"),
  60                             type=wx.BITMAP_TYPE_ICO)
  61         self.SetIcon(frameIcon)
  62 
  63 
  64     def CreateCtrls(self):
  65         """
  66         ...
  67         """
  68 
  69         # Create a panel.
  70         self.panel = wx.Panel(self, -1)
  71 
  72         #------------
  73 
  74         # Add a button.
  75         self.btnClose = wx.Button(self.panel,
  76                                   -1,
  77                                   "&Close")
  78 
  79 
  80     def BindEvents(self):
  81         """
  82         Bind some events to an events handler.
  83         """
  84 
  85         # Bind events to an events handler.
  86         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  87         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  88 
  89 
  90     def DoLayout(self):
  91         """
  92         ...
  93         """
  94 
  95         # MainSizer is the top-level one that manages everything.
  96         mainSizer = wx.BoxSizer(wx.VERTICAL)
  97 
  98         # wx.BoxSizer(window, proportion, flag, border)
  99         # wx.BoxSizer(sizer, proportion, flag, border)
 100         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 101 
 102         # Finally, tell the panel to use the sizer for layout.
 103         self.panel.SetAutoLayout(True)
 104         self.panel.SetSizer(mainSizer)
 105 
 106         mainSizer.Fit(self.panel)
 107 
 108 
 109     def OnCloseMe(self, event):
 110         """
 111         ...
 112         """
 113 
 114         self.Close(True)
 115 
 116 
 117     def OnCloseWindow(self, event):
 118         """
 119         ...
 120         """
 121 
 122         self.Destroy()
 123 
 124 #---------------------------------------------------------------------------
 125 
 126 class MySplash(SplashScreen):
 127     """
 128     ...
 129     """
 130     def __init__(self):
 131 
 132         self.SaveScreen()
 133 
 134         #------------
 135 
 136         # Return bitmaps folder.
 137         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 138 
 139         #------------
 140 
 141         # Load a background bitmap.
 142         bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 143                                      "splashscreen.bmp"),
 144                         type=wx.BITMAP_TYPE_BMP)
 145 
 146         # Determine size of bitmap.
 147         imgSize = (bmp.GetWidth(), bmp.GetHeight())
 148         print("\n... Bitmap size : %sx%s px" % (imgSize))
 149 
 150         #------------
 151 
 152         super(MySplash, self).__init__(bitmap=bmp,
 153                                        splashStyle=wx.adv.SPLASH_TIMEOUT,
 154                                        milliseconds=4000,
 155                                        parent=None,
 156                                        id=-1,
 157                                        pos=wx.DefaultPosition,
 158                                        size=imgSize,
 159                                        style=wx.STAY_ON_TOP |
 160                                              wx.BORDER_NONE)
 161 
 162         #------------
 163 
 164         # Simplified init method.
 165         self.BindEvents()
 166 
 167         #------------
 168 
 169         print("\n... Display the splashScreen")
 170 
 171         #--------------
 172 
 173         wx.BeginBusyCursor()
 174 
 175     #-----------------------------------------------------------------------
 176 
 177     def BindEvents(self):
 178         """
 179         ...
 180         """
 181 
 182         # Bind events to an events handler.
 183         self.Bind(wx.EVT_CLOSE, self.OnClose)
 184 
 185 
 186     def SaveScreen(self):
 187         """
 188         ...
 189         """
 190 
 191         # Return bitmaps folder.
 192         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 193 
 194         # Load a bitmap.
 195         bmp2 = wx.Bitmap(os.path.join(self.bitmaps_dir,
 196                                       "shadow.png"),
 197                          type=wx.BITMAP_TYPE_PNG)
 198 
 199         # Bitmap size.
 200         w2, h2 = bmp2.GetSize()
 201 
 202         #------------
 203 
 204         # Create a screenshot.
 205         screen = wx.ScreenDC()
 206 
 207         # Screen size.
 208         w, h = screen.GetSize()
 209         print("\n... Screen size : %sx%s px" % (w, h))
 210 
 211         bmp = wx.Bitmap(w, h)
 212 
 213         mem = wx.MemoryDC(screen)
 214         mem.SelectObject(bmp)
 215         mem.Blit(0, 0, w, h, screen, 0, 0)
 216         # Draw a bitmap with an alpha
 217         # channel on the screenshot.
 218         # image, x, y, transparency.
 219         mem.DrawBitmap(bmp2, int((w-w2)/2), int((h-h2)/2), False)
 220         mem.SelectObject(wx.NullBitmap)
 221 
 222         #------------
 223 
 224         # Save a background bitmap for splashscreen.
 225         bmp.SaveFile(os.path.join(self.bitmaps_dir,
 226                                   "splashscreen.bmp"),
 227                      type=wx.BITMAP_TYPE_BMP)
 228 
 229 
 230     def OnClose(self, event):
 231         """
 232         Close the splash screen.
 233         This method will be called under 2 cases :
 234         1. time-limit is up, called automatically,
 235         2. you left-click on the splash-bitmap.
 236         """
 237 
 238         # Make sure the default handler runs
 239         # too so this window gets destroyed.
 240         # Tell the event system to continue
 241         # looking for an event handler, so the
 242         # default handler will get called.
 243         event.Skip()
 244         self.Hide()
 245 
 246         #------------
 247 
 248         self.ShowMainFrame()
 249 
 250 
 251     def ShowMainFrame(self):
 252         """
 253         ...
 254         """
 255 
 256         print("\n... Close the splash screen")
 257         print("\n... Create and display the main frame")
 258 
 259         #------------
 260 
 261         wx.CallAfter(wx.EndBusyCursor)
 262 
 263         #------------
 264 
 265         # Create an instance of the MyFrame class.
 266         frame = MyFrame()
 267 
 268 #---------------------------------------------------------------------------
 269 
 270 class MyApp(wx.App):
 271     """
 272     ...
 273     """
 274     def OnInit(self):
 275 
 276         #------------
 277 
 278         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 279 
 280         #------------
 281 
 282         self.SetAppName("Main frame")
 283 
 284         #------------
 285 
 286         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 287 
 288         #------------
 289 
 290         splash = MySplash()
 291         splash.Show(True)
 292 
 293         return True
 294 
 295     #-----------------------------------------------------------------------
 296 
 297     def GetInstallDir(self):
 298         """
 299         Returns the installation directory for my application.
 300         """
 301 
 302         return self.installDir
 303 
 304 
 305     def GetIconsDir(self):
 306         """
 307         Returns the icons directory for my application.
 308         """
 309 
 310         icons_dir = os.path.join(self.installDir, "icons")
 311         return icons_dir
 312 
 313 
 314     def GetBitmapsDir(self):
 315         """
 316         Returns the bitmaps directory for my application.
 317         """
 318 
 319         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 320         return bitmaps_dir
 321 
 322 #---------------------------------------------------------------------------
 323 
 324 def main():
 325     app = MyApp(False)
 326     app.MainLoop()
 327 
 328 #---------------------------------------------------------------------------
 329 
 330 if __name__ == "__main__" :
 331     main()


With throbber

img_sample_three.png

THROBBER file : throb_images.py

   1 # sample_three.py
   2 
   3 import os
   4 import sys
   5 import wx
   6 import wx.lib.throbber as throb
   7 import throb_images
   8 
   9 # class MyFrame
  10 # class MyCaptionBox
  11 # class MyPanel
  12 # class MySplash
  13 # class MyApp
  14 
  15 #---------------------------------------------------------------------------
  16 
  17 class MyFrame(wx.Frame):
  18     """
  19     ...
  20     """
  21     def __init__(self):
  22         super(MyFrame, self).__init__(None,
  23                                       -1,
  24                                       title="")
  25 
  26         #------------
  27 
  28         # Return application name.
  29         self.app_name = wx.GetApp().GetAppName()
  30         # Return icons folder.
  31         self.icons_dir = wx.GetApp().GetIconsDir()
  32 
  33         #------------
  34 
  35         # Simplified init method.
  36         self.SetProperties()
  37         self.CreateCtrls()
  38         self.BindEvents()
  39         self.DoLayout()
  40 
  41         #------------
  42 
  43         self.CenterOnScreen(wx.BOTH)
  44 
  45         #------------
  46 
  47         self.Show(True)
  48 
  49     #-----------------------------------------------------------------------
  50 
  51     def SetProperties(self):
  52         """
  53         ...
  54         """
  55 
  56         self.SetTitle(self.app_name)
  57         self.SetSize((340, 250))
  58 
  59         #------------
  60 
  61         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  62                                          "icon_wxWidgets.ico"),
  63                             type=wx.BITMAP_TYPE_ICO)
  64         self.SetIcon(frameIcon)
  65 
  66 
  67     def CreateCtrls(self):
  68         """
  69         ...
  70         """
  71 
  72         # Create a panel.
  73         self.panel = wx.Panel(self, -1)
  74 
  75         #------------
  76 
  77         # Add a buttons.
  78         self.btnClose = wx.Button(self.panel,
  79                                   -1,
  80                                   "&Close")
  81 
  82 
  83     def BindEvents(self):
  84         """
  85         Bind some events to an events handler.
  86         """
  87 
  88         # Bind events to an events handler.
  89         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  90         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  91 
  92 
  93     def DoLayout(self):
  94         """
  95         ...
  96         """
  97 
  98         # MainSizer is the top-level one that manages everything.
  99         mainSizer = wx.BoxSizer(wx.VERTICAL)
 100 
 101         # wx.BoxSizer(window, proportion, flag, border)
 102         # wx.BoxSizer(sizer, proportion, flag, border)
 103         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 104 
 105         # Finally, tell the panel to use the sizer for layout.
 106         self.panel.SetAutoLayout(True)
 107         self.panel.SetSizer(mainSizer)
 108 
 109         mainSizer.Fit(self.panel)
 110 
 111 
 112     def OnCloseMe(self, event):
 113         """
 114         ...
 115         """
 116 
 117         self.Close(True)
 118 
 119 
 120     def OnCloseWindow(self, event):
 121         """
 122         ...
 123         """
 124 
 125         self.Destroy()
 126 
 127 #---------------------------------------------------------------------------
 128 
 129 class MyCaptionBox(wx.Panel):
 130     """
 131     ...
 132     """
 133     def __init__(self, parent, caption):
 134         super(MyCaptionBox, self).__init__(parent,
 135                                            style=wx.NO_BORDER |
 136                                                  wx.TAB_TRAVERSAL)
 137 
 138         #------------
 139 
 140         self.SetBackgroundColour("#344050")
 141 
 142         #------------
 143 
 144         # Attributes.
 145         self._caption = caption
 146         self._csizer = wx.BoxSizer(wx.VERTICAL)
 147 
 148         #------------
 149 
 150         # Simplified init method.
 151         self.BindEvents()
 152         self.DoLayout()
 153 
 154     #-----------------------------------------------------------------------
 155 
 156     def BindEvents(self):
 157         """
 158         ...
 159         """
 160 
 161         # Bind events to an events handler.
 162         self.Bind(wx.EVT_PAINT, self.OnPaint)
 163 
 164 
 165     def DoLayout(self):
 166         """
 167         ...
 168         """
 169 
 170         msizer = wx.BoxSizer(wx.HORIZONTAL)
 171         self._csizer.AddSpacer(15) # Extra space for caption.
 172         msizer.Add(self._csizer, 0, wx.EXPAND)
 173         self.SetSizer(msizer)
 174 
 175 
 176     def DoGetBestSize(self):
 177         """
 178         ...
 179         """
 180 
 181         size = super(MyCaptionBox, self).DoGetBestSize()
 182         # Compensate for wide caption labels.
 183         tw = self.GetTextExtent(self._caption)[0]
 184         size.SetWidth(max(size.width, tw))
 185         return size
 186 
 187 
 188     def AddItem(self, item):
 189         """
 190         Add a window or sizer item to the caption box.
 191         """
 192 
 193         self._csizer.Add(item, 0, wx.ALL, 10)
 194 
 195 
 196     def OnPaint(self, event):
 197         """
 198         Draws the Caption and border around the controls.
 199         """
 200 
 201         dc = wx.BufferedPaintDC(self)
 202         dc.SetBackground(wx.Brush(wx.Colour(52, 64, 80, 255)))
 203         dc.Clear()
 204         gcdc = wx.GCDC(dc)
 205 
 206         # Get the working rectangle we can draw in.
 207         rect = self.GetClientRect()
 208 
 209         # Get the system color to draw the caption.
 210         ss = wx.SystemSettings
 211         color = ss.GetColour(wx.SYS_COLOUR_3DDKSHADOW)
 212         gcdc.SetTextForeground(color)
 213         
 214         # Draw the border.
 215         rect.Inflate(-0, -0)
 216         gcdc.SetPen(wx.Pen(color))
 217         gcdc.SetBrush(wx.Brush(wx.Colour(52, 64, 80, 255)))
 218 
 219         # Font size and style.
 220         font = self.GetFont().GetPointSize()
 221         font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
 222         font.SetWeight(wx.BOLD)
 223 
 224         # Add the Caption.
 225         rect = wx.Rect(rect.x, rect.y, rect.width, rect.height-34)
 226         rect.Inflate(-5, 0)
 227         gcdc.SetFont(font)
 228         gcdc.DrawLabel(self._caption, rect, wx.ALIGN_CENTER)
 229 
 230 #---------------------------------------------------------------------------
 231 
 232 class MyPanel(wx.Panel):
 233     """
 234     ...
 235     """
 236     def __init__(self, parent):
 237         wx.Panel.__init__(self, parent)
 238 
 239         #------------
 240 
 241         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 242 
 243         #------------
 244 
 245         # Return bitmaps folder.
 246         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 247 
 248         # Load a background bitmap.
 249         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 250                                           "throbber.png"),
 251                              type=wx.BITMAP_TYPE_PNG)
 252 
 253         #------------
 254 
 255         # Attributes.
 256         self.box1 = MyCaptionBox(self, "Loading...")
 257 
 258         #------------
 259 
 260         # Throbber image list.
 261         self.images = [throb_images.catalog[img].GetBitmap()
 262                        for img in throb_images.index
 263                        if img not in ["eclouds", "logo"]]
 264 
 265 
 266         # Put a throbber in the box.
 267         self.throb = throb.Throbber(self.box1,
 268                                     -1,
 269                                     self.images,
 270                                     frameDelay=0.1,
 271                                     rest=4)
 272         self.box1.AddItem(self.throb)
 273 
 274         self.throb.Start()
 275 
 276         #------------
 277 
 278         # Simplified init method.
 279         self.BindEvents()
 280         self.DoLayout()
 281 
 282         #------------
 283 
 284         self.SetClientSize((262, 262))
 285 
 286     #-----------------------------------------------------------------------
 287 
 288     def BindEvents(self):
 289         """
 290         ...
 291         """
 292 
 293         # Bind some events to an events handler.
 294         self.Bind(wx.EVT_PAINT, self.OnPaint)
 295         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
 296         self.box1.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 297         self.throb.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 298 
 299 
 300     def DoLayout(self):
 301         """
 302         ...
 303         """
 304 
 305         hsizer = wx.BoxSizer(wx.HORIZONTAL)
 306         vsizer = wx.BoxSizer(wx.VERTICAL)
 307 
 308         #------------
 309 
 310         # Add the box to the panel.
 311         hsizer.AddStretchSpacer()
 312         hsizer.Add(self.box1, 0, wx.ALIGN_CENTER)
 313         vsizer.AddStretchSpacer(40)
 314         vsizer.Add(hsizer, 0, wx.ALIGN_CENTER)
 315         vsizer.AddStretchSpacer()
 316 
 317         self.SetSizer(vsizer)
 318 
 319 
 320     def OnPaint(self, event):
 321         """
 322         ...
 323         """
 324 
 325         dc = wx.BufferedPaintDC(self)
 326         dc.Clear()
 327         gcdc = wx.GCDC(dc)
 328         gcdc.Clear()
 329 
 330         # Draw a bitmap with an alpha channel
 331         # on top of the last group.
 332         gcdc.DrawBitmap(self.bmp, 0, 0, False)
 333 
 334 
 335     def OnMouseEvents(self, event):
 336         """
 337         Handles the wx.EVT_MOUSE_EVENTS for AdvancedSplash.
 338         This reproduces the behavior of wx.SplashScreen.
 339         """
 340 
 341         if event.LeftDown() or event.RightDown():
 342             splash = wx.GetApp().GetTopWindow()
 343             splash.OnClose(event)
 344 
 345         event.Skip()
 346 
 347 
 348     def OnDestroy(self, event):
 349         """
 350         ...
 351         """
 352 
 353         self.throb.Stop()
 354         event.Skip()
 355 
 356 #---------------------------------------------------------------------------
 357 
 358 class MySplash(wx.Frame):
 359     """
 360     ...
 361     """
 362     def __init__(self):
 363 
 364         #--------------
 365 
 366         screen = wx.ScreenDC()
 367 
 368         # Screen size.
 369         ws, hs = screen.GetSize()
 370 
 371         #--------------
 372 
 373         # Return bitmaps folder.
 374         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 375 
 376         # Load a background bitmap.
 377         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 378                                           "throbber.png"),
 379                              type=wx.BITMAP_TYPE_PNG)
 380 
 381         mask = wx.Mask(self.bmp, wx.RED)
 382         self.bmp.SetMask(mask)
 383 
 384         # Determine size of bitmap.
 385         wi, hi = self.bmp.GetWidth(), self.bmp.GetHeight()
 386         print("\n... Bitmap size : %sx%s px" % (wi, hi))
 387 
 388         x = int((ws-wi)/2)
 389         y = int((hs-hi)/2)
 390 
 391         #--------------
 392 
 393         super(MySplash, self).__init__(parent=None,
 394                                        id=-1,
 395                                        title="SplashScreen",
 396                                        pos=(x, y),
 397                                        size=(wi, hi),
 398                                        style=wx.FRAME_SHAPED |
 399                                              wx.BORDER_NONE |
 400                                              wx.FRAME_NO_TASKBAR |
 401                                              wx.STAY_ON_TOP)
 402 
 403         #--------------
 404 
 405         self.SetBackgroundColour("#4a6991")
 406 
 407         #--------------
 408 
 409         # Attributes.
 410         self.SetTransparent(0)
 411         self.opacity_in = 0
 412         self.deltaN = -30
 413         self.hasShape = False
 414 
 415         #--------------
 416 
 417         if wx.Platform != "__WXMAC__":
 418             # wxMac clips the tooltip to the window shape, YUCK!!!
 419             self.SetToolTip("Right-click to close the window\n"
 420                             "Double-click the image to set/unset the window shape")
 421 
 422         if wx.Platform == "__WXGTK__":
 423             # wxGTK requires that the window be created before you can
 424             # set its shape, so delay the call to SetWindowShape until
 425             # this event.
 426             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 427         else:
 428             # On wxMSW and wxMac the window has already
 429             # been created, so go for it.
 430             self.SetWindowShape()
 431 
 432         #--------------
 433 
 434         # Starts the Timer. Once Expired, splash is Destroyed.
 435         self.timer = wx.Timer(self)
 436 
 437         # Simulate long startup time.
 438         self.timer.Start(4000)
 439 
 440         self.Bind(wx.EVT_TIMER, self.TimeOut, self.timer)
 441 
 442         #--------------
 443 
 444         # Show main frame after 3000 ms.
 445         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 446 
 447         #--------------
 448 
 449         self.CenterOnScreen(wx.BOTH)
 450         self.Show(True)
 451 
 452         #--------------
 453 
 454         # Simplified init method.
 455         self.OnTimerIn(self)
 456         self.CreateCtrls()
 457         self.DoLayout()
 458 
 459         #--------------
 460 
 461         print("\n... Display the splashScreen")
 462 
 463         #--------------
 464 
 465         self.SetClientSize((wi, hi))
 466         wx.BeginBusyCursor()
 467 
 468     #-----------------------------------------------------------------------
 469 
 470     def OnTimerIn(self, evt):
 471         """
 472         Thanks to Pascal Faut.
 473         """
 474 
 475         self.timer1 = wx.Timer(self, -1)
 476         self.timer1.Start(1)
 477         self.Bind(wx.EVT_TIMER, self.AlphaCycle1, self.timer1)
 478 
 479         print("Fade-in was launched.")
 480 
 481 
 482     def AlphaCycle1(self, *args):
 483         """
 484         Thanks to Pascal Faut.
 485         """
 486 
 487         self.opacity_in += self.deltaN
 488         if self.opacity_in <= 0:
 489             self.deltaN = -self.deltaN
 490             self.opacity_in = 0
 491 
 492         if self.opacity_in >= 255:
 493             self.deltaN = -self.deltaN
 494             self.opacity_in = 255
 495 
 496             self.timer1.Stop()
 497 
 498         self.SetTransparent(self.opacity_in)
 499 
 500         print("Fade in = {}/255".format(self.opacity_in))
 501 
 502 
 503     def CreateCtrls(self):
 504         """
 505         ...
 506         """
 507 
 508         self.panel = MyPanel(self)
 509 
 510 
 511     def BindEvents(self):
 512         """
 513         Bind all the events related to my app.
 514         """
 515 
 516         # Bind some events to an events handler.
 517         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 518         self.Bind(wx.EVT_CLOSE, self.OnClose)
 519         self.panel.Bind(wx.EVT_LEFT_DOWN, self.OnClose)
 520         self.Bind(wx.EVT_CLOSE, self.CloseWindow)
 521 
 522 
 523     def DoLayout(self):
 524         """
 525         ...
 526         """
 527 
 528         sizer = wx.BoxSizer(wx.VERTICAL)
 529         sizer.Add(self.panel, 1, wx.EXPAND, 20)
 530         self.SetSizer(sizer)
 531 
 532 
 533     def SetWindowShape(self, *evt):
 534         """
 535         ...
 536         """
 537 
 538         # Use the bitmap's mask to determine the region.
 539         r = wx.Region(self.bmp)
 540         self.hasShape = self.SetShape(r)
 541 
 542 
 543     def OnCharEvents(self, event):
 544         """
 545         Handles the wx.EVT_CHAR for Splash.
 546         This reproduces the behavior of wx.SplashScreen.
 547         """
 548 
 549         self.OnClose(event)
 550 
 551 
 552     def TimeOut(self, event):
 553         """
 554         ...
 555         """
 556 
 557         self.Close(True)
 558 
 559 
 560     def OnClose(self, event):
 561         """
 562         Handles the wx.EVT_CLOSE event for SplashScreen.
 563         """
 564 
 565         # Make sure the default handler runs
 566         # too so this window gets destroyed.
 567         # Tell the event system to continue
 568         # looking for an event handler, so the
 569         # default handler will get called.
 570         # event.Skip()  # ?????
 571         self.Hide()
 572 
 573         #------------
 574 
 575         # If the timer is still running then go
 576         # ahead and show the main frame now.
 577         if self.fc.IsRunning():
 578             # Stop the wx.CallLater timer.
 579             # Stop the splash screen timer
 580             # and close it.
 581             self.fc.Stop()
 582             self.ShowMainFrame()
 583 
 584 
 585     def ShowMainFrame(self):
 586         """
 587         ...
 588         """
 589 
 590         print("\n... Close the splash screen")
 591         print("\n... Create and display the main frame")
 592 
 593         #------------
 594 
 595         wx.CallAfter(wx.EndBusyCursor)
 596 
 597         #------------
 598 
 599         if self.fc.IsRunning():
 600             # Stop the splash screen
 601             # timer and close it.
 602             self.Raise()
 603 
 604         #------------
 605 
 606         # Create an instance of the MyFrame class.
 607         frame = MyFrame()
 608 
 609 
 610     def CloseWindow(self, event):
 611         """
 612         ...
 613         """
 614 
 615         self.timer.Stop()
 616         self.Destroy()
 617 
 618 #---------------------------------------------------------------------------
 619 
 620 class MyApp(wx.App):
 621     """
 622     ...
 623     """
 624     def OnInit(self):
 625 
 626         #------------
 627 
 628         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 629 
 630         #------------
 631 
 632         self.SetAppName("Main frame")
 633 
 634         #------------
 635 
 636         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 637 
 638         #------------
 639 
 640         splash = MySplash()
 641         splash.BindEvents()
 642         splash.CenterOnScreen(wx.BOTH)
 643 
 644         return True
 645 
 646     #-----------------------------------------------------------------------
 647 
 648     def GetInstallDir(self):
 649         """
 650         Returns the installation directory for my application.
 651         """
 652 
 653         return self.installDir
 654 
 655 
 656     def GetIconsDir(self):
 657         """
 658         Returns the icons directory for my application.
 659         """
 660 
 661         icons_dir = os.path.join(self.installDir, "icons")
 662         return icons_dir
 663 
 664 
 665     def GetBitmapsDir(self):
 666         """
 667         Returns the bitmaps directory for my application.
 668         """
 669 
 670         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 671         return bitmaps_dir
 672 
 673 #---------------------------------------------------------------------------
 674 
 675 def main():
 676     app = MyApp(False)
 677     app.MainLoop()
 678 
 679 #---------------------------------------------------------------------------
 680 
 681 if __name__ == "__main__" :
 682     main()


With animated gif

img_sample_four.png

   1 # sample_four.py
   2 
   3 import os
   4 import sys
   5 import wx
   6 from wx.adv import Animation, AnimationCtrl
   7 
   8 # class MyFrame
   9 # class MyCaptionBox
  10 # class MyPanel
  11 # class MySplash
  12 # class MyApp
  13 
  14 #---------------------------------------------------------------------------
  15 
  16 class MyFrame(wx.Frame):
  17     """
  18     ...
  19     """
  20     def __init__(self):
  21         super(MyFrame, self).__init__(None,
  22                                       -1,
  23                                       title="")
  24 
  25         #------------
  26 
  27         # Return application name.
  28         self.app_name = wx.GetApp().GetAppName()
  29         # Return icons folder.
  30         self.icons_dir = wx.GetApp().GetIconsDir()
  31 
  32         #------------
  33 
  34         # Simplified init method.
  35         self.SetProperties()
  36         self.CreateCtrls()
  37         self.BindEvents()
  38         self.DoLayout()
  39 
  40         #------------
  41 
  42         self.CenterOnScreen(wx.BOTH)
  43 
  44         #------------
  45 
  46         self.Show(True)
  47 
  48     #-----------------------------------------------------------------------
  49 
  50     def SetProperties(self):
  51         """
  52         ...
  53         """
  54 
  55         self.SetTitle(self.app_name)
  56         self.SetSize((340, 250))
  57 
  58         #------------
  59 
  60         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  61                                          "icon_wxWidgets.ico"),
  62                             type=wx.BITMAP_TYPE_ICO)
  63         self.SetIcon(frameIcon)
  64 
  65 
  66     def CreateCtrls(self):
  67         """
  68         ...
  69         """
  70 
  71         # Create a panel.
  72         self.panel = wx.Panel(self, -1)
  73 
  74         #------------
  75 
  76         # Add a buttons.
  77         self.btnClose = wx.Button(self.panel,
  78                                   -1,
  79                                   "&Close")
  80 
  81 
  82     def BindEvents(self):
  83         """
  84         Bind some events to an events handler.
  85         """
  86 
  87         # Bind events to an events handler.
  88         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  89         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  90 
  91 
  92     def DoLayout(self):
  93         """
  94         ...
  95         """
  96 
  97         # MainSizer is the top-level one that manages everything.
  98         mainSizer = wx.BoxSizer(wx.VERTICAL)
  99 
 100         # wx.BoxSizer(window, proportion, flag, border)
 101         # wx.BoxSizer(sizer, proportion, flag, border)
 102         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 103 
 104         # Finally, tell the panel to use the sizer for layout.
 105         self.panel.SetAutoLayout(True)
 106         self.panel.SetSizer(mainSizer)
 107 
 108         mainSizer.Fit(self.panel)
 109 
 110 
 111     def OnCloseMe(self, event):
 112         """
 113         ...
 114         """
 115 
 116         self.Close(True)
 117 
 118 
 119     def OnCloseWindow(self, event):
 120         """
 121         ...
 122         """
 123 
 124         self.Destroy()
 125 
 126 #---------------------------------------------------------------------------
 127 
 128 class MyCaptionBox(wx.Panel):
 129     """
 130     ...
 131     """
 132     def __init__(self, parent, caption):
 133         super(MyCaptionBox, self).__init__(parent,
 134                                            style=wx.NO_BORDER |
 135                                                  wx.TAB_TRAVERSAL)
 136 
 137         #------------
 138 
 139         self.SetBackgroundColour("white")
 140 
 141         #------------
 142 
 143         # Attributes.
 144         self._caption = caption
 145         self._csizer = wx.BoxSizer(wx.VERTICAL)
 146 
 147         #------------
 148 
 149         # Simplified init method.
 150         self.BindEvents()
 151         self.DoLayout()
 152 
 153     #-----------------------------------------------------------------------
 154 
 155     def BindEvents(self):
 156         """
 157         ...
 158         """
 159 
 160         # Bind events to an events handler.
 161         self.Bind(wx.EVT_PAINT, self.OnPaint)
 162 
 163 
 164     def DoLayout(self):
 165         """
 166         ...
 167         """
 168 
 169         msizer = wx.BoxSizer(wx.HORIZONTAL)
 170         self._csizer.AddSpacer(15) # Extra space for caption.
 171         msizer.Add(self._csizer, 0, wx.EXPAND)
 172         self.SetSizer(msizer)
 173 
 174 
 175     def DoGetBestSize(self):
 176         """
 177         ...
 178         """
 179 
 180         size = super(MyCaptionBox, self).DoGetBestSize()
 181         # Compensate for wide caption labels.
 182         tw = self.GetTextExtent(self._caption)[0]
 183         size.SetWidth(max(size.width, tw))
 184         return size
 185 
 186 
 187     def AddItem(self, item):
 188         """
 189         Add a window or sizer item to the caption box.
 190         """
 191 
 192         self._csizer.Add(item, 0, wx.ALL, 10)
 193 
 194 
 195     def OnPaint(self, event):
 196         """
 197         Draws the Caption and border around the controls.
 198         """
 199 
 200         dc = wx.BufferedPaintDC(self)
 201         dc.SetBackground(wx.Brush(wx.Colour(255, 255, 255, 255)))
 202         dc.Clear()
 203         gcdc = wx.GCDC(dc)
 204 
 205         # Get the working rectangle we can draw in.
 206         rect = self.GetClientRect()
 207 
 208         # Get the sytem color to draw the caption.
 209         ss = wx.SystemSettings
 210         color = ss.GetColour(wx.SYS_COLOUR_3DDKSHADOW)
 211         gcdc.SetTextForeground(wx.BLACK)
 212 
 213         # Draw the border.
 214         rect.Inflate(-0, -0)
 215         gcdc.SetPen(wx.Pen(color))
 216         gcdc.SetBrush(wx.Brush(wx.Colour(52, 64, 80, 255)))
 217 
 218         # Font size and style.
 219         font = self.GetFont().GetPointSize()
 220         font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT)
 221         font.SetWeight(wx.BOLD)
 222 
 223         # Add the Caption.
 224         rect = wx.Rect(rect.x, rect.y, rect.width, 20)
 225         rect.Inflate(-5, 0)
 226         gcdc.SetFont(font)
 227         gcdc.DrawLabel(self._caption, rect, wx.ALIGN_CENTER)
 228 
 229 #---------------------------------------------------------------------------
 230 
 231 class MyPanel(wx.Panel):
 232     """
 233     ...
 234     """
 235     def __init__(self, parent):
 236         wx.Panel.__init__(self, parent)
 237 
 238         #------------
 239 
 240         self.SetBackgroundColour("white")
 241 
 242         #------------
 243 
 244         # Return bitmaps folder.
 245         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 246 
 247         # Load a background bitmap.
 248         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 249                                           "gloss.png"),
 250                              type=wx.BITMAP_TYPE_PNG)
 251 
 252         #------------
 253 
 254         # Attributes.
 255         self.box1 = MyCaptionBox(self, "Loading...")
 256 
 257         #------------
 258 
 259         # Pick the filename of an animated GIF file you have ...
 260         # Give it the full path and file name.
 261         animatedGif = Animation(os.path.join(self.bitmaps_dir,
 262                                              "loader.gif"))
 263         self.ag = AnimationCtrl(self.box1,
 264                                 -1,
 265                                 animatedGif)
 266 
 267         # Clears the background.
 268         self.ag.SetBackgroundColour(self.GetBackgroundColour())
 269 
 270         # Continuously loop through the frames of
 271         # the gif file (default).
 272         self.ag.Play()
 273 
 274         self.box1.AddItem(self.ag)
 275 
 276         #------------
 277 
 278         # Simplified init method.
 279         self.BindEvents()
 280         self.DoLayout()
 281 
 282         #------------
 283 
 284         self.SetClientSize((262, 282))
 285 
 286     #-----------------------------------------------------------------------
 287 
 288     def BindEvents(self):
 289         """
 290         ...
 291         """
 292 
 293         # Bind some events to an events handler.
 294         self.Bind(wx.EVT_PAINT, self.OnPaint)
 295         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
 296         self.box1.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 297         self.ag.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 298 
 299 
 300     def DoLayout(self):
 301         """
 302         ...
 303         """
 304 
 305         hsizer = wx.BoxSizer(wx.HORIZONTAL)
 306         vsizer = wx.BoxSizer(wx.VERTICAL)
 307 
 308         #------------
 309 
 310         # Add the box to the panel.
 311         hsizer.AddStretchSpacer()
 312         hsizer.Add(self.box1, 0, wx.ALIGN_CENTER)
 313         vsizer.AddStretchSpacer(40)
 314         vsizer.Add(hsizer, 0, wx.ALIGN_CENTER)
 315         vsizer.AddStretchSpacer()
 316 
 317         self.SetSizer(vsizer)
 318 
 319 
 320     def OnPaint(self, event):
 321         """
 322         ...
 323         """
 324 
 325         dc = wx.BufferedPaintDC(self)
 326         dc.Clear()
 327         gcdc = wx.GCDC(dc)
 328         gcdc.Clear()
 329 
 330         # Draw a bitmap with an alpha channel
 331         # on top of the last group.
 332         gcdc.DrawBitmap(self.bmp, 0, 0, False)
 333 
 334 
 335     def OnMouseEvents(self, event):
 336         """
 337         Handles the wx.EVT_MOUSE_EVENTS for AdvancedSplash.
 338         This reproduces the behavior of wx.SplashScreen.
 339         """
 340 
 341         if event.LeftDown() or event.RightDown():
 342             splash = wx.GetApp().GetTopWindow()
 343             splash.OnClose(event)
 344 
 345         event.Skip()
 346 
 347 
 348     def OnDestroy(self, event):
 349         """
 350         ...
 351         """
 352 
 353         event.Skip()
 354 
 355 #---------------------------------------------------------------------------
 356 
 357 class MySplash(wx.Frame):
 358     """
 359     ...
 360     """
 361     def __init__(self):
 362 
 363         #--------------
 364 
 365         screen = wx.ScreenDC()
 366 
 367         # Screen size.
 368         ws, hs = screen.GetSize()
 369 
 370         #------------
 371 
 372         # Return bitmaps folder.
 373         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 374 
 375         # Load a background bitmap.
 376         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 377                                           "gloss.png"),
 378                              type=wx.BITMAP_TYPE_PNG)
 379 
 380         mask = wx.Mask(self.bmp, wx.RED)
 381         self.bmp.SetMask(mask)
 382 
 383         # Determine size of bitmap.
 384         wi, hi = self.bmp.GetWidth(), self.bmp.GetHeight()
 385         print("\n... Bitmap size : %sx%s px" % (wi, hi))
 386 
 387         x = int((ws-wi)/2)
 388         y = int((hs-hi)/2)
 389 
 390         #--------------
 391 
 392         super(MySplash, self).__init__(parent=None,
 393                                        id=-1,
 394                                        title="SplashScreen",
 395                                        pos=(x, y),
 396                                        size=(wi, hi),
 397                                        style=wx.FRAME_SHAPED |
 398                                              wx.BORDER_NONE |
 399                                              wx.FRAME_NO_TASKBAR |
 400                                              wx.STAY_ON_TOP)
 401 
 402         #--------------
 403 
 404         self.SetBackgroundColour("white")
 405 
 406         #--------------
 407 
 408         # Attributes.
 409         self.SetTransparent(0)
 410         self.opacity_in = 0
 411         self.deltaN = -30
 412         self.hasShape = False
 413 
 414         #--------------
 415 
 416         if wx.Platform != "__WXMAC__":
 417             # wxMac clips the tooltip to the window shape, YUCK!!!
 418             self.SetToolTip("Right-click to close the window\n"
 419                             "Double-click the image to set/unset the window shape")
 420 
 421         if wx.Platform == "__WXGTK__":
 422             # wxGTK requires that the window be created before you can
 423             # set its shape, so delay the call to SetWindowShape until
 424             # this event.
 425             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 426         else:
 427             # On wxMSW and wxMac the window has already
 428             # been created, so go for it.
 429             self.SetWindowShape()
 430 
 431         #--------------
 432 
 433         # Starts the Timer. Once Expired, splash is Destroyed.
 434         self.timer = wx.Timer(self)
 435 
 436         # Simulate long startup time.
 437         self.timer.Start(4000)
 438 
 439         self.Bind(wx.EVT_TIMER, self.TimeOut, self.timer)
 440 
 441         #--------------
 442 
 443         # Show main frame after 3000 ms.
 444         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 445 
 446         #--------------
 447 
 448         self.CenterOnScreen(wx.BOTH)
 449         self.Show(True)
 450 
 451         #--------------
 452 
 453         # Simplified init method.
 454         self.OnTimerIn(self)
 455         self.CreateCtrls()
 456         self.DoLayout()
 457 
 458         #--------------
 459 
 460         print("\n... Display the splashScreen")
 461 
 462         #--------------
 463 
 464         self.SetClientSize((wi, hi))
 465         wx.BeginBusyCursor()
 466 
 467     #-----------------------------------------------------------------------
 468 
 469     def OnTimerIn(self, evt):
 470         """
 471         Thanks to Pascal Faut.
 472         """
 473 
 474         self.timer1 = wx.Timer(self, -1)
 475         self.timer1.Start(1)
 476         self.Bind(wx.EVT_TIMER, self.AlphaCycle1, self.timer1)
 477 
 478         print("Fade-in was launched.")
 479 
 480 
 481     def AlphaCycle1(self, *args):
 482         """
 483         Thanks to Pascal Faut.
 484         """
 485 
 486         self.opacity_in += self.deltaN
 487         if self.opacity_in <= 0:
 488             self.deltaN = -self.deltaN
 489             self.opacity_in = 0
 490 
 491         if self.opacity_in >= 255:
 492             self.deltaN = -self.deltaN
 493             self.opacity_in = 255
 494 
 495             self.timer1.Stop()
 496 
 497         self.SetTransparent(self.opacity_in)
 498 
 499         print("Fade in = {}/255".format(self.opacity_in))
 500 
 501 
 502     def CreateCtrls(self):
 503         """
 504         ...
 505         """
 506 
 507 
 508         self.panel = MyPanel(self)
 509 
 510 
 511     def BindEvents(self):
 512         """
 513         Bind all the events related to my app.
 514         """
 515 
 516         # Bind some events to an events handler.
 517         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 518         self.Bind(wx.EVT_CLOSE, self.OnClose)
 519         self.panel.Bind(wx.EVT_LEFT_DOWN, self.OnClose)
 520         self.Bind(wx.EVT_CLOSE, self.CloseWindow)
 521 
 522 
 523     def DoLayout(self):
 524         """
 525         ...
 526         """
 527 
 528         sizer = wx.BoxSizer(wx.VERTICAL)
 529         sizer.Add(self.panel, 1, wx.EXPAND, 20)
 530         self.SetSizer(sizer)
 531 
 532 
 533     def SetWindowShape(self, *evt):
 534         """
 535         ...
 536         """
 537 
 538         # Use the bitmap's mask to determine the region.
 539         r = wx.Region(self.bmp)
 540         self.hasShape = self.SetShape(r)
 541 
 542 
 543     def OnCharEvents(self, event):
 544         """
 545         Handles the wx.EVT_CHAR for Splash.
 546         This reproduces the behavior of wx.SplashScreen.
 547         """
 548 
 549         self.OnClose(event)
 550 
 551 
 552     def TimeOut(self, event):
 553         """
 554         ...
 555         """
 556 
 557         self.Close(True)
 558 
 559 
 560     def OnClose(self, event):
 561         """
 562         Handles the wx.EVT_CLOSE event for SplashScreen.
 563         """
 564 
 565         # Make sure the default handler runs
 566         # too so this window gets destroyed.
 567         # Tell the event system to continue
 568         # looking for an event handler, so the
 569         # default handler will get called.
 570         # event.Skip()  # ?????
 571         self.Hide()
 572 
 573         #------------
 574 
 575         # If the timer is still running then go
 576         # ahead and show the main frame now.
 577         if self.fc.IsRunning():
 578             # Stop the wx.CallLater timer.
 579             # Stop the splash screen timer
 580             # and close it.
 581             self.fc.Stop()
 582             self.ShowMainFrame()
 583 
 584 
 585     def ShowMainFrame(self):
 586         """
 587         ...
 588         """
 589 
 590         print("\n... Close the splash screen")
 591         print("\n... Create and display the main frame")
 592 
 593         #------------
 594 
 595         wx.CallAfter(wx.EndBusyCursor)
 596 
 597         #------------
 598 
 599         if self.fc.IsRunning():
 600             # Stop the splash screen
 601             # timer and close it.
 602             self.Raise()
 603 
 604         #------------
 605 
 606         # Create an instance of the MyFrame class.
 607         frame = MyFrame()
 608 
 609 
 610     def CloseWindow(self, event):
 611         """
 612         ...
 613         """
 614 
 615         self.timer.Stop()
 616         self.Destroy()
 617 
 618 #---------------------------------------------------------------------------
 619 
 620 class MyApp(wx.App):
 621     """
 622     ...
 623     """
 624     def OnInit(self):
 625 
 626         #------------
 627 
 628         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 629 
 630         #------------
 631 
 632         self.SetAppName("Main frame")
 633 
 634         #------------
 635 
 636         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 637 
 638         #------------
 639 
 640         splash = MySplash()
 641         splash.BindEvents()
 642         splash.CenterOnScreen(wx.BOTH)
 643 
 644         return True
 645 
 646     #-----------------------------------------------------------------------
 647 
 648     def GetInstallDir(self):
 649         """
 650         Returns the installation directory for my application.
 651         """
 652 
 653         return self.installDir
 654 
 655 
 656     def GetIconsDir(self):
 657         """
 658         Returns the icons directory for my application.
 659         """
 660 
 661         icons_dir = os.path.join(self.installDir, "icons")
 662         return icons_dir
 663 
 664 
 665     def GetBitmapsDir(self):
 666         """
 667         Returns the bitmaps directory for my application.
 668         """
 669 
 670         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 671         return bitmaps_dir
 672 
 673 #---------------------------------------------------------------------------
 674 
 675 def main():
 676     app = MyApp(False)
 677     app.MainLoop()
 678 
 679 #---------------------------------------------------------------------------
 680 
 681 if __name__ == "__main__" :
 682     main()


With masked area

img_sample_five.png

   1 # sample_five.py
   2 
   3 import os
   4 import sys
   5 import platform
   6 import wx
   7 
   8 # class MyFrame
   9 # class MyPanel
  10 # class MySplash
  11 # class MyApp
  12 
  13 #---------------------------------------------------------------------------
  14 
  15 class MyFrame(wx.Frame):
  16     """
  17     ...
  18     """
  19     def __init__(self):
  20         super(MyFrame, self).__init__(None,
  21                                       -1,
  22                                       title="")
  23 
  24         #------------
  25 
  26         # Return application name.
  27         self.app_name = wx.GetApp().GetAppName()
  28         # Return icons folder.
  29         self.icons_dir = wx.GetApp().GetIconsDir()
  30 
  31         #------------
  32 
  33         # Simplified init method.
  34         self.SetProperties()
  35         self.CreateCtrls()
  36         self.BindEvents()
  37         self.DoLayout()
  38 
  39         #------------
  40 
  41         self.CenterOnScreen(wx.BOTH)
  42 
  43         #------------
  44 
  45         self.Show(True)
  46 
  47     #-----------------------------------------------------------------------
  48 
  49     def SetProperties(self):
  50         """
  51         ...
  52         """
  53 
  54         self.SetTitle(self.app_name)
  55         self.SetSize((340, 250))
  56 
  57         #------------
  58 
  59         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  60                                          "icon_wxWidgets.ico"),
  61                             type=wx.BITMAP_TYPE_ICO)
  62         self.SetIcon(frameIcon)
  63 
  64 
  65     def CreateCtrls(self):
  66         """
  67         ...
  68         """
  69 
  70         # Create a panel.
  71         self.panel = wx.Panel(self, -1)
  72 
  73         #------------
  74 
  75         # Add a buttons.
  76         self.btnClose = wx.Button(self.panel,
  77                                   -1,
  78                                   "&Close")
  79 
  80 
  81     def BindEvents(self):
  82         """
  83         Bind some events to an events handler.
  84         """
  85 
  86         # Bind events to an events handler.
  87         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  88         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  89 
  90 
  91     def DoLayout(self):
  92         """
  93         ...
  94         """
  95 
  96         # MainSizer is the top-level one that manages everything.
  97         mainSizer = wx.BoxSizer(wx.VERTICAL)
  98 
  99         # wx.BoxSizer(window, proportion, flag, border)
 100         # wx.BoxSizer(sizer, proportion, flag, border)
 101         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 102 
 103         # Finally, tell the panel to use the sizer for layout.
 104         self.panel.SetAutoLayout(True)
 105         self.panel.SetSizer(mainSizer)
 106 
 107         mainSizer.Fit(self.panel)
 108 
 109 
 110     def OnCloseMe(self, event):
 111         """
 112         ...
 113         """
 114 
 115         self.Close(True)
 116 
 117 
 118     def OnCloseWindow(self, event):
 119         """
 120         ...
 121         """
 122 
 123         self.Destroy()
 124 
 125 #---------------------------------------------------------------------------
 126 
 127 class MyPanel(wx.Panel):
 128     """
 129     ...
 130     """
 131     def __init__(self, parent):
 132         wx.Panel.__init__(self, parent)
 133 
 134         #------------
 135 
 136         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 137 
 138         #------------
 139 
 140         # Return bitmaps folder.
 141         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 142 
 143         # Load a background bitmap.
 144         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 145                                           "mask.png"),
 146                              type=wx.BITMAP_TYPE_PNG)
 147 
 148         #------------
 149 
 150         # Simplified init method.
 151         self.BindEvents()
 152 
 153     #-----------------------------------------------------------------------
 154 
 155     def BindEvents(self):
 156         """
 157         ...
 158         """
 159 
 160         # Bind event to an events handler.
 161         self.Bind(wx.EVT_PAINT, self.OnPaint)
 162         self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
 163 
 164 
 165     def OnPaint(self, event):
 166         """
 167         ...
 168         """
 169 
 170         dc = wx.BufferedPaintDC(self)
 171         dc.Clear()
 172         gcdc = wx.GCDC(dc)
 173         gcdc.Clear()
 174 
 175         # Draw a bitmap with an alpha channel
 176         # on top of the last group.
 177         gcdc.DrawBitmap(self.bmp, 0, 0, False)
 178 
 179 
 180     def OnMouseEvents(self, event):
 181         """
 182         Handles the wx.EVT_MOUSE_EVENTS for AdvancedSplash.
 183         This reproduces the behavior of wx.SplashScreen.
 184         """
 185 
 186         if event.LeftDown() or event.RightDown():
 187             splash = wx.GetApp().GetTopWindow()
 188             splash.OnClose(event)
 189 
 190         event.Skip()
 191 
 192 
 193     def OnDestroy(self, event):
 194         """
 195         ...
 196         """
 197 
 198         event.Skip()
 199 
 200 #---------------------------------------------------------------------------
 201 
 202 class MySplash(wx.Frame):
 203     """
 204     ...
 205     """
 206     def __init__(self,
 207                  parent=None,
 208                  id=-1,
 209                  title="SplashScreen",
 210                  pos=wx.DefaultPosition,
 211                  size=wx.DefaultSize,
 212                  style=wx.FRAME_SHAPED |
 213                        wx.BORDER_NONE |
 214                        wx.FRAME_NO_TASKBAR |
 215                        wx.STAY_ON_TOP):
 216 
 217         #--------------
 218 
 219         # Return bitmaps folder.
 220         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 221 
 222         # Load a background bitmap.
 223         self.bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 224                                           "mask.png"),
 225                              type=wx.BITMAP_TYPE_PNG)
 226 
 227         mask = wx.Mask(self.bmp, wx.RED)
 228         self.bmp.SetMask(mask)
 229 
 230         # Determine size of bitmap.
 231         w, h = self.bmp.GetWidth(), self.bmp.GetHeight()
 232         print("\n... Bitmap size : %sx%s px" % (w, h))
 233 
 234         #--------------
 235 
 236         super(MySplash, self).__init__(parent,
 237                                        id,
 238                                        title,
 239                                        pos,
 240                                        size,
 241                                        style)
 242 
 243         #--------------
 244 
 245         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 246 
 247         #--------------
 248 
 249         # Attributes.
 250         self.hasShape = False
 251 
 252         #--------------
 253 
 254         if wx.Platform != "__WXMAC__":
 255             # wxMac clips the tooltip to the window shape, YUCK!!!
 256             self.SetToolTip("Right-click to close the window\n"
 257                             "Double-click the image to set/unset the window shape")
 258 
 259         if wx.Platform == "__WXGTK__":
 260             # wxGTK requires that the window be created before you can
 261             # set its shape, so delay the call to SetWindowShape until
 262             # this event.
 263             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 264         else:
 265             # On wxMSW and wxMac the window has already
 266             # been created, so go for it.
 267             self.SetWindowShape()
 268 
 269         #--------------
 270 
 271         # Starts the Timer. Once Expired, splash is Destroyed.
 272         self.timer = wx.Timer(self)
 273 
 274         # Simulate long startup time.
 275         self.timer.Start(4000)
 276 
 277         self.Bind(wx.EVT_TIMER, self.TimeOut, self.timer)
 278 
 279         #--------------
 280 
 281         # Show main frame after 3000 ms.
 282         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 283 
 284         #--------------
 285 
 286         self.CenterOnScreen(wx.BOTH)
 287         self.Show(True)
 288 
 289         #--------------
 290 
 291         # Simplified init method.
 292         self.CreateCtrls()
 293         self.DoLayout()
 294 
 295         #--------------
 296 
 297         print("\n... Display the splashScreen")
 298 
 299         #--------------
 300 
 301         self.SetClientSize((w, h))
 302         wx.BeginBusyCursor()
 303 
 304     #-----------------------------------------------------------------------
 305 
 306     def CreateCtrls(self):
 307         """
 308         ...
 309         """
 310 
 311         self.panel = MyPanel(self)
 312 
 313 
 314     def BindEvents(self):
 315         """
 316         Bind all the events related to my app.
 317         """
 318 
 319         # Bind some events to an events handler.
 320         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 321         self.Bind(wx.EVT_CLOSE, self.OnClose)
 322         self.panel.Bind(wx.EVT_LEFT_DOWN, self.OnClose)
 323         self.Bind(wx.EVT_CLOSE, self.CloseWindow)
 324 
 325 
 326     def DoLayout(self):
 327         """
 328         ...
 329         """
 330 
 331         sizer = wx.BoxSizer(wx.VERTICAL)
 332         sizer.Add(self.panel, 1, wx.EXPAND)
 333         self.SetSizer(sizer)
 334 
 335 
 336     def SetWindowShape(self, *evt):
 337         """
 338         ...
 339         """
 340 
 341         # Use the bitmap's mask to determine the region.
 342         r = wx.Region(self.bmp)
 343         self.hasShape = self.SetShape(r)
 344 
 345 
 346     def OnCharEvents(self, event):
 347         """
 348         Handles the wx.EVT_CHAR for Splash.
 349         This reproduces the behavior of wx.SplashScreen.
 350         """
 351 
 352         self.OnClose(event)
 353 
 354 
 355     def TimeOut(self, event):
 356         """
 357         ...
 358         """
 359 
 360         self.Close(True)
 361 
 362 
 363     def OnClose(self, event):
 364         """
 365         Handles the wx.EVT_CLOSE event for SplashScreen.
 366         """
 367 
 368         # Make sure the default handler runs
 369         # too so this window gets destroyed.
 370         # Tell the event system to continue
 371         # looking for an event handler, so the
 372         # default handler will get called.
 373         event.Skip()
 374         self.Hide()
 375 
 376         #------------
 377 
 378         # If the timer is still running then go
 379         # ahead and show the main frame now.
 380         if self.fc.IsRunning():
 381             # Stop the wx.CallLater timer.
 382             # Stop the splash screen timer
 383             # and close it.
 384             self.fc.Stop()
 385             self.ShowMainFrame()
 386 
 387 
 388     def ShowMainFrame(self):
 389         """
 390         ...
 391         """
 392 
 393         print("\n... Close the splash screen")
 394         print("\n... Create and display the main frame")
 395 
 396         #------------
 397 
 398         wx.CallAfter(wx.EndBusyCursor)
 399 
 400         #------------
 401 
 402         if self.fc.IsRunning():
 403             # Stop the splash screen
 404             # timer and close it.
 405             self.Raise()
 406 
 407         #------------
 408 
 409         # Create an instance of the MyFrame class.
 410         frame = MyFrame()
 411 
 412 
 413     def CloseWindow(self, event):
 414         """
 415         ...
 416         """
 417 
 418         self.timer.Stop()
 419         self.Destroy()
 420 
 421 #---------------------------------------------------------------------------
 422 
 423 class MyApp(wx.App):
 424     """
 425     ...
 426     """
 427     def OnInit(self):
 428 
 429         #------------
 430 
 431         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 432 
 433         #------------
 434 
 435         self.SetAppName("Main frame")
 436 
 437         #------------
 438 
 439         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 440 
 441         #------------
 442 
 443         splash = MySplash(None, -1)
 444         splash.BindEvents()
 445         splash.CenterOnScreen(wx.BOTH)
 446 
 447         return True
 448 
 449     #-----------------------------------------------------------------------
 450 
 451     def GetInstallDir(self):
 452         """
 453         Returns the installation directory for my application.
 454         """
 455 
 456         return self.installDir
 457 
 458 
 459     def GetIconsDir(self):
 460         """
 461         Returns the icons directory for my application.
 462         """
 463 
 464         icons_dir = os.path.join(self.installDir, "icons")
 465         return icons_dir
 466 
 467 
 468     def GetBitmapsDir(self):
 469         """
 470         Returns the bitmaps directory for my application.
 471         """
 472 
 473         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 474         return bitmaps_dir
 475 
 476 #---------------------------------------------------------------------------
 477 
 478 def main():
 479     app = MyApp(False)
 480     app.MainLoop()
 481 
 482 #---------------------------------------------------------------------------
 483 
 484 if __name__ == "__main__" :
 485     main()


With advancedsplash (Andrea Gavana)

img_sample_six.png

Available with wxPython demo (Advanced Generic Widgets (AGW)).

   1 # sample_six.py
   2 
   3 import sys
   4 import os
   5 import wx
   6 
   7 #-------------------------------------------------------------------------------
   8 # ADVANCEDSPLASH Control wxPython IMPLEMENTATION
   9 # Python Code By:
  10 #
  11 # Andrea Gavana, @ 10 Oct 2005
  12 # Latest Revision: 19 Dec 2012, 21.00 GMT
  13 #
  14 #
  15 # TODO List/Caveats
  16 #
  17 # 1. Actually, Setting The Shape Of AdvancedSplash Is Done Using "SetShape"
  18 #    Function On A Frame. This Works, AFAIK, On This Following Platforms:
  19 #
  20 #    - MSW
  21 #    - UNIX/Linux
  22 #    - MacOS Carbon
  23 #
  24 #    Obviously I May Be Wrong Here. Could Someone Verify That Lines 139-145
  25 #    Work Correctly On Other Platforms Than Mine (MSW XP/2000)?
  26 #    Moreover, Is There A Way To Avoid The Use Of The "SetShape" Method?
  27 #    I Don't Know.
  28 #
  29 #
  30 # For All Kind Of Problems, Requests Of Enhancements And Bug Reports, Please
  31 # Write To Me At:
  32 #
  33 # andrea.gavana@gmail.com
  34 # andrea.gavana@maerskoil.com
  35 #
  36 # Or, Obviously, To The wxPython Mailing List!!!
  37 #
  38 # Tags:        phoenix-port, unittest, documented, py3-port
  39 #
  40 # End Of Comments
  41 #-------------------------------------------------------------------------------
  42 
  43 
  44 """
  45 
  46 :class:`~wx.lib.agw.advancedsplash.AdvancedSplash` tries to reproduce the behavior
  47 of :class:`~adv.SplashScreen`, with some enhancements.
  48 
  49 
  50 Description
  51 ===========
  52 
  53 :class:`AdvancedSplash` tries to reproduce the behavior of :class:`~adv.SplashScreen`,
  54 but with some enhancements (in my opinion).
  55 
  56 :class:`AdvancedSplash` starts its construction from a simple frame. Then, depending
  57 on the options passed to it, it sets the frame shape accordingly to the image passed
  58 as input. :class:`AdvancedSplash` behaves somewhat like :class:`~adv.SplashScreen`,
  59 and almost all the methods available in :class:`~adv.SplashScreen` are available also
  60 in this module.
  61 
  62 
  63 Usage
  64 =====
  65 
  66 Sample usage::
  67 
  68     import wx
  69     import wx.lib.agw.advancedsplash as AS
  70 
  71     app = wx.App(0)
  72 
  73     frame = wx.Frame(None, -1, "AdvancedSplash Test")
  74 
  75     imagePath = "my_splash_image.png"
  76     bitmap = wx.Bitmap(imagePath, wx.BITMAP_TYPE_PNG)
  77     shadow = wx.WHITE
  78 
  79     splash = AS.AdvancedSplash(frame, bitmap=bitmap, timeout=5000,
  80                                agwStyle=AS.AS_TIMEOUT |
  81                                AS.AS_CENTER_ON_PARENT |
  82                                AS.AS_SHADOW_BITMAP,
  83                                shadowcolour=shadow)
  84 
  85     app.MainLoop()
  86 
  87 
  88 None of the options are strictly required (a part of the `bitmap` parameter).
  89 If you use the defaults you get a very simple :class:`AdvancedSplash`.
  90 
  91 
  92 Methods and Settings
  93 ====================
  94 
  95 :class:`AdvancedSplash` is customizable, and in particular you can set:
  96 
  97 - Whether you want to mask a colour or not in your input bitmap;
  98 - Where to center the splash screen (on screen, on parent or nowhere);
  99 - Whether it is a "timeout" splashscreen or not;
 100 - The time after which :class:`AdvancedSplash` is destroyed (if it is a timeout splashscreen);
 101 - The (optional) text you wish to display;
 102 - The font, colour and position of the displayed text (optional).
 103 
 104 
 105 Window Styles
 106 =============
 107 
 108 This class supports the following window styles:
 109 
 110 ======================= =========== ==================================================
 111 Window Styles           Hex Value   Description
 112 ======================= =========== ==================================================
 113 ``AS_TIMEOUT``                  0x1 :class:`AdvancedSplash` will be destroyed after `timeout` milliseconds.
 114 ``AS_NOTIMEOUT``                0x2 :class:`AdvancedSplash` can be destroyed by clicking on it,
 115                                             pressing a key or by explicitly call the `Close()` method.
 116 ``AS_CENTER_ON_SCREEN``         0x4 :class:`AdvancedSplash` will be centered on screen.
 117 ``AS_CENTER_ON_PARENT``         0x8 :class:`AdvancedSplash` will be centered on parent.
 118 ``AS_NO_CENTER``               0x10 :class:`AdvancedSplash` will not be centered.
 119 ``AS_SHADOW_BITMAP``           0x20 If the bitmap you pass as input has no transparency,
 120                                     you can choose one colour that will be masked in your bitmap.
 121                                     the final shape of :class:`AdvancedSplash` will be defined only
 122                                     by non-transparent (non-masked) pixels.
 123 ======================= =========== ==================================================
 124 
 125 
 126 Events Processing
 127 =================
 128 
 129 `No custom events are available for this class.`
 130 
 131 
 132 License And Version
 133 ===================
 134 
 135 :class:`AdvancedSplash` control is distributed under the wxPython license.
 136 
 137 Latest revision: Andrea Gavana @ 19 Dec 2012, 21.00 GMT
 138 
 139 Version 0.5
 140 
 141 """
 142 
 143 # def opj
 144 # class AdvancedSplash
 145 # class MyFrame
 146 # class MyApp
 147 
 148 #-------------------------------------------------------------------------------
 149 # Beginning Of ADVANCEDSPLASH wxPython Code.
 150 #-------------------------------------------------------------------------------
 151 
 152 # These Are Used To Declare If The AdvancedSplash Should Be
 153 # Destroyed After The Timeout Or Not.
 154 AS_TIMEOUT = 1
 155 """:class:`AdvancedSplash` will be destroyed after `timeout` milliseconds. """
 156 AS_NOTIMEOUT = 2
 157 """ :class:`AdvancedSplash` can be destroyed by clicking on it,
 158             pressing a key or by explicitly call the `Close()` method. """
 159 
 160 # These Flags Are Used To Position AdvancedSplash Correctly On Screen.
 161 AS_CENTER_ON_SCREEN = 4
 162 """ :class:`AdvancedSplash` will be centered on screen. """
 163 AS_CENTER_ON_PARENT = 8
 164 """ :class:`AdvancedSplash` will be centered on parent. """
 165 AS_NO_CENTER = 16
 166 """ :class:`AdvancedSplash` will not be centered. """
 167 
 168 # This Option Allow To Mask A Colour In The Input Bitmap.
 169 AS_SHADOW_BITMAP = 32
 170 """ If the bitmap you pass as input has no transparency,
 171     you can choose one colour that will be masked in your bitmap.
 172     The final shape of :class:`AdvancedSplash` will be defined
 173     only by non-transparent (non-masked) pixels. """
 174 
 175 #-------------------------------------------------------------------------------
 176 
 177 def opj(path):
 178     """
 179     Convert paths to the platform-specific separator.
 180     """
 181 
 182     st = os.path.join(*tuple(path.split('/')))
 183     # HACK: on Linux, a leading / gets lost...
 184     if path.startswith('/'):
 185         st = '/' + st
 186     return st
 187 
 188 #-------------------------------------------------------------------------------
 189 # ADVANCEDSPLASH Class.
 190 # This Is The Main Class Implementation. See __init__() Method For
 191 # details.
 192 #-------------------------------------------------------------------------------
 193 
 194 class AdvancedSplash(wx.Frame):
 195     """
 196     :class:`AdvancedSplash` tries to reproduce the behavior of :class:`~adv.SplashScreen`, with
 197     some enhancements.
 198 
 199     This is the main class implementation.
 200     """
 201     def __init__(self, parent, id=-1, pos=wx.DefaultPosition, size=wx.DefaultSize,
 202                  style=wx.FRAME_NO_TASKBAR | wx.FRAME_SHAPED | wx.STAY_ON_TOP,
 203                  bitmap=None, timeout=5000,
 204                  agwStyle=AS_TIMEOUT | AS_CENTER_ON_SCREEN,
 205                  shadowcolour=wx.NullColour):
 206         """
 207         Default class constructor.
 208 
 209         :param `parent`: parent window;
 210         :param integer `id`: window identifier. A value of -1 indicates a default value;
 211         :param `pos`: the control position. A value of (-1, -1) indicates a default position,
 212          chosen by either the windowing system or wxPython, depending on platform;
 213         :param `size`: the control size. A value of (-1, -1) indicates a default size,
 214          chosen by either the windowing system or wxPython, depending on platform;
 215         :param integer `style`: the underlying :class:`wx.Frame` style;
 216         :param `bitmap`: this must be a valid bitmap, that you may construct using
 217          whatever image file format supported by wxPython. If the file you load
 218          already supports mask/transparency (like png), the transparent areas
 219          will not be drawn on screen, and the :class:`AdvancedSplash` frame will have
 220          the shape defined only by *non-transparent* pixels.
 221          If you use other file formats that does not supports transparency, you
 222          can obtain the same effect as above by masking a specific colour in
 223          your :class:`wx.Bitmap`.
 224         :param integer `timeout`: if you construct :class:`AdvancedSplash` using the style ``AS_TIMEOUT``,
 225          :class:`AdvancedSplash` will be destroyed after `timeout` milliseconds;
 226         :param integer `agwStyle`: this value specifies the :class:`AdvancedSplash` styles:
 227 
 228          ======================= =========== ==================================================
 229          Window Styles           Hex Value   Description
 230          ======================= =========== ==================================================
 231          ``AS_TIMEOUT``                  0x1 :class:`AdvancedSplash` will be destroyed after `timeout` milliseconds.
 232          ``AS_NOTIMEOUT``                0x2 :class:`AdvancedSplash` can be destroyed by clicking on it,
 233                                                      pressing a key or by explicitly call the `Close()` method.
 234          ``AS_CENTER_ON_SCREEN``         0x4 :class:`AdvancedSplash` will be centered on screen.
 235          ``AS_CENTER_ON_PARENT``         0x8 :class:`AdvancedSplash` will be centered on parent.
 236          ``AS_NO_CENTER``               0x10 :class:`AdvancedSplash` will not be centered.
 237          ``AS_SHADOW_BITMAP``           0x20 If the bitmap you pass as input has no transparency,
 238                                              you can choose one colour that will be masked in your bitmap.
 239                                              The final shape of :class:`AdvancedSplash` will be defined
 240                                              only by non-transparent (non-masked) pixels.
 241          ======================= =========== ==================================================
 242 
 243         :param `shadowcolour`: if you construct :class:`AdvancedSplash` using the style
 244          ``AS_SHADOW_BITMAP``, here you can specify the colour that will be masked on
 245          your input bitmap. This has to be a valid wxPython colour.
 246 
 247         :type parent: :class:`wx.Window`
 248         :type pos: tuple or :class:`wx.Point`
 249         :type size: tuple or :class:`wx.Size`
 250         :type bitmap: :class:`wx.Bitmap`
 251         :type shadowcolour: :class:`wx.Colour`
 252 
 253         :raise: `Exception` in the following cases:
 254 
 255          - The ``AS_TIMEOUT`` style is set but `timeout` is not a positive integer;
 256          - The ``AS_SHADOW_BITMAP`` style is set but `shadowcolour` is not a valid wxPython colour;
 257          - The :class:`AdvancedSplash` bitmap is an invalid :class:`wx.Bitmap`.
 258         """
 259 
 260         wx.Frame.__init__(self, parent, id, "", pos, size, style)
 261 
 262         # Some Error Checking.
 263         if agwStyle & AS_TIMEOUT and timeout <= 0:
 264             raise Exception('\nERROR: Style "AS_TIMEOUT" Used With Invalid "timeout" Parameter Value (' \
 265                             + str(timeout) + ')')
 266 
 267         if agwStyle & AS_SHADOW_BITMAP and not shadowcolour.IsOk():
 268             raise Exception('\nERROR: Style "AS_SHADOW_BITMAP" Used With Invalid "shadowcolour" Parameter')
 269 
 270         if not bitmap or not bitmap.IsOk():
 271             raise Exception("\nERROR: Bitmap Passed To AdvancedSplash Is Invalid.")
 272 
 273         if agwStyle & AS_SHADOW_BITMAP:
 274             # Our Bitmap Is Masked Accordingly To User Input.
 275             self.bmp = self.ShadowBitmap(bitmap, shadowcolour)
 276         else:
 277             self.bmp = bitmap
 278 
 279         self._agwStyle = agwStyle
 280 
 281         #--------------
 282 
 283         # Attributes.
 284         self.SetTransparent(0)
 285         self.opacity_in = 0
 286         self.deltaN = -50
 287 
 288         #--------------
 289 
 290         # Setting Initial Properties.
 291         self.SetText()
 292         self.SetTextFont()
 293         self.SetTextPosition()
 294         self.SetTextColour()
 295 
 296         #------------
 297 
 298         # Calculate The Shape Of AdvancedSplash Using The Input-Modified Bitmap.
 299         self.reg = wx.Region(self.bmp)
 300 
 301         # Don't Know If It Works On Other Platforms!!
 302         # Tested Only In Windows XP/2000.
 303 
 304         if wx.Platform == "__WXGTK__":
 305             self.Bind(wx.EVT_WINDOW_CREATE, self.SetSplashShape)
 306         else:
 307             self.SetSplashShape()
 308 
 309         #------------
 310 
 311         w = self.bmp.GetWidth() + 1
 312         h = self.bmp.GetHeight() + 1
 313 
 314         # Set The AdvancedSplash Size To The Bitmap Size.
 315         self.SetClientSize((w, h))
 316 
 317         #------------
 318 
 319         if agwStyle & AS_CENTER_ON_SCREEN:
 320             self.CenterOnScreen()
 321         elif agwStyle & AS_CENTER_ON_PARENT:
 322             self.CenterOnParent()
 323 
 324         if agwStyle & AS_TIMEOUT:
 325             # Starts The Timer. Once Expired, AdvancedSplash Is Destroyed.
 326             self._splashtimer = wx.Timer(self)
 327             self.Bind(wx.EVT_TIMER, self.OnNotify)
 328             self._splashtimer.Start(timeout)
 329 
 330         #------------
 331 
 332         # Catch Some Mouse Events, To Behave Like wx.SplashScreen.
 333         self.Bind(wx.EVT_PAINT, self.OnPaint)
 334         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 335         self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouseEvents)
 336         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 337 
 338         #------------
 339 
 340         # Show main frame after 3000 ms.
 341         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 342 
 343         #------------
 344 
 345         # Simplified init method.
 346         self.OnTimerIn(self)
 347 
 348         #------------
 349 
 350         self.Show()
 351 
 352         if wx.Platform == "__WXMAC__":
 353             wx.SafeYield(self, True)
 354 
 355         #------------
 356 
 357         wx.BeginBusyCursor()
 358 
 359     #---------------------------------------------------------------------------
 360 
 361     def OnTimerIn(self, evt):
 362         """
 363         Thanks to Pascal Faut.
 364         """
 365 
 366         self.timer1 = wx.Timer(self, -1)
 367         self.timer1.Start(1)
 368         self.Bind(wx.EVT_TIMER, self.AlphaCycle1, self.timer1)
 369 
 370         print("Fade-in was launched.")
 371 
 372 
 373     def AlphaCycle1(self, *args):
 374         """
 375         Thanks to Pascal Faut.
 376         """
 377 
 378         self.opacity_in += self.deltaN
 379         if self.opacity_in <= 0:
 380             self.deltaN = -self.deltaN
 381             self.opacity_in = 0
 382 
 383         if self.opacity_in >= 255:
 384             self.deltaN = -self.deltaN
 385             self.opacity_in = 255
 386 
 387             self.timer1.Stop()
 388 
 389         self.SetTransparent(self.opacity_in)
 390 
 391         print("Fade in = {}/255".format(self.opacity_in))
 392 
 393 
 394     def SetSplashShape(self, event=None):
 395         """
 396         Sets :class:`AdvancedSplash` shape using the region created from the bitmap.
 397 
 398         :param `event`: a :class:`wx.WindowCreateEvent` event (GTK only, as GTK supports setting
 399          the window shape only during window creation).
 400         """
 401 
 402         self.SetShape(self.reg)
 403 
 404         if event is not None:
 405             event.Skip()
 406 
 407 
 408     def ShadowBitmap(self, bmp, shadowcolour):
 409         """
 410         Applies a mask on the bitmap accordingly to user input.
 411 
 412         :param `bmp`: the bitmap to which we want to apply the mask colour `shadowcolour`;
 413         :param `shadowcolour`: the mask colour for our bitmap.
 414         :type bmp: :class:`wx.Bitmap`
 415         :type shadowcolour: :class:`wx.Colour`
 416 
 417         :return: A masked version of the input bitmap, an instance of :class:`wx.Bitmap`.
 418         """
 419 
 420         mask = wx.Mask(bmp, shadowcolour)
 421         bmp.SetMask(mask)
 422 
 423         return bmp
 424 
 425 
 426     def OnPaint(self, event):
 427         """
 428         Handles the ``wx.EVT_PAINT`` event for :class:`AdvancedSplash`.
 429 
 430         :param `event`: a :class:`PaintEvent` to be processed.
 431         """
 432 
 433         dc = wx.BufferedPaintDC(self)
 434 
 435         # Here We Redraw The Bitmap Over The Frame.
 436         dc.DrawBitmap(self.bmp, -1, -1, True)
 437 
 438         # We Draw The Text Anyway, Wheter It Is Empty ("") Or Not.
 439         textcolour = self.GetTextColour()
 440         textfont = self.GetTextFont()
 441         textpos = self.GetTextPosition()
 442         text = self.GetText()
 443 
 444         dc.SetFont(textfont[0])
 445         dc.SetTextForeground(textcolour)
 446         dc.DrawText(text, textpos[0], textpos[1])
 447 
 448 
 449     def OnNotify(self, event):
 450         """
 451         Handles the timer expiration, and calls the `Close()` method.
 452 
 453         :param `event`: a :class:`wx.TimerEvent` to be processed.
 454         """
 455 
 456         self.Close()
 457 
 458 
 459     def OnMouseEvents(self, event):
 460         """
 461         Handles the ``wx.EVT_MOUSE_EVENTS`` events for :class:`AdvancedSplash`.
 462 
 463         :param `event`: a :class:`MouseEvent` to be processed.
 464 
 465         :note: This reproduces the behavior of :class:`~adv.SplashScreen`.
 466         """
 467 
 468         if event.LeftDown() or event.RightDown():
 469             self.OnClose(event)
 470 
 471         event.Skip()
 472 
 473 
 474     def OnCharEvents(self, event):
 475         """
 476         Handles the ``wx.EVT_CHAR`` event for :class:`AdvancedSplash`.
 477 
 478         :param `event`: a :class:`KeyEvent` to be processed.
 479 
 480         :note: This reproduces the behavior of :class:`~adv.SplashScreen`.
 481         """
 482 
 483         self.OnClose(event)
 484 
 485 
 486     def OnCloseWindow(self, event):
 487         """
 488         Handles the ``wx.EVT_CLOSE`` event for :class:`AdvancedSplash`.
 489 
 490         :param `event`: a :class:`CloseEvent` to be processed.
 491 
 492         :note: This reproduces the behavior of :class:`~adv.SplashScreen`.
 493         """
 494 
 495         if hasattr(self, "_splashtimer"):
 496             self._splashtimer.Stop()
 497             del self._splashtimer
 498 
 499         self.Destroy()
 500 
 501 
 502     def OnClose(self, event):
 503         """
 504         Handles the wx.EVT_CLOSE event for SplashScreen.
 505         """
 506 
 507         # Make sure the default handler runs
 508         # too so this window gets destroyed.
 509         # Tell the event system to continue
 510         # looking for an event handler, so the
 511         # default handler will get called.
 512         event.Skip()
 513         self.Hide()
 514 
 515         #------------
 516 
 517         # If the timer is still running then go
 518         # ahead and show the main frame now.
 519         if self.fc.IsRunning():
 520             # Stop the wx.CallLater timer.
 521             # Stop the splash screen timer
 522             # and close it.
 523             self.fc.Stop()
 524             self.ShowMainFrame()
 525 
 526 
 527     def SetText(self, text=None):
 528         """
 529         Sets the text to be displayed on :class:`AdvancedSplash`.
 530 
 531         :param `text`: the text we want to display on top of the bitmap. If `text` is
 532          set to ``None``, nothing will be drawn on top of the bitmap.
 533         :type text: string or ``None``
 534         """
 535 
 536         if text is None:
 537             text = ""
 538 
 539         self._text = text
 540 
 541         self.Refresh()
 542         self.Update()
 543 
 544 
 545     def GetText(self):
 546         """
 547         Returns the text displayed on :class:`AdvancedSplash`.
 548 
 549         :return: A string representing the text drawn on top of the :class:`AdvancedSplash` bitmap.
 550         """
 551 
 552         return self._text
 553 
 554 
 555     def SetTextFont(self, font=None):
 556         """
 557         Sets the font for the text in :class:`AdvancedSplash`.
 558 
 559         :param `font`: the font to use while drawing the text on top of our bitmap. If `font`
 560          is ``None``, a simple generic font is generated.
 561         :type font: :class:`wx.Font` or ``None``
 562         """
 563 
 564         if font is None:
 565             self._textfont = wx.Font(1, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_BOLD, False)
 566             self._textsize = 10.0
 567             self._textfont.SetPointSize(int(self._textsize))
 568         else:
 569             self._textfont = font
 570             self._textsize = font.GetPointSize()
 571             self._textfont.SetPointSize(int(self._textsize))
 572 
 573         self.Refresh()
 574         self.Update()
 575 
 576 
 577     def GetTextFont(self):
 578         """
 579         Gets the font for the text in :class:`AdvancedSplash`.
 580 
 581         :return: An instance of :class:`wx.Font` to draw the text and a :class:`wx.Size` object containing
 582          the text width an height, in pixels.
 583         """
 584 
 585         return self._textfont, self._textsize
 586 
 587 
 588     def SetTextColour(self, colour=None):
 589         """
 590         Sets the colour for the text in :class:`AdvancedSplash`.
 591 
 592         :param `colour`: the text colour to use while drawing the text on top of our
 593          bitmap. If `colour` is ``None``, then ``wx.BLACK`` is used.
 594         :type colour: :class:`wx.Colour` or ``None``
 595         """
 596 
 597         if colour is None:
 598             colour = wx.BLACK
 599 
 600         self._textcolour = colour
 601         self.Refresh()
 602         self.Update()
 603 
 604 
 605     def GetTextColour(self):
 606         """
 607         Gets the colour for the text in :class:`AdvancedSplash`.
 608 
 609         :return: An instance of :class:`wx.Colour`.
 610         """
 611 
 612         return self._textcolour
 613 
 614 
 615     def SetTextPosition(self, position=None):
 616         """
 617         Sets the text position inside :class:`AdvancedSplash` frame.
 618 
 619         :param `position`: the text position inside our bitmap. If `position` is ``None``,
 620          the text will be placed at the top-left corner.
 621         :type position: tuple or ``None``
 622         """
 623 
 624         if position is None:
 625             position = (0, 0)
 626 
 627         self._textpos = position
 628         self.Refresh()
 629         self.Update()
 630 
 631 
 632     def GetTextPosition(self):
 633         """
 634         Returns the text position inside :class:`AdvancedSplash` frame.
 635 
 636         :return: A tuple containing the text `x` and `y` position inside the :class:`AdvancedSplash` frame.
 637         """
 638 
 639         return self._textpos
 640 
 641 
 642     def GetSplashStyle(self):
 643         """
 644         Returns a list of strings and a list of integers containing the styles.
 645 
 646         :return: Two Python lists containing the style name and style values for :class:`AdvancedSplash`.
 647         """
 648 
 649         stringstyle = []
 650         integerstyle = []
 651 
 652         if self._agwStyle & AS_TIMEOUT:
 653             stringstyle.append("AS_TIMEOUT")
 654             integerstyle.append(AS_TIMEOUT)
 655 
 656         if self._agwStyle & AS_NOTIMEOUT:
 657             stringstyle.append("AS_NOTIMEOUT")
 658             integerstyle.append(AS_NOTIMEOUT)
 659 
 660         if self._agwStyle & AS_CENTER_ON_SCREEN:
 661             stringstyle.append("AS_CENTER_ON_SCREEN")
 662             integerstyle.append(AS_CENTER_ON_SCREEN)
 663 
 664         if self._agwStyle & AS_CENTER_ON_PARENT:
 665             stringstyle.append("AS_CENTER_ON_PARENT")
 666             integerstyle.append(AS_CENTER_ON_PARENT)
 667 
 668         if self._agwStyle & AS_NO_CENTER:
 669             stringstyle.append("AS_NO_CENTER")
 670             integerstyle.append(AS_NO_CENTER)
 671 
 672         if self._agwStyle & AS_SHADOW_BITMAP:
 673             stringstyle.append("AS_SHADOW_BITMAP")
 674             integerstyle.append(AS_SHADOW_BITMAP)
 675 
 676         return stringstyle, integerstyle
 677 
 678 
 679     def ShowMainFrame(self):
 680         """
 681         ...
 682         """
 683 
 684         #------------
 685 
 686         wx.CallAfter(wx.EndBusyCursor)
 687 
 688         #------------
 689 
 690         if self.fc.IsRunning():
 691             # Stop the splash screen
 692             # timer and close it.
 693             self.Raise()
 694 
 695         #------------
 696 
 697         # Create an instance of the MyFrame class.
 698         frame = MyFrame()
 699         frame.Center()
 700         frame.Show(True)
 701 
 702 #-------------------------------------------------------------------------------
 703 
 704 class MyFrame(wx.Frame):
 705     """
 706     ...
 707     """
 708     def __init__(self):
 709         super(MyFrame, self).__init__(None,
 710                                       -1,
 711                                       title="")
 712 
 713         #------------
 714 
 715         # Return application name.
 716         self.app_name = wx.GetApp().GetAppName()
 717         # Return icons folder.
 718         self.icons_dir = wx.GetApp().GetIconsDir()
 719 
 720         #------------
 721 
 722         # Simplified init method.
 723         self.SetProperties()
 724         self.CreateCtrls()
 725         self.BindEvents()
 726         self.DoLayout()
 727 
 728         #------------
 729 
 730         self.CenterOnScreen(wx.BOTH)
 731 
 732     #---------------------------------------------------------------------------
 733 
 734     def SetProperties(self):
 735         """
 736         ...
 737         """
 738 
 739         self.SetTitle("Main frame")
 740         self.SetSize((400, 300))
 741 
 742         #------------
 743 
 744         frameIcon = wx.Icon(os.path.join(self.icons_dir,
 745                                          "icon_wxWidgets.ico"),
 746                             type=wx.BITMAP_TYPE_ICO)
 747         self.SetIcon(frameIcon)
 748 
 749 
 750     def CreateCtrls(self):
 751         """
 752         ...
 753         """
 754 
 755         # Create a panel.
 756         self.panel = wx.Panel(self, -1)
 757 
 758         #------------
 759 
 760         # Add a button.
 761         self.btnClose = wx.Button(self.panel,
 762                                   -1,
 763                                   "&Close")
 764 
 765 
 766     def BindEvents(self):
 767         """
 768         Bind some events to an events handler.
 769         """
 770 
 771         # Bind events to an events handler.
 772         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 773         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
 774 
 775 
 776     def DoLayout(self):
 777         """
 778         ...
 779         """
 780 
 781         # MainSizer is the top-level one that manages everything.
 782         mainSizer = wx.BoxSizer(wx.VERTICAL)
 783 
 784         # wx.BoxSizer(window, proportion, flag, border)
 785         # wx.BoxSizer(sizer, proportion, flag, border)
 786         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 787 
 788         # Finally, tell the panel to use the sizer for layout.
 789         self.panel.SetAutoLayout(True)
 790         self.panel.SetSizer(mainSizer)
 791 
 792         mainSizer.Fit(self.panel)
 793 
 794 
 795     def OnCloseMe(self, event):
 796         """
 797         ...
 798         """
 799 
 800         self.Close(True)
 801 
 802 
 803     def OnCloseWindow(self, event):
 804         """
 805         ...
 806         """
 807 
 808         self.Destroy()
 809 
 810 #-------------------------------------------------------------------------------
 811 
 812 class MyApp(wx.App):
 813     """
 814     ...
 815     """
 816     def OnInit(self):
 817 
 818         #------------
 819 
 820         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 821 
 822         #------------
 823 
 824         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 825 
 826         #------------
 827 
 828         # Return bitmaps folder.
 829         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 830 
 831         # Load a background bitmap.
 832         bmp = wx.Bitmap(os.path.join(self.bitmaps_dir,
 833                                      "advancedsplash.png"),
 834                         type=wx.BITMAP_TYPE_PNG)
 835         shadow = wx.WHITE
 836 
 837         splash = AdvancedSplash(None,
 838                                 bitmap=bmp,
 839                                 timeout=5000,
 840                                 agwStyle=AS_TIMEOUT |
 841                                          AS_CENTER_ON_PARENT |
 842                                          AS_SHADOW_BITMAP,
 843                                 shadowcolour=shadow)
 844         splash.SetText("Loading...")
 845         splash.SetTextColour(wx.WHITE)
 846         position = (40, 270)
 847         splash.SetTextPosition(position)
 848 
 849         #------------
 850 
 851         return True
 852 
 853     #---------------------------------------------------------------------------
 854 
 855     def GetInstallDir(self):
 856         """
 857         Returns the installation directory for my application.
 858         """
 859 
 860         return self.installDir
 861 
 862 
 863     def GetIconsDir(self):
 864         """
 865         Returns the icons directory for my application.
 866         """
 867 
 868         icons_dir = os.path.join(self.installDir, "icons")
 869         return icons_dir
 870 
 871 
 872     def GetBitmapsDir(self):
 873         """
 874         Returns the bitmaps directory for my application.
 875         """
 876 
 877         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 878         return bitmaps_dir
 879 
 880 #-------------------------------------------------------------------------------
 881 
 882 def main():
 883     app = MyApp(False)
 884     app.MainLoop()
 885 
 886 #-------------------------------------------------------------------------------
 887 
 888 if __name__ == "__main__" :
 889     main()


With alpha (only Windows)

Thank you so much to Kevin Schlosser and Metallicow for the "Alpha" source code.

ShapedWindow with Alpha that works on wxPy4.0 and 4.1.

I like it ! (Ecco ;) ).

First example

img_sample_seven_a.png

   1 # sample_seven_a.py
   2 
   3 import os
   4 import sys
   5 import platform
   6 import time
   7 import wx
   8 import wx.lib.fancytext as fancytext
   9 try:
  10     from wx.lib.mswalpha import draw_alpha
  11 except ImportError:
  12     from mswalpha import draw_alpha
  13 
  14 # class MyFrame
  15 # class MySplash
  16 # class MyApp
  17 
  18 #---------------------------------------------------------------------------
  19 
  20 class MyFrame(wx.Frame):
  21     """
  22     ...
  23     """
  24     def __init__(self):
  25         super(MyFrame, self).__init__(None,
  26                                       -1,
  27                                       title="")
  28 
  29         #------------
  30 
  31         # Return application name.
  32         self.app_name = wx.GetApp().GetAppName()
  33         # Return icons folder.
  34         self.icons_dir = wx.GetApp().GetIconsDir()
  35 
  36         #------------
  37 
  38         # Simplified init method.
  39         self.SetProperties()
  40         self.CreateCtrls()
  41         self.BindEvents()
  42         self.DoLayout()
  43 
  44         #------------
  45 
  46         self.CenterOnScreen(wx.BOTH)
  47 
  48         #------------
  49 
  50         self.Show(True)
  51 
  52     #-----------------------------------------------------------------------
  53 
  54     def SetProperties(self):
  55         """
  56         ...
  57         """
  58 
  59         self.SetTitle(self.app_name)
  60         self.SetSize((340, 200))
  61 
  62         #------------
  63 
  64         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  65                                          "icon_wxWidgets.ico"),
  66                             type=wx.BITMAP_TYPE_ICO)
  67         self.SetIcon(frameIcon)
  68 
  69 
  70     def CreateCtrls(self):
  71         """
  72         ...
  73         """
  74 
  75         # Create a panel.
  76         self.panel = wx.Panel(self, -1)
  77 
  78         #------------
  79 
  80         # Add a buttons.
  81         self.btnClose = wx.Button(self.panel,
  82                                   -1,
  83                                   "&Close")
  84 
  85 
  86     def BindEvents(self):
  87         """
  88         Bind some events to an events handler.
  89         """
  90 
  91         # Bind events to an events handler.
  92         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  93         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  94 
  95 
  96     def DoLayout(self):
  97         """
  98         ...
  99         """
 100 
 101         # MainSizer is the top-level one that manages everything.
 102         mainSizer = wx.BoxSizer(wx.VERTICAL)
 103 
 104         # wx.BoxSizer(window, proportion, flag, border)
 105         # wx.BoxSizer(sizer, proportion, flag, border)
 106         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 107 
 108         # Finally, tell the panel to use the sizer for layout.
 109         self.panel.SetAutoLayout(True)
 110         self.panel.SetSizer(mainSizer)
 111 
 112         mainSizer.Fit(self.panel)
 113 
 114 
 115     def OnCloseMe(self, event):
 116         """
 117         ...
 118         """
 119 
 120         self.Close(True)
 121 
 122 
 123     def OnCloseWindow(self, event):
 124         """
 125         ...
 126         """
 127 
 128         self.Destroy()
 129         wx.Exit()
 130 
 131 #-------------------------------------------------------------------------------
 132 
 133 class MySplash(wx.Frame):
 134     """
 135     Thanks to Robin Dunn.
 136     """
 137     style = (wx.FRAME_SHAPED | wx.BORDER_NONE |
 138              wx.FRAME_NO_TASKBAR | wx.STAY_ON_TOP)
 139     def __init__(self, parent, id=wx.ID_ANY, title=wx.EmptyString,
 140                  pos=wx.DefaultPosition, size=wx.DefaultSize,
 141                  style=style,
 142                  name='frame'):
 143         wx.Frame.__init__(self, parent, id, title, pos, size, style, name)
 144 
 145         #------------
 146 
 147         # Attributes.
 148         self.delta = wx.Point(0,0)
 149 
 150         #------------
 151 
 152         # Return application name.
 153         self.app_name = wx.GetApp().GetAppName()
 154         # Return bitmaps folder.
 155         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 156         # Return icons folder.
 157         self.icons_dir = wx.GetApp().GetIconsDir()
 158 
 159         #------------
 160 
 161         # Starts the Timer. Once Expired, splash is Destroyed.
 162         self.timer = wx.Timer(self)
 163         self.timer.Start(4000)
 164         self.Bind(wx.EVT_TIMER, self.TimeOut, self.timer)
 165 
 166         #--------------
 167 
 168         # Show main frame after 3000 ms.
 169         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 170 
 171         #------------
 172 
 173         # Simplified init method.
 174         self.SetProperties()
 175         self.CreateCtrls()
 176         self.BindEvents()
 177 
 178         #--------------
 179 
 180         self.CenterOnScreen(wx.BOTH)
 181 
 182         #------------
 183 
 184         wx.BeginBusyCursor()
 185 
 186     #---------------------------------------------------------------------------
 187 
 188     def SetProperties(self):
 189         """
 190         ...
 191         """
 192 
 193         self.SetTitle(self.app_name)
 194         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 195 
 196         frameIcon = wx.Icon(os.path.join(self.icons_dir,
 197                                          "icon_wxWidgets.ico"),
 198                             type=wx.BITMAP_TYPE_ICO)
 199         self.SetIcon(frameIcon)
 200 
 201 
 202     def CreateCtrls(self):
 203         """
 204         ...
 205         """
 206 
 207         # Load a background bitmap.
 208         self.bitmap = wx.Bitmap(os.path.join(self.bitmaps_dir,
 209                                              "wxPython.png"),
 210                                 type=wx.BITMAP_TYPE_PNG)
 211         # or
 212         # image = wx.Image('phone.png', wx.BITMAP_TYPE_PNG)
 213         # blurimage = image.Blur(1)
 214         # self.bitmap = blurimage.ConvertToBitmap()
 215 
 216         self.SetClientSize((self.bitmap.GetWidth(), self.bitmap.GetHeight()))
 217 
 218         #------------
 219 
 220         if wx.Platform == "__WXGTK__":
 221             # wxGTK requires that the window be created before you can
 222             # set its shape, so delay the call to SetWindowShape until
 223             # this event.
 224             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 225         else:
 226             # On wxMSW and wxMac the window has
 227             # already been created, so go for it.
 228             self.SetWindowShape()
 229 
 230 
 231     def BindEvents(self):
 232         """
 233         Bind some events to an events handle.
 234         """
 235 
 236         self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x: None)
 237         # self.Bind(wx.EVT_MOTION, self.OnMouseMove)
 238         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
 239         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
 240         self.Bind(wx.EVT_RIGHT_UP, self.OnClose)
 241         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 242         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 243         self.Bind(wx.EVT_PAINT, self.OnPaint)
 244 
 245 
 246     def SetWindowShape(self, *event):
 247         """
 248         ...
 249         """
 250 
 251         # Use the bitmap's mask to determine the region.
 252         self.region = wx.Region(self.bitmap)
 253         self.hasShape = self.SetShape(self.region)
 254 
 255 
 256     def OnLeftDown(self, event):
 257         """
 258         ...
 259         """
 260 
 261         if self.HasCapture():
 262             self.ReleaseMouse()
 263 
 264         self.CaptureMouse()
 265         x, y = self.ClientToScreen(event.GetPosition())
 266         originx, originy = self.GetPosition()
 267         dx = x - originx
 268         dy = y - originy
 269         self.delta = (dx, dy)
 270 
 271 
 272     def OnLeftUp(self, event):
 273         """
 274         ...
 275         """
 276 
 277         if self.HasCapture():
 278             self.ReleaseMouse()
 279 
 280 
 281     def OnMouseMove(self, event):
 282         """
 283         ...
 284         """
 285 
 286         if event.Dragging() and event.LeftIsDown():
 287             x, y = self.ClientToScreen(event.GetPosition())
 288             fp = (x - self.delta[0], y - self.delta[1])
 289             self.SetPosition(fp)
 290 
 291 
 292     def Draw(self):
 293         """
 294         ...
 295         """
 296 
 297         # Return client size.
 298         width, height = self.GetClientSize()
 299 
 300         # Return main image size.
 301         bw, bh = self.bitmap.GetWidth(), self.bitmap.GetHeight()
 302 
 303         #------------
 304 
 305         dc = wx.MemoryDC()
 306 
 307         #------------
 308 
 309         fontSize = self.GetFont().GetPointSize()
 310 
 311         # wx.Font(pointSize, family, style, weight, underline, faceName)
 312         if wx.Platform == "__WXMSW__":
 313             self.normalBoldFont = wx.Font(fontSize-1,
 314                                           wx.DEFAULT, wx.NORMAL,
 315                                           wx.NORMAL, False, "")
 316             self.normalFont = wx.Font(fontSize,
 317                                       wx.DEFAULT, wx.NORMAL,
 318                                       wx.NORMAL, False, "")
 319 
 320         dc.SetFont(self.normalFont)
 321         dc.SetFont(self.normalBoldFont)
 322 
 323         #------------
 324 
 325         bmp = wx.Bitmap.FromRGBA(width, height, red=0, green=0, blue=0, alpha=0)
 326         dc.SelectObject(bmp)
 327 
 328         #------------
 329 
 330         gc = wx.GraphicsContext.Create(dc)
 331         gcdc = wx.GCDC(gc)
 332 
 333         # Draw a bitmap with an alpha channel
 334         # on top of the last group.
 335         # image, x, y, transparence
 336         gcdc.DrawBitmap(self.bitmap, -1, -1, useMask=False)
 337 
 338         # Draw text.
 339         gcdc.SetTextForeground(wx.Colour(255, 255, 255, 100))  # white
 340         gcdc.SetTextBackground(wx.TransparentColour)
 341         gcdc.SetFont(self.normalBoldFont)
 342         firstTxt = "wxPython is a Python extension module that\n"\
 343                    " encapsulates the wxWindows GUI classes."
 344         tw, th = gcdc.GetTextExtent(firstTxt)
 345         gcdc.DrawText(firstTxt, (int((bw-tw)/2), int(245)))
 346 
 347         gcdc.SetTextForeground(wx.Colour(250, 250, 250, 255))  # white
 348         gcdc.SetTextBackground(wx.TransparentColour)
 349         gcdc.SetFont(self.normalFont)
 350         secondTxt = " wxPython is brought to you by Robin Dunn and\n"\
 351                    "Total Control Software, Copyright (c) 1997-2020."
 352         tw, th = gcdc.GetTextExtent(secondTxt)
 353         gcdc.DrawText(secondTxt, (int((bw-tw)/2), int(280)))
 354 
 355         #------------
 356 
 357         gcdc.Destroy()
 358         del gcdc
 359 
 360         dc.Destroy()
 361         del dc
 362 
 363         #------------
 364 
 365         draw_alpha(self, bmp)
 366 
 367 
 368     def OnTimer(self, event):
 369         """
 370         ...
 371         """
 372 
 373         dc = wx.BufferedDC(wx.ClientDC(self))
 374         dc.Clear()
 375 
 376         self.Draw()
 377 
 378 
 379     def OnPaint(self, event):
 380         """
 381         ...
 382         """
 383 
 384         dc = wx.BufferedPaintDC(self)
 385         dc.Clear()
 386 
 387         self.Draw()
 388 
 389 
 390     def OnCharEvents(self, event):
 391         """
 392         Handles the wx.EVT_CHAR for Splash.
 393         This reproduces the behavior of wx.SplashScreen.
 394         """
 395 
 396         self.OnClose(event)
 397 
 398 
 399     def TimeOut(self, event):
 400         """
 401         ...
 402         """
 403 
 404         self.Close(True)
 405 
 406 
 407     def OnClose(self, event):
 408         """
 409         Handles the wx.EVT_CLOSE event for SplashScreen.
 410         """
 411 
 412         # Make sure the default handler runs
 413         # too so this window gets destroyed.
 414         # Tell the event system to continue
 415         # looking for an event handler, so the
 416         # default handler will get called.
 417         event.Skip()
 418         self.Hide()
 419 
 420         #------------
 421 
 422         # If the timer is still running then go
 423         # ahead and show the main frame now.
 424         if self.fc.IsRunning():
 425             # Stop the wx.CallLater timer.
 426             # Stop the splash screen timer
 427             # and close it.
 428             self.fc.Stop()
 429             self.ShowMainFrame()
 430 
 431 
 432     def ShowMainFrame(self):
 433         """
 434         ...
 435         """
 436 
 437         print("\n... Close the splash screen")
 438         print("\n... Create and display the main frame")
 439 
 440         #------------
 441 
 442         wx.CallAfter(wx.EndBusyCursor)
 443 
 444         #------------
 445 
 446         if self.fc.IsRunning():
 447             # Stop the splash screen
 448             # timer and close it.
 449             self.Raise()
 450 
 451         #------------
 452 
 453         # Create an instance of the MyFrame class.
 454         frame = MyFrame()
 455 
 456 
 457     def OnCloseWindow(self, event):
 458         """
 459         ...
 460         """
 461 
 462         self.timer.Stop()
 463         self.Destroy()
 464 
 465 #---------------------------------------------------------------------------
 466 
 467 class MyApp(wx.App):
 468     """
 469     ...
 470     """
 471     def OnInit(self):
 472 
 473         #------------
 474 
 475         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 476 
 477         #------------
 478 
 479         self.SetAppName("Main frame")
 480 
 481         #------------
 482 
 483         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 484 
 485         #------------
 486 
 487         frame = MySplash(None)
 488         self.SetTopWindow(frame)
 489         frame.Show(True)
 490 
 491         return True
 492 
 493     #-----------------------------------------------------------------------
 494 
 495     def GetInstallDir(self):
 496         """
 497         Returns the installation directory for my application.
 498         """
 499 
 500         return self.installDir
 501 
 502 
 503     def GetIconsDir(self):
 504         """
 505         Returns the icons directory for my application.
 506         """
 507 
 508         icons_dir = os.path.join(self.installDir, "icons")
 509         return icons_dir
 510 
 511 
 512     def GetBitmapsDir(self):
 513         """
 514         Returns the bitmaps directory for my application.
 515         """
 516 
 517         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 518         return bitmaps_dir
 519 
 520 #---------------------------------------------------------------------------
 521 
 522 def main():
 523     app = MyApp(False)
 524     app.MainLoop()
 525 
 526 #---------------------------------------------------------------------------
 527 
 528 if __name__ == "__main__" :
 529     main()


Second example

img_sample_seven_b.png

   1 # sample_seven_b.py
   2 
   3 import os
   4 import sys
   5 import platform
   6 import time
   7 import wx
   8 import wx.lib.fancytext as fancytext
   9 try:
  10     from wx.lib.mswalpha import draw_alpha
  11 except ImportError:
  12     from mswalpha import draw_alpha
  13 
  14 # class MyFrame
  15 # class MySplash
  16 # class MyControls
  17 # class MyApp
  18 
  19 #---------------------------------------------------------------------------
  20 
  21 class MyFrame(wx.Frame):
  22     """
  23     ...
  24     """
  25     def __init__(self):
  26         super(MyFrame, self).__init__(None,
  27                                       -1,
  28                                       title="")
  29 
  30         #------------
  31 
  32         # Return application name.
  33         self.app_name = wx.GetApp().GetAppName()
  34         # Return icons folder.
  35         self.icons_dir = wx.GetApp().GetIconsDir()
  36 
  37         #------------
  38 
  39         # Simplified init method.
  40         self.SetProperties()
  41         self.CreateCtrls()
  42         self.BindEvents()
  43         self.DoLayout()
  44 
  45         #------------
  46 
  47         self.CenterOnScreen(wx.BOTH)
  48 
  49         #------------
  50 
  51         self.Show(True)
  52 
  53     #-----------------------------------------------------------------------
  54 
  55     def SetProperties(self):
  56         """
  57         ...
  58         """
  59 
  60         self.SetTitle(self.app_name)
  61         self.SetSize((340, 200))
  62 
  63         #------------
  64 
  65         frameIcon = wx.Icon(os.path.join(self.icons_dir,
  66                                          "icon_wxWidgets.ico"),
  67                             type=wx.BITMAP_TYPE_ICO)
  68         self.SetIcon(frameIcon)
  69 
  70 
  71     def CreateCtrls(self):
  72         """
  73         ...
  74         """
  75 
  76         # Create a panel.
  77         self.panel = wx.Panel(self, -1)
  78 
  79         #------------
  80 
  81         # Add a buttons.
  82         self.btnClose = wx.Button(self.panel,
  83                                   -1,
  84                                   "&Close")
  85 
  86 
  87     def BindEvents(self):
  88         """
  89         Bind some events to an events handler.
  90         """
  91 
  92         # Bind events to an events handler.
  93         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
  94         self.Bind(wx.EVT_BUTTON, self.OnCloseMe, self.btnClose)
  95 
  96 
  97     def DoLayout(self):
  98         """
  99         ...
 100         """
 101 
 102         # MainSizer is the top-level one that manages everything.
 103         mainSizer = wx.BoxSizer(wx.VERTICAL)
 104 
 105         # wx.BoxSizer(window, proportion, flag, border)
 106         # wx.BoxSizer(sizer, proportion, flag, border)
 107         mainSizer.Add(self.btnClose, 1, wx.EXPAND | wx.ALL, 10)
 108 
 109         # Finally, tell the panel to use the sizer for layout.
 110         self.panel.SetAutoLayout(True)
 111         self.panel.SetSizer(mainSizer)
 112 
 113         mainSizer.Fit(self.panel)
 114 
 115 
 116     def OnCloseMe(self, event):
 117         """
 118         ...
 119         """
 120 
 121         self.Close(True)
 122 
 123 
 124     def OnCloseWindow(self, event):
 125         """
 126         ...
 127         """
 128 
 129         self.Destroy()
 130         wx.Exit()
 131 
 132 #-------------------------------------------------------------------------------
 133 
 134 class MySplash(wx.Frame):
 135     """
 136     ...
 137     """
 138     style = (wx.FRAME_SHAPED | wx.NO_BORDER |
 139              wx.FRAME_NO_TASKBAR | wx.STAY_ON_TOP)
 140     def __init__(self, parent, id=wx.ID_ANY, title=wx.EmptyString,
 141                  pos=wx.DefaultPosition, size=wx.DefaultSize,
 142                  style=style,
 143                  name='frame'):
 144         wx.Frame.__init__(self, parent, id, title, pos, size, style, name)
 145 
 146         #------------
 147 
 148         # Attributes.
 149         self.delta = wx.Point(0,0)
 150 
 151         #------------
 152 
 153         # Return application name.
 154         self.app_name = wx.GetApp().GetAppName()
 155         # Return bitmaps folder.
 156         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 157         # Return icons folder.
 158         self.icons_dir = wx.GetApp().GetIconsDir()
 159 
 160         #------------
 161 
 162         # Starts the Timer. Once Expired, splash is Destroyed.
 163         self.timer = wx.Timer(self)
 164         self.timer.Start(4000)
 165         self.Bind(wx.EVT_TIMER, self.TimeOut, self.timer)
 166 
 167         #--------------
 168 
 169         # Show main frame after 3000 ms.
 170         self.fc = wx.CallLater(3000, self.ShowMainFrame)
 171 
 172         #------------
 173 
 174         # Simplified init method.
 175         self.SetProperties()
 176         self.CreateCtrls()
 177         self.BindEvents()
 178 
 179         #--------------
 180 
 181         self.CenterOnScreen(wx.BOTH)
 182 
 183         #------------
 184 
 185         wx.BeginBusyCursor()
 186 
 187     #---------------------------------------------------------------------------
 188 
 189     def SetProperties(self):
 190         """
 191         ...
 192         """
 193 
 194         self.SetTitle(self.app_name)
 195         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 196 
 197         frameIcon = wx.Icon(os.path.join(self.icons_dir,
 198                                          "icon_wxWidgets.ico"),
 199                             type=wx.BITMAP_TYPE_ICO)
 200         self.SetIcon(frameIcon)
 201 
 202 
 203     def CreateCtrls(self):
 204         """
 205         ...
 206         """
 207 
 208         # Load a background bitmap.
 209         self.bitmap = wx.Bitmap(os.path.join(self.bitmaps_dir,
 210                                              "wxWidgets.png"),
 211                                 type=wx.BITMAP_TYPE_PNG)
 212         # or
 213         # image = wx.Image('phone.png', wx.BITMAP_TYPE_PNG)
 214         # blurimage = image.Blur(1)
 215         # self.bitmap = blurimage.ConvertToBitmap()
 216 
 217         self.SetClientSize((self.bitmap.GetWidth(), self.bitmap.GetHeight()))
 218 
 219         #------------
 220 
 221         if wx.Platform == "__WXGTK__":
 222             # wxGTK requires that the window be created before you can
 223             # set its shape, so delay the call to SetWindowShape until
 224             # this event.
 225             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 226         else:
 227             # On wxMSW and wxMac the window has
 228             # already been created, so go for it.
 229             self.SetWindowShape()
 230 
 231         #------------
 232 
 233         # It appears that we cannot make child widgets on the Frame
 234         # when using mswalpha, there fore we will make a "child" shaped
 235         # frame that will handle widgets transparency also.
 236         # self.button = wx.Button(self, -1, 'Button', pos=(100, 100))
 237 
 238         #------------
 239 
 240         self.Centre()
 241         self.widgetsframe = MyControls(self,
 242                                        pos=self.GetPosition(),
 243                                        size=self.GetSize())
 244         self.widgetsframe.Show()
 245 
 246 
 247     def BindEvents(self):
 248         """
 249         Bind some events to an events handle.
 250         """
 251 
 252         self.Bind(wx.EVT_ERASE_BACKGROUND, lambda x: None)
 253         # self.Bind(wx.EVT_MOTION, self.OnMouseMove)
 254         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
 255         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
 256         self.Bind(wx.EVT_RIGHT_UP, self.OnClose)
 257         self.Bind(wx.EVT_CHAR, self.OnCharEvents)
 258         self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
 259         self.Bind(wx.EVT_PAINT, self.OnPaint)
 260 
 261 
 262     def SetWindowShape(self, *event):
 263         """
 264         ...
 265         """
 266 
 267         # Use the bitmap's mask to determine the region.
 268         self.region = wx.Region(self.bitmap)
 269         self.hasShape = self.SetShape(self.region)
 270 
 271 
 272     def OnLeftDown(self, event):
 273         """
 274         ...
 275         """
 276 
 277         if self.HasCapture():
 278             self.ReleaseMouse()
 279 
 280         self.CaptureMouse()
 281         x, y = self.ClientToScreen(event.GetPosition())
 282         originx, originy = self.GetPosition()
 283         dx = x - originx
 284         dy = y - originy
 285         self.delta = (dx, dy)
 286 
 287 
 288     def OnLeftUp(self, event):
 289         """
 290         ...
 291         """
 292 
 293         if self.HasCapture():
 294             self.ReleaseMouse()
 295 
 296 
 297     def OnMouseMove(self, event):
 298         """
 299         ...
 300         """
 301 
 302         if event.Dragging() and event.LeftIsDown():
 303             x, y = self.ClientToScreen(event.GetPosition())
 304             fp = (x - self.delta[0], y - self.delta[1])
 305             self.SetPosition(fp)
 306             self.widgetsframe.SetPosition(fp)
 307 
 308 
 309     def Draw(self):
 310         """
 311         ...
 312         """
 313 
 314         # Return client size.
 315         width, height = self.GetClientSize()
 316 
 317         # Return main image size.
 318         bw, bh = self.bitmap.GetWidth(), self.bitmap.GetHeight()
 319 
 320         #------------
 321 
 322         dc = wx.MemoryDC()
 323 
 324         #------------
 325 
 326         fontSize = self.GetFont().GetPointSize()
 327 
 328         # wx.Font(pointSize, family, style, weight, underline, faceName)
 329         if wx.Platform == "__WXMSW__":
 330             self.normalBoldFont = wx.Font(fontSize-1,
 331                                           wx.DEFAULT, wx.NORMAL,
 332                                           wx.NORMAL, False, "")
 333             self.normalFont = wx.Font(fontSize,
 334                                       wx.DEFAULT, wx.NORMAL,
 335                                       wx.NORMAL, False, "")
 336 
 337         dc.SetFont(self.normalFont)
 338         dc.SetFont(self.normalBoldFont)
 339 
 340         #------------
 341 
 342         bmp = wx.Bitmap.FromRGBA(width, height, red=0, green=0, blue=0, alpha=0)
 343         dc.SelectObject(bmp)
 344 
 345         #------------
 346 
 347         gc = wx.GraphicsContext.Create(dc)
 348         gcdc = wx.GCDC(gc)
 349 
 350         # Draw a bitmap with an alpha channel
 351         # on top of the last group.
 352         # image, x, y, transparence
 353         gcdc.DrawBitmap(self.bitmap, -1, -1, useMask=False)
 354 
 355         # Draw text.
 356         gcdc.SetTextForeground(wx.Colour(0, 0, 0, 100))  # black
 357         gcdc.SetTextBackground(wx.TransparentColour)
 358         gcdc.SetFont(self.normalBoldFont)
 359         firstTxt = "wxPython is a Python extension module that\n"\
 360                    " encapsulates the wxWindows GUI classes."
 361         tw, th = gcdc.GetTextExtent(firstTxt)
 362         gcdc.DrawText(firstTxt, (int((bw-tw)/2-25), int(240)))
 363 
 364         gcdc.SetTextForeground(wx.Colour(250, 250, 250, 255))  # white
 365         gcdc.SetTextBackground(wx.TransparentColour)
 366         gcdc.SetFont(self.normalFont)
 367         secondTxt = " wxPython is brought to you by Robin Dunn and\n"\
 368                    "Total Control Software, Copyright (c) 1997-2020."
 369         tw, th = gcdc.GetTextExtent(secondTxt)
 370         gcdc.DrawText(secondTxt, (int((bw-tw)/2-25), int(275)))
 371 
 372         #------------
 373 
 374         gcdc.Destroy()
 375         del gcdc
 376 
 377         dc.Destroy()
 378         del dc
 379 
 380         #------------
 381 
 382         draw_alpha(self, bmp)
 383 
 384 
 385     def OnTimer(self, event):
 386         """
 387         ...
 388         """
 389 
 390         dc = wx.BufferedDC(wx.ClientDC(self))
 391         dc.Clear()
 392 
 393         self.Draw()
 394 
 395 
 396     def OnPaint(self, event):
 397         """
 398         ...
 399         """
 400 
 401         dc = wx.BufferedPaintDC(self)
 402         dc.Clear()
 403 
 404         self.Draw()
 405 
 406 
 407     def OnCharEvents(self, event):
 408         """
 409         Handles the wx.EVT_CHAR for Splash.
 410         This reproduces the behavior of wx.SplashScreen.
 411         """
 412 
 413         self.OnClose(event)
 414 
 415 
 416     def TimeOut(self, event):
 417         """
 418         ...
 419         """
 420 
 421         self.Close(True)
 422 
 423 
 424     def OnClose(self, event):
 425         """
 426         Handles the wx.EVT_CLOSE event for SplashScreen.
 427         """
 428 
 429         self.widgetsframe.Close()
 430 
 431         #------------
 432 
 433         # Make sure the default handler runs
 434         # too so this window gets destroyed.
 435         # Tell the event system to continue
 436         # looking for an event handler, so the
 437         # default handler will get called.
 438         event.Skip()
 439         self.Hide()
 440 
 441         #------------
 442 
 443         # If the timer is still running then go
 444         # ahead and show the main frame now.
 445         if self.fc.IsRunning():
 446             # Stop the wx.CallLater timer.
 447             # Stop the splash screen timer
 448             # and close it.
 449             self.fc.Stop()
 450             self.ShowMainFrame()
 451 
 452 
 453     def ShowMainFrame(self):
 454         """
 455         ...
 456         """
 457 
 458         print("\n... Close the splash screen")
 459         print("\n... Create and display the main frame")
 460 
 461         #------------
 462 
 463         wx.CallAfter(wx.EndBusyCursor)
 464 
 465         #------------
 466 
 467         if self.fc.IsRunning():
 468             # Stop the splash screen
 469             # timer and close it.
 470             self.Raise()
 471 
 472         #------------
 473 
 474         # Create an instance of the MyFrame class.
 475         frame = MyFrame()
 476 
 477 
 478     def OnCloseWindow(self, event):
 479         """
 480         ...
 481         """
 482 
 483         self.timer.Stop()
 484         self.Destroy()
 485 
 486 #-------------------------------------------------------------------------------
 487 
 488 class MyControls(wx.Frame):
 489     """
 490     ...
 491     """
 492     style = (wx.FRAME_SHAPED | wx.NO_BORDER |
 493              wx.FRAME_NO_TASKBAR | wx.FRAME_FLOAT_ON_PARENT)
 494     def __init__(self, parent, id=wx.ID_ANY, title=wx.EmptyString,
 495                  pos=wx.DefaultPosition, size=wx.DefaultSize,
 496                  style=style,
 497                  name='frame'):
 498         wx.Frame.__init__(self, parent, id, title, pos, size, style, name)
 499 
 500         #------------
 501 
 502         # Attributes.
 503         self.SetTransparent(200)
 504 
 505         #------------
 506 
 507         # Return bitmaps folder.
 508         self.bitmaps_dir = wx.GetApp().GetBitmapsDir()
 509         # Return icons folder.
 510         self.icons_dir = wx.GetApp().GetIconsDir()
 511 
 512         #------------
 513 
 514         # Simplified init method.
 515         self.SetProperties()
 516         self.CreateCtrls()
 517         self.BindEvents()
 518 
 519     #---------------------------------------------------------------------------
 520 
 521     def SetProperties(self):
 522         """
 523         ...
 524         """
 525 
 526         self.SetBackgroundStyle(wx.BG_STYLE_CUSTOM)
 527 
 528 
 529     def CreateCtrls(self):
 530         """
 531         ...
 532         """
 533 
 534         # Gauge.
 535         self.gauge = wx.Gauge(self,
 536                               id=-1,
 537                               #range=50,
 538                               pos=(25, 312),
 539                               size=(275, 15))
 540         self.gauge.Pulse()
 541 
 542         #------------
 543 
 544         if wx.Platform == "__WXGTK__":
 545             # wxGTK requires that the window be created before you can
 546             # set its shape, so delay the call to SetWindowShape until
 547             # this event.
 548             self.Bind(wx.EVT_WINDOW_CREATE, self.SetWindowShape)
 549         else:
 550             # On wxMSW and wxMac the window has
 551             # already been created, so go for it.
 552             self.SetWindowShape()
 553 
 554 
 555     def BindEvents(self):
 556         """
 557         Bind some events to an events handler.
 558         """
 559 
 560         self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
 561         self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
 562 
 563 
 564     def TimerHandler(self, event):
 565         """
 566         ...
 567         """
 568 
 569 
 570         #self.gauge.SetValue(self.count)
 571         # or
 572         self.gauge.Pulse()
 573 
 574 
 575     def SetWindowShape(self, *event):
 576         """
 577         ...
 578         """
 579 
 580         # Use the widget's rect's to determine the region.
 581         wxRegion = wx.Region
 582         self.region = wxRegion()
 583         widgets = [child for child in self.GetChildren()]
 584         regions = [wxRegion(widget.GetRect()) for widget in widgets]
 585         Union = self.region.Union
 586         [Union(reg) for reg in regions]
 587         self.hasShape = self.SetShape(self.region)
 588 
 589 
 590     def OnLeftDown(self, event):
 591         """
 592         ...
 593         """
 594 
 595         if self.HasCapture():
 596             self.ReleaseMouse()
 597 
 598         self.CaptureMouse()
 599         x, y = self.ClientToScreen(event.GetPosition())
 600         originx, originy = self.GetPosition()
 601         dx = x - originx
 602         dy = y - originy
 603         self.delta = (dx, dy)
 604 
 605 
 606     def OnLeftUp(self, event):
 607         """
 608         ...
 609         """
 610 
 611         if self.HasCapture():
 612             self.ReleaseMouse()
 613 
 614 #-------------------------------------------------------------------------------
 615 
 616 class MyApp(wx.App):
 617     """
 618     ...
 619     """
 620     def OnInit(self):
 621 
 622         #------------
 623 
 624         self.locale = wx.Locale(wx.LANGUAGE_ENGLISH)
 625 
 626         #------------
 627 
 628         self.SetAppName("Main frame")
 629 
 630         #------------
 631 
 632         self.installDir = os.path.split(os.path.abspath(sys.argv[0]))[0]
 633 
 634         #------------
 635 
 636         frame = MySplash(None)
 637         self.SetTopWindow(frame)
 638         frame.Show(True)
 639 
 640         return True
 641 
 642     #-----------------------------------------------------------------------
 643 
 644     def GetInstallDir(self):
 645         """
 646         Returns the installation directory for my application.
 647         """
 648 
 649         return self.installDir
 650 
 651 
 652     def GetIconsDir(self):
 653         """
 654         Returns the icons directory for my application.
 655         """
 656 
 657         icons_dir = os.path.join(self.installDir, "icons")
 658         return icons_dir
 659 
 660 
 661     def GetBitmapsDir(self):
 662         """
 663         Returns the bitmaps directory for my application.
 664         """
 665 
 666         bitmaps_dir = os.path.join(self.installDir, "bitmaps")
 667         return bitmaps_dir
 668 
 669 #---------------------------------------------------------------------------
 670 
 671 def main():
 672     app = MyApp(False)
 673     app.MainLoop()
 674 
 675 #---------------------------------------------------------------------------
 676 
 677 if __name__ == "__main__" :
 678     main()


Download source

source.zip


Additional Information

Link :

https://www.blog.pythonlibrary.org/2018/09/

https://stackoverflow.com/questions/12181185/wxpython-and-splash-screen

https://stackoverflow.com/questions/9435498/wxpython-splash-screen-trouble

http://wxpython-users.1045709.n5.nabble.com/Splash-Screen-td2368727.html

https://github.com/ponty/pyscreenshot

https://stackoverflow.com/questions/28742324/wxpython-screenshot-windows

https://stackoverflow.com/questions/8644908/take-screenshot-in-python-cross-platform

- - - - -

https://wiki.wxpython.org/TitleIndex

https://docs.wxpython.org/


Thanks to

Cody Precord, Chris Barker, Robin Dunn, Mike Driscoll, Andrea Gavana, Vegaseat (DaniWeb), Cliff Wells, Harald Massa, Jeff Grimmett, Kevin Schlosser {OK} and Metallicow {OK} , the wxPython community...


About this page

Date (d/m/y) Person (bot) Comments :

27/04/18 - Ecco (Created page for wxPython Phoenix).


Comments

- blah, blah, blah....

How to create a customized splash screen (Phoenix) (last edited 2021-01-02 17:04:18 by Ecco)

NOTE: To edit pages in this wiki you must be a member of the TrustedEditorsGroup.