def OnPaint(self, event): """ Handles the ``wx.EVT_PAINT`` event for :class:`RibbonToolBar`. :param `event`: a :class:`PaintEvent` event to be processed. """ dc = wx.AutoBufferedPaintDC(self) if self._art == None: return self._art.DrawToolBarBackground(dc, self, wx.Rect(0, 0, *self.GetSize())) for group in self._groups: tool_count = len(group.tools) if tool_count != 0: self._art.DrawToolGroupBackground(dc, self, wx.RectPS(group.position, group.size)) for tool in group.tools: rect = wx.RectPS(group.position + tool.position, tool.size) if tool.state & RIBBON_TOOLBAR_TOOL_DISABLED: self._art.DrawTool(dc, self, rect, tool.bitmap_disabled, tool.kind, tool.state) else: self._art.DrawTool(dc, self, rect, tool.bitmap, tool.kind, tool.state)
def test_Rect(): r = wx.Rect() attrs = 'X Y x y Width Height width height'.split() assert all(0 == val for val in (getattr(r, a) for a in attrs)) r2 = wx.Rect(1, 2, 3, 4) assert r2.x == r2.GetX() == 1 assert r2.y == r2.GetY() == 2 assert r2.width == r2.GetWidth() == r2.Width == 3 assert r2.height == r2.GetHeight() == r2.Height == 4 assert r2[:2] == r2.Position assert r2.TopLeft == r2.GetTopLeft() == wx.Point(1, 2) assert r2.TopRight == r2.GetTopRight() == wx.Point(3, 2) assert r2.BottomLeft == r2.GetBottomLeft() == wx.Point(1, 5) assert r2.BottomRight == r2.GetBottomRight() == wx.Point(3, 5) assert r2 == (1, 2, 3, 4) assert r2 != (4, 3, 2, 1) r3 = wx.RectPS(wx.Point(20, 30), wx.Size(40, 50)) r4 = wx.RectPS((20, 30), (40, 50)) assert r3 == r4 r5 = r3.Inflate(10, 10) r6 = wx.Rect(40, 40, 20, 20) r6.Offset((20, -10)) assert r6 == (60, 30, 20, 20)
def paint_bitmap(self, dc, pickerPos=None): ''' If dc is None, returns a PIL image ''' bw, bh = self.bitmap.Width, self.bitmap.Height # get the 0,0 point of the image if centered imagecenter = Point(self.Rect.Width / 2, self.Rect.Height / 2) - Point( bw / 2, bh / 2) # adjust away from center xy = imagecenter + (self.adjustment[0] * bw, self.adjustment[1] * bh) # adjust the offset by how far into the picture the selection is # if pickerPos: # xy[0] += pickerPos[0]; xy[1] += pickerPos[1] if dc is not None: # dc.SetBrush(wx.TRANSPARENT_BRUSH) #@UndefinedVariable # dc.SetPen(wx.RED_PEN) #@UndefinedVariable dc.DrawBitmap(self.bitmap, *xy) # dc.DrawRectangleRect(cropRect) else: pickWidth = int(self.picksize[0]) pickHeight = int(self.picksize[1]) pickRect = wx.RectPS( pickerPos or ((self.Rect.width // 2 - self.picksize[0] // 2), (self.Rect.height // 2 - self.picksize[1] // 2)), (pickWidth, pickHeight)) pickRect.Position -= xy imageRect = wx.RectPS((0, 0), (bw, bh)) cropRect = imageRect.Intersect(pickRect) crop_box = (cropRect.left, cropRect.top, cropRect.right, cropRect.bottom) croppedImage = self.bitmap.PIL.crop(crop_box) # croppedImage.Show("croppedImage") offsetX = max(-(pickRect.x - cropRect.x), 0) offsetY = max(-(pickRect.y - cropRect.y), 0) if (offsetX or offsetY): paddedImage = Image.new('RGBA', (pickRect.width, pickRect.height), (0, 0, 0, 0)) paddedImage.paste(croppedImage, (offsetX, offsetY)) return paddedImage return croppedImage
def on_capture(self): self.slider.Enable(True) dragger = self.dragger self.Freeze() try: if config.platform == 'win': try: from cgui import getScreenBitmap except ImportError: print_exc() return bitmap = getScreenBitmap( wx.RectPS(dragger.ScreenRect.Position, dragger.ClientSize)) else: screendc = wx.ScreenDC() bitmap = screendc.GetAsBitmap() if bitmap is not None: self.set_image(wx.ImageFromBitmap(bitmap)) s = self.slider s.Value = (s.Max - s.Min) / 2 finally: wx.CallAfter(self.ThawLater)
def DrawHorzBand(self, dc, rect): """ Draw Vertical bands - No falloff effect for vertical bands. """ horzBands = (self._ledBands > 1 and [self._ledBands] or [self._maxValue * BAND_PERCENT / 100])[0] minHorzLimit = self._minValue * horzBands / self._maxValue medHorzLimit = self._medValue * horzBands / self._maxValue maxHorzLimit = horzBands size = wx.Size(rect.width / horzBands, rect.height / self._numBands) rectBand = wx.RectPS(rect.GetTopLeft(), size) # Draw band from top rectBand.OffsetXY(0, rect.height - size.y * self._numBands) xDecal = (self._ledBands > 1 and [1] or [0])[0] yDecal = (self._numBands > 1 and [1] or [0])[0] for vert in xrange(self._numBands): self._value = self._meterData[vert]._value horzLimit = self._value * horzBands / self._maxValue for horz in xrange(horzBands): rectBand.Deflate(0, yDecal) # Find color based on range value colorRect = self._clrBackground if self._showGrid: colorRect = DarkenColor(self._clrBackground, GRID_INCREASEBY) if self._showGrid and (horz == minHorzLimit or horz == (horzBands - 1)): points = [wx.Point() for i in xrange(2)] points[0].x = rectBand.GetTopLeft().x + ( rectBand.width >> 1) points[0].y = rectBand.GetTopLeft().y - yDecal points[1].x = points[0].x points[1].y = rectBand.GetBottomRight().y + yDecal dc.DrawLinePoint(points[0], points[1]) if horz < horzLimit: if InRange(horz, 0, minHorzLimit - 1): colorRect = self._clrNormal elif InRange(horz, minHorzLimit, medHorzLimit - 1): colorRect = self._clrMedium elif InRange(horz, medHorzLimit, maxHorzLimit): colorRect = self._clrHigh dc.SetBrush(wx.Brush(colorRect)) dc.DrawRectangleRect(rectBand) rectBand.Inflate(0, yDecal) rectBand.OffsetXY(size.x, 0) # Move to Next Vertical band rectBand.OffsetXY(-size.x * horzBands, size.y)
def ShowExpanded(self): """ Show the panel externally expanded. When a panel is minimised, it can be shown full-size in a pop-out window, which is refered to as being (externally) expanded. :returns: ``True`` if the panel was expanded, ``False`` if it was not (possibly due to it not being minimised, or already being expanded). :note: When a panel is expanded, there exist two panels - the original panel (which is refered to as the dummy panel) and the expanded panel. The original is termed a dummy as it sits in the ribbon bar doing nothing, while the expanded panel holds the panel children. :see: :meth:`~RibbonPanel.HideExpanded`, :meth:`~RibbonPanel.GetExpandedPanel` """ if not self.IsMinimised(): return False if self._expanded_dummy != None or self._expanded_panel != None: return False size = self.GetBestSize() pos = self.GetExpandedPosition(wx.RectPS(self.GetScreenPosition(), self.GetSize()), size, self._preferred_expand_direction).GetTopLeft() # Need a top-level frame to contain the expanded panel container = wx.Frame(None, wx.ID_ANY, self.GetLabel(), pos, size, wx.FRAME_NO_TASKBAR | wx.BORDER_NONE) self._expanded_panel = RibbonPanel(container, wx.ID_ANY, self.GetLabel(), self._minimised_icon, wx.Point(0, 0), size, self._flags) self._expanded_panel.SetArtProvider(self._art) self._expanded_panel._expanded_dummy = self # Move all children to the new panel. # Conceptually it might be simpler to reparent self entire panel to the # container and create a new panel to sit in its place while expanded. # This approach has a problem though - when the panel is reinserted into # its original parent, it'll be at a different position in the child list # and thus assume a new position. # NB: Children iterators not used as behaviour is not well defined # when iterating over a container which is being emptied for child in self.GetChildren(): child.Reparent(self._expanded_panel) child.Show() # Move sizer to new panel if self.GetSizer(): sizer = self.GetSizer() self.SetSizer(None, False) self._expanded_panel.SetSizer(sizer) self._expanded_panel.Realize() self.Refresh() container.Show() self._expanded_panel.SetFocus() return True
def OnPaint(self, event): """ Painting when skined, otherwise it lets the system handle it """ if self.native: event.Skip() return dc = wx.AutoBufferedPaintDC(self) rect = wx.RectS(self.Size) #Background drawing if self.bg: self.bg.Draw(dc, rect) rect.width = int(float(self.value) / float(self.range) * self.Size.x) #forground drawing if self.repeat: curser = wx.Point(self.padding, 0) while curser.x < self.fill: self.fg.Draw(dc, wx.RectPS(curser, (self.fg.width, rect.height))) curser.x += self.fg.width + self.padding else: self.fg.Draw(dc, wx.RectS((self.fill, rect.height)))
def OnMouseMotion(self, event): """ Ensures mouse in and mouse out capture events occure, also handels hover for the button and link """ #If the left mouse button is not down, make sure the panel gets/losses # capture accordingly if not event.LeftIsDown(): mouseisin = wx.FindWindowAtPointer() is self if mouseisin and not self.HasCapture(): self.OnMouseIn(event) elif not mouseisin and self.HasCapture(): self.OnMouseOut(event) #Handle button statethings on mouse over if not self.Parent.ShowAll and self.HasCapture() and self.buttonshown: bstate = self.buttonstate bisdown = self.buttonisdown mouseinb = wx.RectPS(self.riconpos, (16, 16)).Contains(event.Position) if bstate == 0 and mouseinb: self.buttonstate = 2 if bisdown else 1 self.Refresh() elif bstate in (1, 2) and not mouseinb: self.buttonstate = 0 self.Refresh() #handle link mouseover mouseinl = self.linkhovered = self.linkrect.Contains(event.Position) self.SetCursor( wx.StockCursor(wx.CURSOR_HAND if mouseinl else wx.CURSOR_DEFAULT))
def OnSize(self, event): if self.aui.GetPane("filebrowser").IsShown( ): # Adjust overflow state of file browser toolbar if visible wx.CallAfter(self.filebrowser.GetSizer().Layout) if self.HasCapture(): self.rect = wx.RectPS(self.GetPosition(), self.GetSize()) event.Skip()
def OnPaint(self, event): dc = wx.AutoBufferedPaintDC(self) if self._art == None: return self._art.DrawToolBarBackground(dc, self, wx.Rect(0, 0, *self.GetSize())) for group in self._groups: tool_count = len(group.tools) if tool_count != 0: self._art.DrawToolGroupBackground(dc, self, wx.RectPS(group.position, group.size)) for tool in group.tools: rect = wx.RectPS(group.position + tool.position, tool.size) self._art.DrawTool(dc, self, rect, tool.bitmap, tool.kind, tool.state)
def OnSize(self, evt): if not self._managedChild: return sz = self.GetSize() self._managedChild.SetRect( wx.RectPS((0, 0), sz - (RW_THICKNESS, RW_THICKNESS))) r = wx.Rect(sz.width - RW_LENGTH, sz.height - RW_LENGTH, RW_LENGTH, RW_LENGTH) r.Inflate(2, 2) self.RefreshRect(r)
def OnSize(self, evt): if not self._managedChild: return sz = self.GetSize() cr = wx.RectPS((0, 0), sz - (RW_THICKNESS, RW_THICKNESS)) self._managedChild.SetRect(cr) r1 = wx.Rect(0, cr.height, sz.width, RW_THICKNESS) r2 = wx.Rect(cr.width, 0, RW_THICKNESS, sz.height) self.RefreshRect(r1) self.RefreshRect(r2)
def OnPaint(self, event): dc = wx.AutoBufferedPaintDC(self) rect = wx.RectPS(wx.Point(0, 0), self.GetSize()) if self.content: skin = self.content.skinCML skin["frame"].Draw(dc, rect) else: dc.SetBrush(wx.BLACK_BRUSH) #@UndefinedVariable dc.SetPen(wx.TRANSPARENT_PEN) #@UndefinedVariable dc.DrawRectangleRect(rect)
def SetPopupRect(self, popup, rect, quick=False): t = int(self.slidetime) if t == 0: quick = True oldrect = popup.Rect if quick: popup.SetRect(rect) else: if oldrect.Size != rect.Size: popup.SetRect(wx.RectPS(oldrect.Position, rect.Size)) move_smoothly(popup, rect.Position, time=t)
def SetEnabled(self, val): """ Enable or disable docking, called by buddy list when the pref changes. """ if not isinstance(val, bool): raise TypeError('Enabled must be a boolean') self._enabled = val #turn docking off docking if not val and self.docked: self.Undock() p = self.dockedRect[:2] self.docking = self.docked = self.autohidden = False wx.CallLater(50, self.SetRectSimple, wx.Rect(p[0],p[1], *wx.Size(*self.oldSize))) self.UpdateTaskbar() #turn docking on elif val and not self.docked and self.win.IsShownOnScreen(): self.docking = False #emulate a motion event to initiate docking if the buddylist is in position if self.OnMoving(): #emulate a finished moving event to finish docking procedure self.OnExitSizeMove() #if autohide preference is set, start timer to autohide the buddylist if self.AutoHide: self.timer.Start(AUTOHIDE_TIMER_MS) self.motiontrigger = False self.win.SetRect(self.dockedRect) elif self.wasDocked: SetToolStyle(self.win,val) self.bypassMoveEvents = True if val: self.win.Rect = self.dockedRect else: self.win.Rect = wx.RectPS(self.dockedRect.Position, self.oldSize) self.bypassMoveEvents = False self.UpdateTaskbar() if not val: self.oldSize = None
def OnPaint(self, e): e.Skip() icon, dc = self.icon, wx.PaintDC(self) if icon is not None: # draw a centered buddy icon w, h = self.Size assert isinstance(icon, wx.Bitmap), str(type(icon)) icopos = (w / 2 - icon.Width / 2, h / 2 - icon.Height / 2) dc.DrawBitmap(icon, *icopos) dc.Brush = wx.TRANSPARENT_BRUSH dc.Pen = wx.Pen(wx.Color(213, 213, 213)) dc.DrawRectangleRect(wx.RectPS(icopos, (icon.Width, icon.Height)))
def Display(self,rect): 'Set Position and popup' pos = rect.BottomLeft newrect = wx.RectPS(pos, self.Size) screenrect = Monitor.GetFromRect(newrect).ClientArea if newrect.bottom > screenrect.bottom: pos.y -= rect.height + self.Size.height if newrect.right > screenrect.right: pos.x += rect.width - self.Size.width self.SetPosition(pos) # Position property doesn't work for PopTransWin self.Popup()
def __DrawSection(self, dc): if not self._imgProxy.IsOk(): return sectRect = self.__SectRectToClientRect() dc.SetBrush(wx.TRANSPARENT_BRUSH) iRect = wx.RectPS(sectRect.GetPosition(), sectRect.GetSize()) dc.SetPen(wx.WHITE_PEN) iRect.Inflate(1, 1) dc.DrawRectangleRect(iRect) # draw background color = wx.Colour(0, 0, 0, 153) dc.SetBrush(wx.Brush(color)) dc.SetPen(wx.TRANSPARENT_PEN) # wx.Pen(color)) # left left, top = self.__GetBmpTopLeft() bmpWidth, bmpHeight = self._imgProxy.GetCurrentSize() dc.DrawRectangle(left, top, iRect.x - left, bmpHeight) lWidth = left + bmpWidth - iRect.GetWidth() - iRect.x left = iRect.x + iRect.GetWidth() dc.DrawRectangle(left, top, lWidth, bmpHeight) dc.DrawRectangle(iRect.x, top, iRect.GetWidth(), iRect.y - top) dc.DrawRectangle(iRect.x, iRect.y + iRect.GetHeight(), iRect.GetWidth(), top + bmpHeight - iRect.GetHeight() - iRect.y) now = time.time() alpha = 255 if now - self._lastRectUpdate > self.INFO_TIME_OUT / 2: alpha = (1 - ((now - self._lastRectUpdate) - (self.INFO_TIME_OUT / 2)) / (self.INFO_TIME_OUT / 2)) * 255 alpha = int(round(alpha)) if alpha < 0: alpha = 0 dc.SetTextForeground(wx.Colour(255, 255, 255, alpha)) font = wx.SystemSettings.GetFont(wx.SYS_SYSTEM_FIXED_FONT) font.SetPointSize(16) font.SetWeight(wx.BOLD) dc.SetFont(font) dc.SetPen(wx.WHITE_PEN) dc.SetBrush(wx.TRANSPARENT_BRUSH) dc.DrawRectangleRect(sectRect) dc.DrawLabel("%d, %d - %d x %d" % tuple(self._sectRect), sectRect, wx.ALIGN_CENTER_HORIZONTAL | wx.ALIGN_CENTER_VERTICAL)
def ShowExpanded(self): if not self.IsMinimised(): return False if self._expanded_dummy != None or self._expanded_panel != None: return False size = self.GetBestSize() pos = self.GetExpandedPosition( wx.RectPS(self.GetScreenPosition(), self.GetSize()), size, self._preferred_expand_direction).GetTopLeft() # Need a top-level frame to contain the expanded panel container = wx.Frame(None, wx.ID_ANY, self.GetLabel(), pos, size, wx.FRAME_NO_TASKBAR | wx.BORDER_NONE) self._expanded_panel = RibbonPanel(container, wx.ID_ANY, self.GetLabel(), self._minimised_icon, wx.Point(0, 0), size, self._flags) self._expanded_panel.SetArtProvider(self._art) self._expanded_panel._expanded_dummy = self # Move all children to the new panel. # Conceptually it might be simpler to reparent self entire panel to the # container and create a new panel to sit in its place while expanded. # This approach has a problem though - when the panel is reinserted into # its original parent, it'll be at a different position in the child list # and thus assume a new position. # NB: Children iterators not used as behaviour is not well defined # when iterating over a container which is being emptied for child in self.GetChildren(): child.Reparent(self._expanded_panel) child.Show() # TODO: Move sizer to new panel self._expanded_panel.Realize() self.Refresh() container.Show() self._expanded_panel.SetFocus() return True
def OnPaint(self, event): dc = wx.AutoBufferedPaintDC(self) self._art.DrawButtonBarBackground(dc, self, wx.Rect(0, 0, *self.GetSize())) layout = self._layouts[self._current_layout] for button in layout.buttons: base = button.base bitmap = base.bitmap_large bitmap_small = base.bitmap_small if base.state & RIBBON_BUTTONBAR_BUTTON_DISABLED: bitmap = base.bitmap_large_disabled bitmap_small = base.bitmap_small_disabled rect = wx.RectPS(button.position + self._layout_offset, base.sizes[button.size].size) self._art.DrawButtonBarButton(dc, self, rect, base.kind, base.state | button.size, base.label, bitmap, bitmap_small)
def getRect(self, obj): rects = [wx.RectPS(obj.GetPosition(), obj.GetSize())] for sizerItem in obj.GetChildren(): rect = sizerItem.GetRect() rects.append(rect) # Add lines to show borders flag = sizerItem.GetFlag() border = sizerItem.GetBorder() if border == 0: continue x = (rect.GetLeft() + rect.GetRight()) / 2 if flag & wx.TOP: rects.append(wx.Rect(x, rect.GetTop() - border, 0, border)) if flag & wx.BOTTOM: rects.append(wx.Rect(x, rect.GetBottom() + 1, 0, border)) y = (rect.GetTop() + rect.GetBottom()) / 2 if flag & wx.LEFT: rects.append(wx.Rect(rect.GetLeft() - border, y, border, 0)) if flag & wx.RIGHT: rects.append(wx.Rect(rect.GetRight() + 1, y, border, 0)) return rects
def PopUp(self, rect): self.rect = rect monarea = Monitor.GetFromRect(rect).ClientArea below = wx.Point(rect.BottomLeft) above = wx.Point(rect.TopLeft - wx.Point(0, self.frame.Size.height)) if getattr(self, 'valign', 'bottom') == 'top': prefer, second = above, below else: prefer, second = below, above if monarea.ContainsRect(wx.RectPS(prefer, self.frame.Size)): chose = prefer else: chose = second self.frame.SetPosition(chose) if not hasattr(self, 'valign'): self.valign = 'bottom' if chose == below else 'top' return self.frame.ShowNoActivate(True)
def DrawVertBand(self, dc, rect): """ Draws vertical bands. :param `dc`: an instance of :class:`DC`; :param `rect`: the vertical bands client rectangle. """ vertBands = (self._ledBands > 1 and [self._ledBands] or [self._maxValue * BAND_PERCENT / 100])[0] minVertLimit = self._minValue * vertBands / self._maxValue medVertLimit = self._medValue * vertBands / self._maxValue maxVertLimit = vertBands size = wx.Size(rect.width / self._numBands, rect.height / vertBands) rectBand = wx.RectPS(rect.GetTopLeft(), size) # Draw band from bottom rectBand.OffsetXY(0, rect.bottom - size.y) xDecal = (self._numBands > 1 and [1] or [0])[0] yDecal = (self._ledBands > 1 and [1] or [0])[0] for horz in xrange(self._numBands): self._value = self._meterData[horz]._value vertLimit = self._value * vertBands / self._maxValue rectPrev = wx.Rect(*rectBand) for vert in xrange(vertBands): rectBand.Deflate(xDecal, 0) # Find colour based on range value colourRect = self._clrBackground if self._showGrid: colourRect = DarkenColour(self._clrBackground, GRID_INCREASEBY) # Draw grid line (level) bar if self._showGrid and (vert == minVertLimit or vert == (vertBands - 1)): points = [wx.Point() for i in xrange(2)] points[0].x = rectBand.GetTopLeft().x - xDecal points[0].y = rectBand.GetTopLeft().y + ( rectBand.height >> 1) points[1].x = rectBand.GetBottomRight().x + xDecal points[1].y = points[0].y dc.DrawLinePoint(points[0], points[1]) if vert < vertLimit: if InRange(vert, 0, minVertLimit - 1): colourRect = self._clrNormal elif InRange(vert, minVertLimit, medVertLimit - 1): colourRect = self._clrMedium elif InRange(vert, medVertLimit, maxVertLimit): colourRect = self._clrHigh dc.SetBrush(wx.Brush(colourRect)) dc.DrawRectangleRect(rectBand) rectBand.Inflate(xDecal, 0) rectBand.OffsetXY(0, -size.y) # Draw falloff effect if self._showFalloff: oldPen = dc.GetPen() pen = wx.Pen(DarkenColour(self._clrBackground, FALL_INCREASEBY)) maxHeight = size.y * vertBands points = [wx.Point() for i in xrange(2)] points[0].x = rectPrev.GetTopLeft().x + xDecal points[0].y = rectPrev.GetBottomRight().y - self._meterData[ horz]._falloff * maxHeight / self._maxValue points[1].x = rectPrev.GetBottomRight().x - xDecal points[1].y = points[0].y dc.SetPen(pen) dc.DrawLinePoint(points[0], points[1]) dc.SetPen(oldPen) # Move to Next Horizontal band rectBand.OffsetXY(size.x, size.y * vertBands)
def SetPosition(self, x, y, size): self._position = wx.RectPS(wx.Point(x, y), size)
def Layout(self): if self._art == None: return False dc = wx.MemoryDC() origin = wx.Point() client_size, origin, self._scroll_up_button_rect, self._scroll_down_button_rect, self._extension_button_rect = \ self._art.GetGalleryClientSize(dc, self, wx.Size(*self.GetSize())) self._client_rect = wx.RectPS(origin, client_size) x_cursor = y_cursor = 0 art_flags = self._art.GetFlags() for indx, item in enumerate(self._items): item.SetIsVisible(True) if art_flags & RIBBON_BAR_FLOW_VERTICAL: if y_cursor + self._bitmap_padded_size.y > client_size.GetHeight( ): if y_cursor == 0: break y_cursor = 0 x_cursor += self._bitmap_padded_size.x item.SetPosition(origin.x + x_cursor, origin.y + y_cursor, self._bitmap_padded_size) y_cursor += self._bitmap_padded_size.y else: if x_cursor + self._bitmap_padded_size.x > client_size.GetWidth( ): if x_cursor == 0: break x_cursor = 0 y_cursor += self._bitmap_padded_size.y item.SetPosition(origin.x + x_cursor, origin.y + y_cursor, self._bitmap_padded_size) x_cursor += self._bitmap_padded_size.x for item in self._items[indx:]: item.SetIsVisible(False) if art_flags & RIBBON_BAR_FLOW_VERTICAL: self._scroll_limit = x_cursor else: self._scroll_limit = y_cursor if self._scroll_amount >= self._scroll_limit: self._scroll_amount = self._scroll_limit self._down_button_state = RIBBON_GALLERY_BUTTON_DISABLED elif self._down_button_state == RIBBON_GALLERY_BUTTON_DISABLED: self._down_button_state = RIBBON_GALLERY_BUTTON_NORMAL if self._scroll_amount <= 0: self._scroll_amount = 0 self._up_button_state = RIBBON_GALLERY_BUTTON_DISABLED elif self._up_button_state == RIBBON_GALLERY_BUTTON_DISABLED: self._up_button_state = RIBBON_GALLERY_BUTTON_NORMAL return True
def GetExpandedPosition(self, panel, expanded_size, direction): # Strategy: # 1) Determine primary position based on requested direction # 2) Move the position so that it sits entirely within a display # (for single monitor systems, this moves it into the display region, # but for multiple monitors, it does so without splitting it over # more than one display) # 2.1) Move in the primary axis # 2.2) Move in the secondary axis primary_x = False secondary_x = secondary_y = 0 pos = wx.Point() if direction == wx.NORTH: pos.x = panel.GetX() + (panel.GetWidth() - expanded_size.GetWidth()) / 2 pos.y = panel.GetY() - expanded_size.GetHeight() primary_x = True secondary_y = 1 elif direction == wx.EAST: pos.x = panel.GetRight() pos.y = panel.GetY() + (panel.GetHeight() - expanded_size.GetHeight()) / 2 secondary_x = -1 elif direction == wx.SOUTH: pos.x = panel.GetX() + (panel.GetWidth() - expanded_size.GetWidth()) / 2 pos.y = panel.GetBottom() primary_x = True secondary_y = -1 else: pos.x = panel.GetX() - expanded_size.GetWidth() pos.y = panel.GetY() + (panel.GetHeight() - expanded_size.GetHeight()) / 2 secondary_x = 1 expanded = wx.RectPS(pos, expanded_size) best = wx.Rect(*expanded) best_distance = 10000 display_n = wx.Display.GetCount() for display_i in xrange(display_n): display = wx.Display(display_i).GetGeometry() if display.ContainsRect(expanded): return expanded elif display.Intersects(expanded): new_rect = wx.Rect(*expanded) distance = 0 if primary_x: if expanded.GetRight() > display.GetRight(): distance = expanded.GetRight() - display.GetRight() new_rect.x -= distance elif expanded.GetLeft() < display.GetLeft(): distance = display.GetLeft() - expanded.GetLeft() new_rect.x += distance else: if expanded.GetBottom() > display.GetBottom(): distance = expanded.GetBottom() - display.GetBottom() new_rect.y -= distance elif expanded.GetTop() < display.GetTop(): distance = display.GetTop() - expanded.GetTop() new_rect.y += distance if not display.Contains(new_rect): # Tried moving in primary axis, but failed. # Hence try moving in the secondary axis. dx = secondary_x * (panel.GetWidth() + expanded_size.GetWidth()) dy = secondary_y * (panel.GetHeight() + expanded_size.GetHeight()) new_rect.x += dx new_rect.y += dy # Squaring makes secondary moves more expensive (and also # prevents a negative cost) distance += dx * dx + dy * dy if display.Contains(new_rect) and distance < best_distance: best = new_rect best_distance = distance return best
def AdjustRect(self, tlw, win, rect): pos, j = self.FindHighlightPos(tlw, win.ClientToScreen(rect.Position)) rect.Position = pos return wx.RectPS(pos, rect.Size)
def HighlightSizer(self, sizer): # first do the outline of the whole sizer like normal win = sizer.GetContainingWindow() tlw = win.GetTopLevelParent() pos = sizer.GetPosition() pos, useWinDC = self.FindHighlightPos(tlw, win.ClientToScreen(pos)) rect = wx.RectPS(pos, sizer.GetSize()) dc = self.DoHighlight(tlw, rect, self.color1, useWinDC) # Now highlight the actual items within the sizer. This may # get overdrawn by the code below for item boundaries, but if # there is border padding then this will help make it more # obvious. dc.SetPen(wx.Pen(self.color3, 1)) for item in sizer.GetChildren(): if item.IsShown(): if item.IsWindow(): r = item.GetWindow().GetRect() elif item.IsSizer(): p = item.GetSizer().GetPosition() s = item.GetSizer().GetSize() r = wx.RectPS(p, s) else: continue r = self.AdjustRect(tlw, win, r) dc.DrawRectangleRect(r) # Next highlight the area allocated to each item in the sizer. # Each kind of sizer will need to be done a little # differently. dc.SetPen(wx.Pen(self.color2, 1)) # wx.BoxSizer, wx.StaticBoxSizer if isinstance(sizer, wx.BoxSizer): # NOTE: we have to do some reverse-engineering here for # borders because the sizer and sizer item don't give us # enough information to know for sure where item # (allocated) boundaries are, just the boundaries of the # actual widgets. TODO: It would be nice to add something # to wx.SizerItem that would give us the full bounds, but # that will have to wait until 2.9... x, y = rect.GetPosition() if sizer.Orientation == wx.HORIZONTAL: y1 = y + rect.height for item in sizer.GetChildren(): ir = self.AdjustRect(tlw, win, item.Rect) x = ir.x if item.Flag & wx.LEFT: x -= item.Border dc.DrawLine(x, y, x, y1) if item.IsSizer(): dc.DrawRectangleRect(ir) if sizer.Orientation == wx.VERTICAL: x1 = x + rect.width for item in sizer.GetChildren(): ir = self.AdjustRect(tlw, win, item.Rect) y = ir.y if item.Flag & wx.TOP: y -= item.Border dc.DrawLine(x, y, x1, y) if item.IsSizer(): dc.DrawRectangleRect(ir) # wx.FlexGridSizer, wx.GridBagSizer elif isinstance(sizer, wx.FlexGridSizer): sizer.Layout() y = rect.y for rh in sizer.RowHeights[:-1]: y += rh dc.DrawLine(rect.x, y, rect.x + rect.width, y) y += sizer.VGap dc.DrawLine(rect.x, y, rect.x + rect.width, y) x = rect.x for cw in sizer.ColWidths[:-1]: x += cw dc.DrawLine(x, rect.y, x, rect.y + rect.height) x += sizer.HGap dc.DrawLine(x, rect.y, x, rect.y + rect.height) # wx.GridSizer elif isinstance(sizer, wx.GridSizer): # NOTE: More reverse engineering (see above.) This time we # need to determine what the sizer is using for row # heights and column widths. #rh = cw = 0 #for item in sizer.GetChildren(): # rh = max(rh, item.Size.height) # cw = max(cw, item.Size.width) cw = (rect.width - sizer.HGap * (sizer.Cols - 1)) / sizer.Cols rh = (rect.height - sizer.VGap * (sizer.Rows - 1)) / sizer.Rows y = rect.y for i in range(sizer.Rows - 1): y += rh dc.DrawLine(rect.x, y, rect.x + rect.width, y) y += sizer.VGap dc.DrawLine(rect.x, y, rect.x + rect.width, y) x = rect.x for i in range(sizer.Cols - 1): x += cw dc.DrawLine(x, rect.y, x, rect.y + rect.height) x += sizer.HGap dc.DrawLine(x, rect.y, x, rect.y + rect.height) # Anything else is probably a custom sizer, just highlight the items else: del dc for item in sizer.GetChildren(): self.HighlightSizerItem(item, sizer, 1)
def ScreenCapture(captureStartPos, captureBmapSize, debug=False): """ General Desktop screen portion capture - partial or entire Desktop. My particular screen hardware configuration: wx.Display( 0 ) refers to the primary Desktop display monitor screen. wx.Display( 1 ) refers to the extended Desktop display monitor screen (above the primary screen). Any particular Desktop screen size is : screenRect = wx.Display( n ).GetGeometry() Different wx.Display's in a single system may have different dimensions. """ # A wx.ScreenDC provides access to the entire Desktop. # This includes any extended Desktop monitor screens that are enabled in the OS. scrDC = wx.ScreenDC( ) # MSW HAS BUG: DOES NOT INCLUDE ANY EXTENDED SCREENS. scrDcSize = scrDC.Size scrDcSizeX, scrDcSizeY = scrDcSize # Cross-platform adaptations : scrDcBmap = scrDC.GetAsBitmap() scrDcBmapSize = scrDcBmap.GetSize() if debug: print 'DEBUG: Size of scrDC.GetAsBitmap() ', scrDcBmapSize # Check if scrDC.GetAsBitmap() method has been implemented on this platform. if not scrDcBmap.IsOk( ): # Not implemented : Get the screen bitmap the long way. if debug: print 'DEBUG: Using memDC.Blit() since scrDC.GetAsBitmap() is nonfunctional.' # Create a new empty (black) destination bitmap the size of the scrDC. scrDcBmap = wx.EmptyBitmap( *scrDcSize) # Overwrire the invalid original assignment. scrDcBmapSizeX, scrDcBmapSizeY = scrDcSize # Create a DC tool that is associated with scrDcBmap. memDC = wx.MemoryDC(scrDcBmap) # Copy (blit, "Block Level Transfer") a portion of the screen bitmap # into the returned capture bitmap. # The bitmap associated with memDC (scrDcBmap) is the blit destination. memDC.Blit( 0, 0, # Copy to this start coordinate. scrDcBmapSizeX, scrDcBmapSizeY, # Copy an area this size. scrDC, # Copy from this DC's bitmap. 0, 0, ) # Copy from this start coordinate. memDC.SelectObject(wx.NullBitmap) # Finish using this wx.MemoryDC. # Release scrDcBmap for other uses. else: if debug: print 'DEBUG: Using scrDC.GetAsBitmap()' # This platform has scrDC.GetAsBitmap() implemented. scrDcBmap = scrDC.GetAsBitmap( ) # So easy ! Copy the entire Desktop bitmap. if debug: print 'DEBUG: scrDcBmap.GetSize() ', scrDcBmap.GetSize() #end if return scrDcBmap.GetSubBitmap(wx.RectPS(captureStartPos, captureBmapSize))
def CalculateDockSizerLimits(self, dock): # Replacement for default calculation for min/max dock sizes. Instead # of adjusting the sizes of all the docks, only adjusts one to make the # dock insertion process a little more like what the user expected. docks, panes = aui.CopyDocksAndPanes2(self._docks, self._panes) sash_size = self._art.GetMetric(aui.AUI_DOCKART_SASH_SIZE) caption_size = self._art.GetMetric(aui.AUI_DOCKART_CAPTION_SIZE) opposite_size = self.GetOppositeDockTotalSize(docks, dock.dock_direction) for tmpDock in docks: if tmpDock.dock_direction == dock.dock_direction and \ tmpDock.dock_layer == dock.dock_layer and \ tmpDock.dock_row == dock.dock_row: tmpDock.size = 1 break neighbor_docks = [] horizontal = dock.dock_direction == aui.AUI_DOCK_LEFT or dock.dock_direction == aui.AUI_DOCK_RIGHT right_or_down = dock.dock_direction == aui.AUI_DOCK_RIGHT or dock.dock_direction == aui.AUI_DOCK_BOTTOM for d in docks: if d.dock_direction == dock.dock_direction and d.dock_layer == dock.dock_layer: if horizontal: neighbor_docks.append((d.rect.x, d.rect.width)) else: neighbor_docks.append((d.rect.y, d.rect.height)) neighbor_docks.sort() sizer, panes, docks, uiparts = self.LayoutAll(panes, docks, [], True, False) client_size = self._frame.GetClientSize() sizer.SetDimension(0, 0, client_size.x, client_size.y) sizer.Layout() for part in uiparts: part.rect = wx.RectPS(part.sizer_item.GetPosition(), part.sizer_item.GetSize()) if part.type == aui.AuiDockUIPart.typeDock: part.dock.rect = part.rect sizer.Destroy() new_dock = None for tmpDock in docks: if tmpDock.dock_direction == dock.dock_direction and \ tmpDock.dock_layer == dock.dock_layer and \ tmpDock.dock_row == dock.dock_row: new_dock = tmpDock break partnerDock = self.GetPartnerDock(dock) if partnerDock: if horizontal: pos = dock.rect.x size = dock.rect.width else: pos = dock.rect.y size = dock.rect.height min_pos = pos max_pos = pos + size if right_or_down: for p, s in neighbor_docks: if p >= pos: max_pos = p + s - sash_size break else: min_pos = p + sash_size else: for p, s in neighbor_docks: if p > pos: max_pos = p + s - sash_size break else: min_pos = p + sash_size return min_pos, max_pos direction = new_dock.dock_direction if direction == aui.AUI_DOCK_LEFT: minPix = new_dock.rect.x + new_dock.rect.width maxPix = client_size.x - opposite_size - sash_size elif direction == aui.AUI_DOCK_TOP: minPix = new_dock.rect.y + new_dock.rect.height maxPix = client_size.y - opposite_size - sash_size elif direction == aui.AUI_DOCK_RIGHT: minPix = opposite_size maxPix = new_dock.rect.x - sash_size elif direction == aui.AUI_DOCK_BOTTOM: minPix = opposite_size maxPix = new_dock.rect.y - sash_size return minPix, maxPix