def OnPaint(self, evt): """ Internal use, handles the drawing of the widget. :param evt: wxEvent instance. :return: None """ value = self.value # reversing the max/min if wx.SL_INVERSE was set if self.inverse: maxValue = self.minValue minValue = self.maxValue sliderRange = minValue - maxValue else: minValue = self.minValue maxValue = self.maxValue sliderRange = maxValue - minValue # grabbing the colours and setting the wxSlider as the same and the # colours will also be used in the drawing of the labels forecolour = self.GetForegroundColour() backcolour = self.GetBackgroundColour() self.Slider.SetForegroundColour(forecolour) self.Slider.SetBackgroundColour(backcolour) panelW, panelH = self.GetSizeTuple() sliderW, sliderH = self.Slider.GetSize() sliderX, sliderY = self.Slider.GetPosition() bmp = wx.EmptyBitmap(panelW, panelH) font = self.GetFont() dc = wx.MemoryDC() dc.SelectObject(bmp) dc.SetFont(font) # drawing the background for the labels dc.SetBrush(wx.Brush(wx.Colour(*backcolour))) dc.SetPen(wx.Pen(wx.Colour(*backcolour), 0)) dc.DrawRectangle(0, 0, panelW, panelH) dc.SetTextForeground(wx.Colour(*forecolour)) dc.SetTextBackground(wx.Colour(*backcolour)) if self.mLabel: print 'mLabel' # converting the max/min to strings maxText = self.floatFormat % maxValue minText = self.floatFormat % minValue # getting the size in pixels of the max/min values minW, minH = dc.GetTextExtent(minText) maxW, maxH = dc.GetTextExtent(maxText) if self.horizontal: if self.top: y = sliderY + sliderH else: y = sliderY - minH minX = sliderX maxX = panelW - maxW minY = y maxY = y else: if self.left: x = sliderX + sliderW + 3 else: x = sliderX - minW minY = sliderY maxY = sliderY + sliderH - maxH minX = x maxX = x dc.DrawText(minText, minX, minY) dc.DrawText(maxText, maxX, maxY) if self.vLabel: print 'vLabel' valText = self.floatFormat % value valW, valH = dc.GetTextExtent(valText) if self.horizontal: slider = float(sliderW) val = valW else: slider = float(sliderH) val = valH sldRatio = float(slider) / sliderRange loc = sldRatio * value if value == minValue: pos = 0 elif value == maxValue: pos = slider - val else: pos = loc - (val * (loc / slider)) if self.top: pos = (pos, sliderY - valH) elif self.left: pos = (sliderX - valW - 3, pos) elif self.horizontal: pos = (pos, sliderY + sliderH) else: pos = (sliderX + sliderW, pos) dc.DrawText(valText, *pos) dc.Destroy() del dc pdc = wx.PaintDC(self) pdc.DrawBitmap(bmp, 0, 0) evt.Skip()
def SetBalloonShape(self, event=None): """ Sets the balloon shape. :param `event`: on wxGTK, a `wx.WindowCreateEvent` event to process. """ size = self.GetSize() pos = self.GetPosition() dc = wx.MemoryDC(wx.EmptyBitmap(1, 1)) textlabel = self._balloonmsg.GetLabel() textfont = self._balloonmsg.GetFont() textextent = dc.GetFullTextExtent(textlabel, textfont) boxheight = size.y - textextent[1] * len(textlabel.split("\n")) boxwidth = size.x position = wx.GetMousePosition() xpos = position[0] ypos = position[1] if xpos > 20 and ypos > 20: # This Is NW Positioning positioning = "NW" xpos = position[0] - boxwidth + 20 ypos = position[1] - boxheight - 20 elif xpos <= 20 and ypos <= 20: # This Is SE Positioning positioning = "SE" xpos = position[0] - 20 ypos = position[1] elif xpos > 20 and ypos <= 20: # This Is SW Positioning positioning = "SW" xpos = position[0] - boxwidth + 20 ypos = position[1] else: # This Is NE Positioning positioning = "NE" xpos = position[0] ypos = position[1] - boxheight + 20 bmp = wx.EmptyBitmap(size.x, size.y) dc = wx.BufferedDC(None, bmp) dc.BeginDrawing() dc.SetBackground(wx.Brush(wx.Colour(0, 0, 0), wx.SOLID)) dc.Clear() dc.SetPen(wx.Pen(wx.Colour(0, 0, 0), 1, wx.TRANSPARENT)) if self._shape == BT_ROUNDED: dc.DrawRoundedRectangle(0, 20, boxwidth, boxheight - 20, 12) elif self._shape == BT_RECTANGLE: dc.DrawRectangle(0, 20, boxwidth, boxheight - 20) if positioning == "NW": dc.DrawPolygon( ((boxwidth - 40, boxheight), (boxwidth - 20, boxheight + 20), (boxwidth - 20, boxheight))) elif positioning == "SE": dc.DrawPolygon(((20, 20), (20, 0), (40, 20))) elif positioning == "SW": dc.DrawPolygon( ((boxwidth - 40, 20), (boxwidth - 20, 0), (boxwidth - 20, 20))) else: dc.DrawPolygon( ((20, boxheight), (20, boxheight + 20), (40, boxheight))) dc.EndDrawing() r = wx.RegionFromBitmapColour(bmp, wx.Colour(0, 0, 0)) self.hasShape = self.SetShape(r) if self._tipstyle == BT_BUTTON: colour = self.panel.GetBackgroundColour() self._closebutton.SetBackgroundColour(colour) self.SetPosition((xpos, ypos))
def Realize(self): """ Calculates tool layouts and positions. Must be called after tools are added to the tool bar, as otherwise the newly added tools will not be displayed. :note: Reimplemented from :class:`~wx.lib.agw.ribbon.control.RibbonControl`. """ if self._art is None: return False # Calculate the size of each group and the position/size of each tool temp_dc = wx.MemoryDC() group_count = len(self._groups) for group in self._groups: prev = None tool_count = len(group.tools) tallest = 0 for t, tool in enumerate(group.tools): tool.size, tool.dropdown = self._art.GetToolSize( temp_dc, self, tool.bitmap.GetSize(), tool.kind, t == 0, t == (tool_count - 1)) tool.state = tool.state & ~RIBBON_TOOLBAR_TOOL_DISABLED if t == 0: tool.state |= RIBBON_TOOLBAR_TOOL_FIRST if t == tool_count - 1: tool.state |= RIBBON_TOOLBAR_TOOL_LAST if tool.size.GetHeight() > tallest: tallest = tool.size.GetHeight() if prev: tool.position = wx.Point(*prev.position) tool.position.x += prev.size.x else: tool.position = wx.Point(0, 0) prev = tool if tool_count == 0: group.size = wx.Size(0, 0) else: group.size = wx.Size(prev.position.x + prev.size.x, tallest) for tool in group.tools: tool.size.SetHeight(tallest) # Calculate the minimum size for each possible number of rows sep = self._art.GetMetric(RIBBON_ART_TOOL_GROUP_SEPARATION_SIZE) smallest_area = 10000 row_sizes = [wx.Size(0, 0) for i in range(self._nrows_max)] major_axis = ((self._art.GetFlags() & RIBBON_BAR_FLOW_VERTICAL) and [wx.VERTICAL] or [wx.HORIZONTAL])[0] self.SetMinSize(wx.Size(0, 0)) minSize = wx.Size(10000, 10000) # See if we're sizing flexibly (i.e. wrapping), and set min size differently sizingFlexibly = False panel = self.GetParent() if isinstance(panel, RibbonPanel) and (panel.GetFlags() & RIBBON_PANEL_FLEXIBLE): sizingFlexibly = True # Without this, there will be redundant horizontal space because SetMinSize will # use the smallest possible height (and therefore largest width). if sizingFlexibly: major_axis = wx.HORIZONTAL for nrows in range(self._nrows_min, self._nrows_max + 1): for r in range(nrows): row_sizes[r] = wx.Size(0, 0) for g in range(group_count): group = self._groups[g] shortest_row = 0 for r in range(1, nrows): if row_sizes[r].GetWidth( ) < row_sizes[shortest_row].GetWidth(): shortest_row = r row_sizes[shortest_row].x += group.size.x + sep if group.size.y > row_sizes[shortest_row].y: row_sizes[shortest_row].y = group.size.y size = wx.Size(0, 0) for r in range(nrows): if row_sizes[r].GetWidth() != 0: row_sizes[r].DecBy(sep, 0) if row_sizes[r].GetWidth() > size.GetWidth(): size.SetWidth(row_sizes[r].GetWidth()) size.IncBy(0, row_sizes[r].y) self._sizes[nrows - self._nrows_min] = size if GetSizeInOrientation(size, major_axis) < smallest_area: smallest_area = GetSizeInOrientation(size, major_axis) self.SetMinSize(size) if sizingFlexibly: if size.x < minSize.x: minSize.x = size.x if size.y < minSize.y: minSize.y = size.y if sizingFlexibly: # Give it the min size in either direction regardless of row, # so that we're able to vary the size of the panel according to # the space the toolbar takes up. self.SetMinSize(minSize) # Position the groups dummy_event = wx.SizeEvent(self.GetSize()) self.OnSize(dummy_event) return True
def clearBmp(self, bmp): dc = wx.MemoryDC() dc.SelectObject(bmp) dc.SetBackground(wx.Brush("white")) dc.Clear()
def _Render(self): """Renders the tab, complete with the icon, text, and close button""" if self.tabBitmap: del self.tabBitmap height = self.tabHeight #rect = wx.Rect(0, 0, self.tabWidth, self.tabHeight) canvas = wx.EmptyBitmap(self.tabWidth, self.tabHeight, 24) mdc = wx.MemoryDC() mdc.SelectObject(canvas) #mdc.SetBackground(wx.Brush ((0x12,0x23,0x32))) mdc.Clear() #r = copy.copy(rect) #r.top = r.left = 0 #r.height = height mdc.DrawBitmap(self.tabBackBitmap, 0, 0, True) if self.tabImg: bmp = wx.BitmapFromImage(self.tabImg) if self.contentWidth > 16: # @todo: is this conditional relevant anymore? # Draw tab icon mdc.DrawBitmap(bmp, self.leftWidth + self.padding - bmp.GetWidth()/2, (height - bmp.GetHeight())/2) textStart = self.leftWidth + self.padding + bmp.GetWidth()/2 else: textStart = self.leftWidth mdc.SetFont(self.font) maxsize = self.tabWidth - textStart - self.rightWidth - self.padding*4 color = self.selectedColor if self.selected else self.inactiveColor mdc.SetTextForeground(colorUtils.GetSuitableColor(color, 1)) text = drawUtils.GetPartialText(mdc, self.text, maxsize, "") tx, ty = mdc.GetTextExtent(text) mdc.DrawText(text, textStart + self.padding, height / 2 - ty / 2) if self.closeButton: if self.closeBtnHovering: cbmp = self.ctabCloseBmp else: cimg = self.ctabCloseBmp.ConvertToImage() cimg = cimg.AdjustChannels(0.7, 0.7, 0.7, 0.3) cbmp = wx.BitmapFromImage(cimg) mdc.DrawBitmap( cbmp, self.contentWidth + self.leftWidth - self.ctabCloseBmp.GetWidth()/2, (height - self.ctabCloseBmp.GetHeight())/2) mdc.SelectObject(wx.NullBitmap) canvas.SetMaskColour((0x12, 0x23, 0x32)) img = canvas.ConvertToImage() if not img.HasAlpha(): img.InitAlpha() bmp = wx.BitmapFromImage(img) self.tabBitmap = bmp
def paintScatterplot(self, lower1, upper1, lower2, upper2, slope, intercept): """ Paint the scatterplot showing the given thresholds and correlation @param lower1 The lower threshold for Ch1 @param upper1 The upper threshold for Ch1 @param lower2 The lower threshold for Ch2 @param upper2 The upper threshold for Ch2 """ dc = wx.MemoryDC() dc.SelectObject(self.buffer) dc.BeginDrawing() colour = self.parent.GetBackgroundColour() dc.SetBackground(wx.Brush(colour)) dc.SetPen(wx.Pen(colour, 0)) dc.SetBrush(wx.Brush(colour)) dc.DrawRectangle(0, 0, self.size[0], self.size[1]) if not self.scatter: dc.EndDrawing() dc = None return c = 256.0 / (self.scalarMax + 1) bmp = self.scatter.ConvertToBitmap() self.scatterBitmap = bmp if not self.verticalLegend: verticalLegend = lib.ImageOperations.paintCTFValues( self.sources[1].getColorTransferFunction(), height=256, width=self.legendWidth, paintScalars=self.paintScalars) self.verticalLegend = verticalLegend else: verticalLegend = self.verticalLegend if not self.horizontalLegend: horizontalLegend = lib.ImageOperations.paintCTFValues( self.sources[0].getColorTransferFunction(), width=256, height=self.legendWidth, paintScalars=self.paintScalars) self.horizontalLegend = horizontalLegend else: horizontalLegend = self.horizontalLegend horizontalLegendWidth = verticalLegend.GetWidth() + 2 * self.emptySpace dc.DrawBitmap(verticalLegend, 0, 0) dc.DrawBitmap(horizontalLegend, self.xoffset + horizontalLegendWidth, bmp.GetHeight() + self.emptySpace) dc.DrawBitmap(bmp, self.xoffset + horizontalLegendWidth, 0, True) self.bmp = self.buffer dc.SetPen(wx.Pen(wx.Colour(255, 255, 255), 1)) if slope and intercept: x = 255 y = 255 - (255 * slope + intercept) dc.DrawLine(self.xoffset + horizontalLegendWidth, 255 - intercept, self.xoffset + horizontalLegendWidth + x, y) ymax = 255 # These are the threshold lines dc.DrawLine(self.xoffset + horizontalLegendWidth + lower1 * c, 0, self.xoffset + horizontalLegendWidth + lower1 * c, 255) dc.DrawLine(self.xoffset + horizontalLegendWidth, ymax - lower2 * c, self.xoffset + 255 + horizontalLegendWidth, ymax - lower2 * c) dc.DrawLine(self.xoffset + horizontalLegendWidth + upper1 * c, 0, self.xoffset + horizontalLegendWidth + upper1 * c, 255) dc.DrawLine(self.xoffset + horizontalLegendWidth, ymax - upper2 * c, self.xoffset + horizontalLegendWidth + 255, ymax - upper2 * c) if upper1 != lower1 and upper2 != lower2: overlay = lib.ImageOperations.getOverlay( int((upper1 - lower1) * c), int((upper2 - lower2) * c), (0, 0, 255), 64) overlay = overlay.ConvertToBitmap() borders = lib.ImageOperations.getOverlayBorders( int((upper1 - lower1) * c) + 1, int((upper2 - lower2) * c) + 1, (0, 0, 255), 90, lineWidth=2) borders = borders.ConvertToBitmap() dc.DrawBitmap(overlay, self.xoffset + horizontalLegendWidth + lower1 * c, ymax - upper2 * c, 1) dc.DrawBitmap(borders, self.xoffset + horizontalLegendWidth + lower1 * c, ymax - upper2 * c, 1) if not self.scatterLegend: self.scatterLegend = lib.ImageOperations.paintCTFValues( self.scatterCTF, width=self.legendWidth, height=256, paintScale=1) dc.DrawBitmap( self.scatterLegend, self.xoffset + horizontalLegendWidth + 255 + 2 * self.emptySpace, 0) dc.SetTextForeground(wx.Colour(255, 255, 255)) dc.SetFont(wx.Font(9, wx.SWISS, wx.NORMAL, wx.NORMAL)) dc.DrawText("%d" % lower2, 3, ymax - lower2 * c) dc.DrawText("%d" % lower1, self.xoffset + horizontalLegendWidth + lower1 * c, 265) self.scatterLegendBitmap = self.buffer self.dc = dc del self.dc dc.EndDrawing() dc = None
def Render(self): """ Recalculate dimensions as client area may have been scrolled or resized. The smallest unit of rendering that can be done is the pdf page. So render the drawing commands for the pages in the visible rectangle into a buffer big enough to hold this set of pages. Force re-creating the page buffer only when client view moves outside it. With PyPDF2, use gc.Translate to render each page wrt the pdf origin, which is at the bottom left corner of the page. """ if not self.have_file: return self.CalculateDimensions() if not self.page_buffer_valid: # Initialize the buffer bitmap. self.pagebuffer = wx.Bitmap(self.pagebufferwidth, self.pagebufferheight) self.pdc = wx.MemoryDC(self.pagebuffer) # must persist gc = GraphicsContext.Create( self.pdc) # Cairo/wx.GraphicsContext API # white background path = gc.CreatePath() path.AddRectangle(0, 0, self.pagebuffer.GetWidth(), self.pagebuffer.GetHeight()) gc.SetBrush(wx.WHITE_BRUSH) gc.FillPath(path) for pageno in range(self.frompage, self.topage + 1): self.xpageoffset = 0 - self.x0 self.ypageoffset = pageno * self.Ypagepixels - self.page_y0 gc.PushState() if mupdf: gc.Translate(self.xpageoffset, self.ypageoffset) # scaling is done inside RenderPage else: gc.Translate( self.xpageoffset, self.ypageoffset + self.pageheight * self.scale) gc.Scale(self.scale, self.scale) self.pdfdoc.RenderPage(gc, pageno, scale=self.scale) # Show inter-page gap gc.SetBrush(wx.Brush(wx.Colour(180, 180, 180))) #mid grey gc.SetPen(wx.TRANSPARENT_PEN) if mupdf: gc.DrawRectangle(0, self.pageheight * self.scale, self.pagewidth * self.scale, self.page_gap * self.scale) else: gc.DrawRectangle(0, 0, self.pagewidth, self.page_gap) gc.PopState() gc.PushState() gc.Translate(0 - self.x0, 0 - self.page_y0) self.RenderPageBoundaries(gc) gc.PopState() self.page_buffer_valid = True self.Refresh( 0 ) # Blit appropriate area of new or existing page buffer to screen # ensure we stay on the same page after zoom scale is changed if self.page_after_zoom_change: self.GoPage(self.page_after_zoom_change) self.page_after_zoom_change = None
def ShowOSD( self, osdText="", fontInfo=None, textColour=(255, 255, 255), outlineColour=(0, 0, 0), alignment=0, offset=(0, 0), displayNumber=0, timeout=3.0, event=None, skin=None, ): self.timer.cancel() if osdText.strip() == "": self.bitmap = wx.EmptyBitmap(0, 0) SetWindowPos(self.hwnd, 0, 0, 0, 0, 0, HWND_FLAGS | SWP_HIDEWINDOW) SetEvent(event) return #self.Freeze() memoryDC = wx.MemoryDC() # make sure the mask colour is not used by foreground or # background colour forbiddenColours = (textColour, outlineColour) maskColour = (255, 0, 255) if maskColour in forbiddenColours: maskColour = (0, 0, 2) if maskColour in forbiddenColours: maskColour = (0, 0, 3) maskBrush = wx.Brush(maskColour, wx.SOLID) memoryDC.SetBackground(maskBrush) if fontInfo is None: fontInfo = DEFAULT_FONT_INFO font = wx.FontFromNativeInfoString(fontInfo) memoryDC.SetFont(font) textLines = osdText.splitlines() sizes = [memoryDC.GetTextExtent(line or " ") for line in textLines] textWidths, textHeights = zip(*sizes) textWidth = max(textWidths) textHeight = sum(textHeights) if skin: bitmap = self.GetSkinnedBitmap(textLines, textWidths, textHeights, textWidth, textHeight, memoryDC, textColour, "Default") width, height = bitmap.GetSize() elif outlineColour is None: width, height = textWidth, textHeight bitmap = wx.EmptyBitmap(width, height) memoryDC.SelectObject(bitmap) # fill the DC background with the maskColour memoryDC.Clear() # draw the text with the foreground colour memoryDC.SetTextForeground(textColour) DrawTextLines(memoryDC, textLines, textHeights) # mask the bitmap, so we can use it to get the needed # region of the window memoryDC.SelectObject(wx.NullBitmap) bitmap.SetMask(wx.Mask(bitmap, maskColour)) # fill the anti-aliased pixels of the text with the foreground # colour, because the region of the window will add these # half filled pixels also. Otherwise we would get an ugly # border with mask-coloured pixels. memoryDC.SetBackground(wx.Brush(textColour, wx.SOLID)) memoryDC.SelectObject(bitmap) memoryDC.Clear() memoryDC.SelectObject(wx.NullBitmap) else: width, height = textWidth + 5, textHeight + 5 outlineBitmap = wx.EmptyBitmap(width, height, 1) outlineDC = wx.MemoryDC() outlineDC.SetFont(font) outlineDC.SelectObject(outlineBitmap) outlineDC.Clear() outlineDC.SetBackgroundMode(wx.SOLID) DrawTextLines(outlineDC, textLines, textHeights) outlineDC.SelectObject(wx.NullBitmap) outlineBitmap.SetMask(wx.Mask(outlineBitmap)) outlineDC.SelectObject(outlineBitmap) bitmap = wx.EmptyBitmap(width, height) memoryDC.SetTextForeground(outlineColour) memoryDC.SelectObject(bitmap) memoryDC.Clear() Blit = memoryDC.Blit logicalFunc = wx.COPY for x in xrange(5): for y in xrange(5): Blit(x, y, width, height, outlineDC, 0, 0, logicalFunc, True) outlineDC.SelectObject(wx.NullBitmap) memoryDC.SetTextForeground(textColour) DrawTextLines(memoryDC, textLines, textHeights, 2, 2) memoryDC.SelectObject(wx.NullBitmap) bitmap.SetMask(wx.Mask(bitmap, maskColour)) region = wx.RegionFromBitmap(bitmap) self.SetShape(region) self.bitmap = bitmap monitorDimensions = GetMonitorDimensions() try: displayRect = monitorDimensions[displayNumber] except IndexError: displayRect = monitorDimensions[0] xOffset, yOffset = offset xFunc, yFunc = ALIGNMENT_FUNCS[alignment] x = displayRect.x + xFunc((displayRect.width - width), xOffset) y = displayRect.y + yFunc((displayRect.height - height), yOffset) deviceContext = wx.ClientDC(self) deviceContext.DrawBitmap(self.bitmap, 0, 0, False) SetWindowPos(self.hwnd, 0, x, y, width, height, HWND_FLAGS | SWP_SHOWWINDOW) if timeout > 0.0: self.timer = threading.Timer(timeout, self.OnTimeout) self.timer.start() eg.app.Yield(True) SetEvent(event)
def OnPaint(self, event): dc = wx.PaintDC(self) if self.bitmap: dc.Blit(0, 0, self.bitmap.GetWidth(), self.bitmap.GetHeight(), wx.MemoryDC(self.bitmap), 0, 0)
def __init__(self, parent, id=wx.ID_ANY, title="", pos=wx.DefaultPosition, size=wx.DefaultSize, style=wx.DEFAULT_FRAME_STYLE, log=None): wx.Frame.__init__(self, parent, id, title, pos, size, style) panel = wx.Panel(self) self._ribbon = RB.RibbonBar(panel, wx.ID_ANY, agwStyle=RB.RIBBON_BAR_DEFAULT_STYLE|RB.RIBBON_BAR_SHOW_PANEL_EXT_BUTTONS) self._bitmap_creation_dc = wx.MemoryDC() self._colour_data = wx.ColourData() home = RB.RibbonPage(self._ribbon, wx.ID_ANY, "Examples", CreateBitmap("ribbon")) toolbar_panel = RB.RibbonPanel(home, wx.ID_ANY, "Toolbar", wx.NullBitmap, wx.DefaultPosition, wx.DefaultSize, agwStyle=RB.RIBBON_PANEL_NO_AUTO_MINIMISE|RB.RIBBON_PANEL_EXT_BUTTON) toolbar = RB.RibbonToolBar(toolbar_panel, ID_MAIN_TOOLBAR) toolbar.AddTool(wx.ID_ANY, CreateBitmap("align_left")) toolbar.AddTool(wx.ID_ANY, CreateBitmap("align_center")) toolbar.AddTool(wx.ID_ANY, CreateBitmap("align_right")) toolbar.AddSeparator() toolbar.AddHybridTool(wx.ID_NEW, wx.ArtProvider.GetBitmap(wx.ART_NEW, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddTool(wx.ID_ANY, wx.ArtProvider.GetBitmap(wx.ART_FILE_OPEN, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddTool(wx.ID_ANY, wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddTool(wx.ID_ANY, wx.ArtProvider.GetBitmap(wx.ART_FILE_SAVE_AS, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddSeparator() toolbar.AddDropdownTool(wx.ID_UNDO, wx.ArtProvider.GetBitmap(wx.ART_UNDO, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddDropdownTool(wx.ID_REDO, wx.ArtProvider.GetBitmap(wx.ART_REDO, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddSeparator() toolbar.AddTool(wx.ID_ANY, wx.ArtProvider.GetBitmap(wx.ART_REPORT_VIEW, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddTool(wx.ID_ANY, wx.ArtProvider.GetBitmap(wx.ART_LIST_VIEW, wx.ART_OTHER, wx.Size(16, 15))) toolbar.AddSeparator() toolbar.AddHybridTool(ID_POSITION_LEFT, CreateBitmap("position_left"), "Align ribbonbar vertically\non the left\nfor demonstration purposes") toolbar.AddHybridTool(ID_POSITION_TOP, CreateBitmap("position_top"), "Align the ribbonbar horizontally\nat the top\nfor demonstration purposes") toolbar.AddSeparator() toolbar.AddHybridTool(wx.ID_PRINT, wx.ArtProvider.GetBitmap(wx.ART_PRINT, wx.ART_OTHER, wx.Size(16, 15)), "This is the Print button tooltip\ndemonstrating a tooltip") toolbar.SetRows(2, 3) selection_panel = RB.RibbonPanel(home, wx.ID_ANY, "Selection", CreateBitmap("selection_panel")) selection = RB.RibbonButtonBar(selection_panel) selection.AddSimpleButton(ID_SELECTION_EXPAND_V, "Expand Vertically", CreateBitmap("expand_selection_v"), "This is a tooltip for Expand Vertically\ndemonstrating a tooltip") selection.AddSimpleButton(ID_SELECTION_EXPAND_H, "Expand Horizontally", CreateBitmap("expand_selection_h"), "") selection.AddButton(ID_SELECTION_CONTRACT, "Contract", CreateBitmap("auto_crop_selection"), CreateBitmap("auto_crop_selection_small")) shapes_panel = RB.RibbonPanel(home, wx.ID_ANY, "Shapes", CreateBitmap("circle_small")) shapes = RB.RibbonButtonBar(shapes_panel) shapes.AddButton(ID_CIRCLE, "Circle", CreateBitmap("circle"), CreateBitmap("circle_small"), help_string="This is a tooltip for the circle button\ndemonstrating another tooltip", kind=RB.RIBBON_BUTTON_TOGGLE) shapes.AddSimpleButton(ID_CROSS, "Cross", CreateBitmap("cross"), "") shapes.AddHybridButton(ID_TRIANGLE, "Triangle", CreateBitmap("triangle")) shapes.AddSimpleButton(ID_SQUARE, "Square", CreateBitmap("square"), "") shapes.AddDropdownButton(ID_POLYGON, "Other Polygon", CreateBitmap("hexagon"), "") sizer_panel = RB.RibbonPanel(home, wx.ID_ANY, "Panel with Sizer", wx.NullBitmap, wx.DefaultPosition, wx.DefaultSize, agwStyle=RB.RIBBON_PANEL_DEFAULT_STYLE) strs = ["Item 1 using a box sizer now", "Item 2 using a box sizer now"] sizer_panelcombo = wx.ComboBox(sizer_panel, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, strs, wx.CB_READONLY) sizer_panelcombo2 = wx.ComboBox(sizer_panel, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, strs, wx.CB_READONLY) sizer_panelcombo.Select(0) sizer_panelcombo2.Select(1) sizer_panelcombo.SetMinSize(wx.Size(150, -1)) sizer_panelcombo2.SetMinSize(wx.Size(150, -1)) # not using wx.WrapSizer(wx.HORIZONTAL) as it reports an incorrect min height sizer_panelsizer = wx.BoxSizer(wx.VERTICAL) sizer_panelsizer.AddStretchSpacer(1) sizer_panelsizer.Add(sizer_panelcombo, 0, wx.ALL|wx.EXPAND, 2) sizer_panelsizer.Add(sizer_panelcombo2, 0, wx.ALL|wx.EXPAND, 2) sizer_panelsizer.AddStretchSpacer(1) sizer_panel.SetSizer(sizer_panelsizer) label_font = wx.Font(8, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_LIGHT) self._bitmap_creation_dc.SetFont(label_font) scheme = RB.RibbonPage(self._ribbon, wx.ID_ANY, "Appearance", CreateBitmap("eye")) self._default_primary, self._default_secondary, self._default_tertiary = self._ribbon.GetArtProvider().GetColourScheme(1, 1, 1) provider_panel = RB.RibbonPanel(scheme, wx.ID_ANY, "Art", wx.NullBitmap, wx.DefaultPosition, wx.DefaultSize, agwStyle=RB.RIBBON_PANEL_NO_AUTO_MINIMISE) provider_bar = RB.RibbonButtonBar(provider_panel, wx.ID_ANY) provider_bar.AddSimpleButton(ID_DEFAULT_PROVIDER, "Default Provider", wx.ArtProvider.GetBitmap(wx.ART_QUESTION, wx.ART_OTHER, wx.Size(32, 32)), "") provider_bar.AddSimpleButton(ID_AUI_PROVIDER, "AUI Provider", CreateBitmap("aui_style"), "") provider_bar.AddSimpleButton(ID_MSW_PROVIDER, "MSW Provider", CreateBitmap("msw_style"), "") primary_panel = RB.RibbonPanel(scheme, wx.ID_ANY, "Primary Colour", CreateBitmap("colours")) self._primary_gallery = self.PopulateColoursPanel(primary_panel, self._default_primary, ID_PRIMARY_COLOUR) secondary_panel = RB.RibbonPanel(scheme, wx.ID_ANY, "Secondary Colour", CreateBitmap("colours")) self._secondary_gallery = self.PopulateColoursPanel(secondary_panel, self._default_secondary, ID_SECONDARY_COLOUR) dummy_2 = RB.RibbonPage(self._ribbon, wx.ID_ANY, "Empty Page", CreateBitmap("empty")) dummy_3 = RB.RibbonPage(self._ribbon, wx.ID_ANY, "Another Page", CreateBitmap("empty")) self._ribbon.Realize() self._logwindow = wx.TextCtrl(panel, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, wx.TE_MULTILINE | wx.TE_READONLY | wx.TE_LEFT | wx.TE_BESTWRAP | wx.BORDER_NONE) self._togglePanels = wx.ToggleButton(panel, ID_TOGGLE_PANELS, "&Toggle panels") self._togglePanels.SetValue(True) s = wx.BoxSizer(wx.VERTICAL) s.Add(self._ribbon, 0, wx.EXPAND) s.Add(self._logwindow, 1, wx.EXPAND) s.Add(self._togglePanels, 0, wx.ALL|wx.ALIGN_CENTER_HORIZONTAL, 10) panel.SetSizer(s) self.panel = panel self.BindEvents([selection, shapes, provider_bar, toolbar_panel]) self.CenterOnScreen() self.Show()
def OnPaint(self, _): width, height = self._handler.size if width <= 0 or height <= 0: bmp = wx.EmptyBitmapRGBA(1, 1) pdc = wx.PaintDC(self) gcdc = wx.GCDC(pdc) gcdc.DrawBitmap(bmp, 0, 0) gcdc.Destroy() del gcdc self._startup = None return bmp = wx.EmptyBitmapRGBA(width, height) dc = wx.MemoryDC() dc.SelectObject(bmp) gc = wx.GraphicsContext.Create(dc) gcdc = wx.GCDC(gc) gcdc.SetBrush(wx.Brush(self.GetBackgroundColour())) gcdc.SetPen(wx.TRANSPARENT_PEN) gcdc.DrawRectangle(0, 0, width, height) def draw_circle(x, y, r, _gcdc): _gcdc.DrawEllipse(int(round(float(x) - r)), int(round(float(y) - r)), int(round(r * 2.0)), int(round(r * 2.0))) gcdc.SetBrush(wx.TRANSPARENT_BRUSH) x_center, y_center = self._handler.center gcdc.SetPen(wx.TRANSPARENT_PEN) radius = self._handler.radius if self._handler.shadow: # shadow stops = wx.GraphicsGradientStops() stops.Add(wx.GraphicsGradientStop(wx.TransparentColour, 0.45)) stops.Add(wx.GraphicsGradientStop(wx.Colour(0, 0, 0, 255), 0.25)) stops.SetStartColour(wx.Colour(0, 0, 0, 255)) stops.SetEndColour(wx.TransparentColour) gc.SetBrush( gc.CreateRadialGradientBrush(x_center + (radius * 0.10), y_center + (radius * 0.10), x_center + (radius * 0.30), y_center + (radius * 0.30), radius * 2.3, stops)) draw_circle(x_center + (radius * 0.10), y_center + (radius * 0.10), radius * 2, gcdc) # eliminate any shadow under the knob just in case there is a color # used in the gradient of the knob that does not have an alpha level of 255 gc.SetBrush(wx.Brush(self.GetBackgroundColour())) draw_circle(x_center, y_center, radius - 2, gcdc) if self._handler.glow: _ = self._handler.tick_list neon_colour = self._handler.neon_colour stops = wx.GraphicsGradientStops() stops.Add(wx.GraphicsGradientStop(wx.TransparentColour, 0.265)) stops.Add( wx.GraphicsGradientStop(wx.Colour(*neon_colour + (255, )), 0.25)) stops.Add(wx.GraphicsGradientStop(wx.TransparentColour, 0.248)) stops.SetStartColour(wx.TransparentColour) stops.SetEndColour(wx.TransparentColour) gc.SetBrush( gc.CreateRadialGradientBrush(x_center, y_center, x_center, y_center, radius * 4, stops)) draw_circle(x_center, y_center, radius * 2, gcdc) # outside ring of volume knob gc.SetBrush( gc.CreateRadialGradientBrush(x_center - radius, y_center - radius, x_center, y_center - radius, radius * 2, self._handler.secondary_colour, self._handler.primary_colour)) draw_circle(x_center, y_center, radius, gcdc) thumb_x, thumb_y = self._handler.thumb_position thumb_radius = self._handler.thumb_radius # inside of volume knob if self._handler.depression: center_radius = self._handler.center_radius gc.SetBrush( gc.CreateRadialGradientBrush( x_center + center_radius, y_center + center_radius, x_center, y_center + center_radius, center_radius * 2, self._handler.secondary_colour, self._handler.primary_colour)) draw_circle(x_center, y_center, center_radius, gcdc) if self._last_degrees is None: self._last_degrees = _remap(self._handler.value, self._handler.min_value, self._handler.max_value, 135.0, 405.0) # handle of the volume knob gc.SetBrush( gc.CreateRadialGradientBrush(thumb_x + thumb_radius, thumb_y + thumb_radius, thumb_x, thumb_y + thumb_radius, thumb_radius * 2, self._handler.secondary_colour, self._handler.primary_colour)) draw_circle(thumb_x, thumb_y, thumb_radius, gcdc) if self._handler.thumb_glow: _ = self._handler.tick_list neon_colour = self._handler.neon_colour stops = wx.GraphicsGradientStops() stops.Add(wx.GraphicsGradientStop(wx.TransparentColour, 0.355)) stops.Add( wx.GraphicsGradientStop(wx.Colour(*neon_colour + (255, )), 0.28)) stops.Add(wx.GraphicsGradientStop(wx.TransparentColour, 0.258)) stops.SetStartColour(wx.TransparentColour) stops.SetEndColour(wx.TransparentColour) gc.SetBrush( gc.CreateRadialGradientBrush(thumb_x, thumb_y, thumb_x, thumb_y, thumb_radius * 4, stops)) draw_circle(thumb_x, thumb_y, thumb_radius * 2, gcdc) gcdc.SetBrush(wx.TRANSPARENT_BRUSH) # draw the tick marks if self._handler.ticks: ticks = [] pens = [] for _, pen, coords in self._handler.tick_list: ticks += [coords] pens += [pen] gcdc.DrawLineList(ticks, pens) dc.SelectObject(wx.EmptyBitmap(1, 1)) gcdc.Destroy() del gcdc dc.Destroy() del dc # create a buffered paint dc to draw the bmp to the client area pdc = wx.PaintDC(self) gcdc = wx.GCDC(pdc) gcdc.DrawBitmap(bmp, 0, 0) gcdc.Destroy() del gcdc if self._startup is True: self._startup = None t = threading.Thread(target=self._run_startup) t.daemon = True t.start() else: self._startup = None
def MakeSnapshot(self, maxColumns=1337): if self.FVsnapshot: self.FVsnapshot = None tbmp = wx.Bitmap(16, 16) tdc = wx.MemoryDC() tdc.SelectObject(tbmp) tdc.SetFont(self.font) columnsWidths = [] for i in range(len(self.DEFAULT_COLS)): columnsWidths.append(0) sFit = Fit.getInstance() try: fit = sFit.getFit(self.activeFitID) except (KeyboardInterrupt, SystemExit): raise except Exception as e: pyfalog.critical("Failed to get fit") pyfalog.critical(e) return if fit is None: return slotMap = {} for slot in [e.value for e in FittingSlot]: slotMap[slot] = fit.getSlotsFree(slot) < 0 padding = 2 isize = 16 headerSize = max(isize, tdc.GetTextExtent("W")[0]) + padding * 2 maxRowHeight = isize rows = 0 for st in self.mods: for i, col in enumerate(self.activeColumns): if i > maxColumns: break name = col.getText(st) if not isinstance(name, str): name = "" nx, ny = tdc.GetTextExtent(name) imgId = col.getImageId(st) cw = 0 if imgId != -1: cw += isize + padding if name != "": cw += nx + 4 * padding if imgId == -1 and name == "": cw += isize + padding maxRowHeight = max(ny, maxRowHeight) columnsWidths[i] = max(columnsWidths[i], cw) rows += 1 render = wx.RendererNative.Get() # Fix column widths (use biggest between header or items) for i, col in enumerate(self.activeColumns): if i > maxColumns: break name = col.columnText imgId = col.imageId if not isinstance(name, str): name = "" opts = wx.HeaderButtonParams() if name != "": opts.m_labelText = name if imgId != -1: opts.m_labelBitmap = wx.Bitmap(isize, isize) width = render.DrawHeaderButton(self, tdc, (0, 0, 16, 16), sortArrow=wx.HDR_SORT_ICON_NONE, params=opts) columnsWidths[i] = max(columnsWidths[i], width) tdc.SelectObject(wx.NullBitmap) maxWidth = padding * 2 for i in range(len(self.DEFAULT_COLS)): if i > maxColumns: break maxWidth += columnsWidths[i] mdc = wx.MemoryDC() mbmp = wx.Bitmap(maxWidth, maxRowHeight * rows + padding * 4 + headerSize) mdc.SelectObject(mbmp) mdc.SetBackground( wx.Brush(wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOW))) mdc.Clear() mdc.SetFont(self.font) mdc.SetTextForeground( wx.SystemSettings.GetColour(wx.SYS_COLOUR_WINDOWTEXT)) cx = padding for i, col in enumerate(self.activeColumns): if i > maxColumns: break name = col.columnText imgId = col.imageId if not isinstance(name, str): name = "" opts = wx.HeaderButtonParams() opts.m_labelAlignment = wx.ALIGN_LEFT if name != "": opts.m_labelText = name if imgId != -1: bmp = col.bitmap opts.m_labelBitmap = bmp render.DrawHeaderButton( self, mdc, (cx, padding, columnsWidths[i], headerSize), wx.CONTROL_CURRENT, sortArrow=wx.HDR_SORT_ICON_NONE, params=opts) cx += columnsWidths[i] brush = wx.Brush(wx.Colour(224, 51, 51)) pen = wx.Pen(wx.Colour(224, 51, 51)) mdc.SetPen(pen) mdc.SetBrush(brush) cy = padding * 2 + headerSize for st in self.mods: cx = padding if slotMap[st.slot]: mdc.DrawRectangle(cx, cy, maxWidth - cx, maxRowHeight) for i, col in enumerate(self.activeColumns): if i > maxColumns: break name = col.getText(st) if not isinstance(name, str): name = "" imgId = col.getImageId(st) tcx = cx if imgId != -1: self.imageList.Draw(imgId, mdc, cx, cy, wx.IMAGELIST_DRAW_TRANSPARENT, False) tcx += isize + padding if name != "": nx, ny = mdc.GetTextExtent(name) rect = wx.Rect() rect.top = cy rect.left = cx + 2 * padding rect.width = nx rect.height = maxRowHeight + padding mdc.DrawLabel(name, rect, wx.ALIGN_CENTER_VERTICAL) tcx += nx + padding cx += columnsWidths[i] cy += maxRowHeight mdc.SelectObject(wx.NullBitmap) self.FVsnapshot = mbmp
def __init__(self, *args, **kwargs): DCContextManager.__init__(self, wx.MemoryDC(*args, **kwargs))
def OnSaveAs(self, event): ### XXX TODO: Save overlays ### XXX TODO: Fix bug where multi-asic images are slightly cropped due to tranformation error' try: import PIL.Image as Image except ImportError: import Image dialog = wx.FileDialog( self, defaultDir='', message="Save PNG or PDF file", style=wx.FD_SAVE | wx.FD_OVERWRITE_PROMPT, wildcard="PNG file (*.png)|*.png|PDF file (*.pdf)|*.pdf") if dialog.ShowModal() != wx.ID_OK: return file_name = dialog.GetPath() if file_name == '': return self.update_statusbar("Writing " + file_name + "...") if dialog.GetFilterIndex() == 0: from six.moves import cStringIO as StringIO # XXX Copied from tile_generation.py; all its disclaimers # apply. raw_img = self.pyslip.tiles.raw_image detector = raw_img.get_detector() data = raw_img.get_raw_data() if not isinstance(data, tuple): # XXX should not need this test data = (data, ) if len(detector) > 1: from .tile_generation import _get_flex_image_multipanel flex_img = _get_flex_image_multipanel( brightness=self.settings.brightness / 100, panels=detector, raw_data=data, beam=raw_img.get_beam()) else: from .tile_generation import _get_flex_image flex_img = _get_flex_image( brightness=self.settings.brightness / 100, data=data[0], saturation=detector[0].get_trusted_range()[1], vendortype=raw_img.get_vendortype()) if flex_img.supports_rotated_tiles_antialiasing_recommended: currentZoom = self.pyslip.level self.pyslip.tiles.UseLevel(0) #1:1 zoom level try: x, y, width, height = self._img._raw.bounding_box_mm() x1, y1 = self._img._raw.detector_coords_as_image_coords( x, y) x2, y2 = self._img._raw.detector_coords_as_image_coords( x + width, y + height) except AttributeError: x1 = min([p.get_pixel_lab_coord(c)[0]/p.get_pixel_size()[0] \ for p in detector \ for c in [(0,0),(0,p.get_image_size()[1]),(p.get_image_size()[0],0),(p.get_image_size()[0],p.get_image_size()[1])]]) y1 = min([p.get_pixel_lab_coord(c)[1]/p.get_pixel_size()[1] \ for p in detector \ for c in [(0,0),(0,p.get_image_size()[1]),(p.get_image_size()[0],0),(p.get_image_size()[0],p.get_image_size()[1])]]) x2 = max([p.get_pixel_lab_coord(c)[0]/p.get_pixel_size()[0] \ for p in detector \ for c in [(0,0),(0,p.get_image_size()[1]),(p.get_image_size()[0],0),(p.get_image_size()[0],p.get_image_size()[1])]]) y2 = max([p.get_pixel_lab_coord(c)[1]/p.get_pixel_size()[1] \ for p in detector \ for c in [(0,0),(0,p.get_image_size()[1]),(p.get_image_size()[0],0),(p.get_image_size()[0],p.get_image_size()[1])]]) # Map > View - determine layout in X direction x_offset = x1 import math start_x_tile = int( math.floor(x_offset / self.pyslip.tile_size_x)) stop_x_tile = ((x2 + self.pyslip.tile_size_x - 1) / self.pyslip.tile_size_x) stop_x_tile = int(stop_x_tile) col_list = range(start_x_tile, stop_x_tile) x_pix = start_x_tile * self.pyslip.tile_size_y - x_offset y_offset = y1 start_y_tile = int( math.floor(y_offset / self.pyslip.tile_size_y)) stop_y_tile = ((y2 + self.pyslip.tile_size_y - 1) / self.pyslip.tile_size_y) stop_y_tile = int(stop_y_tile) row_list = range(start_y_tile, stop_y_tile) y_pix_start = start_y_tile * self.pyslip.tile_size_y - y_offset bitmap = wx.EmptyBitmap(x2 - x1, y2 - y1) dc = wx.MemoryDC() dc.SelectObject(bitmap) # start pasting tiles for x in col_list: y_pix = y_pix_start for y in row_list: dc.DrawBitmap(self.pyslip.tiles.GetTile(x, y), x_pix, y_pix, False) y_pix += self.pyslip.tile_size_y x_pix += self.pyslip.tile_size_x dc.SelectObject(wx.NullBitmap) wximg = wx.ImageFromBitmap(bitmap) imageout = Image.new('RGB', (wximg.GetWidth(), wximg.GetHeight())) imageout.frombytes(wximg.GetData()) self.pyslip.tiles.UseLevel(currentZoom) else: # write the image out at full resolution flex_img.setWindow(0.0, 0.0, 1) flex_img.spot_convention(0) flex_img.adjust(color_scheme=self.settings.color_scheme) flex_img.prep_string() data_string = flex_img.export_string try: imageout = Image.fromstring( "RGB", (flex_img.ex_size2(), flex_img.ex_size1()), data_string) except NotImplementedError: imageout = Image.frombytes( "RGB", (flex_img.ex_size2(), flex_img.ex_size1()), data_string) out = StringIO() imageout.save(out, "PNG") open(file_name, "wb").write(out.getvalue()) elif dialog.GetFilterIndex() == 1: from reportlab.lib.units import inch from reportlab.pdfgen import canvas # Dots per inch in PDF output, and fudge factor to not make # fine features impossibly small. XXX The fudge factor should # go. DPI = 72 LINE_WIDTH_FACTOR = 0.6 # XXX Copied from tile_generation.py; all its disclaimers # apply. raw_img = self.pyslip.tiles.raw_image detector = raw_img.get_detector() data = raw_img.get_raw_data() if not isinstance(data, tuple): # XXX should not need this test data = (data, ) if len(detector) > 1: from .tile_generation import _get_flex_image_multipanel flex_img = _get_flex_image_multipanel( brightness=self.settings.brightness / 100, panels=detector, raw_data=data, beam=raw_img.get_beam()) else: from .tile_generation import _get_flex_image flex_img = _get_flex_image( brightness=self.settings.brightness / 100, data=data[0], saturation=detector[0].get_trusted_range()[1], vendortype=raw_img.get_vendortype()) flex_img.setWindow(0, 0, 1) flex_img.adjust(color_scheme=self.settings.color_scheme) flex_img.prep_string() # XXX Order of size1/size2 correct? pdf_size = (flex_img.size2() * inch / DPI, flex_img.size1() * inch / DPI) pdf_canvas = canvas.Canvas(filename=file_name, pagesize=pdf_size) try: pil_img = Image.fromstring( 'RGB', (flex_img.size2(), flex_img.size1()), flex_img.export_string) except NotImplementedError: pil_img = Image.frombytes('RGB', (flex_img.size2(), flex_img.size1()), flex_img.export_string) pdf_canvas.drawInlineImage(pil_img, 0, 0, width=pdf_size[0], height=pdf_size[1]) for layer_id in self.pyslip.layer_z_order: layer = self.pyslip.layer_mapping[layer_id] # XXX This would probably be more elegant if these were # functions in some layer class. Note repeated roundabout # way (via a wx.Pen object) to extract RGB values from the # colour parameter. if layer.type == self.pyslip.TypeEllipse: from math import atan2, degrees, hypot from scitbx.matrix import col for (p, place, width, colour, closed, filled, fillcolour, x_off, y_off, pdata) in layer.data: if layer.map_rel: pp = [] for i in range(len(p)): fs = self.pyslip.tiles.map_relative_to_picture_fast_slow( p[i][0], p[i][1]) pp.append((fs[0] * inch / DPI, pdf_size[1] - fs[1] * inch / DPI)) ellipse_center = col(pp[0]) major = col(pp[1]) - ellipse_center minor = col(pp[2]) - ellipse_center else: raise NotImplementedError( "PDF output in view-relative coordinates not implemented" ) pen = wx.Pen(colour) pdf_canvas.setLineWidth(width * LINE_WIDTH_FACTOR) pdf_canvas.setStrokeColorRGB(pen.Colour.Red() / 255, pen.Colour.Green() / 255, pen.Colour.Blue() / 255) angle = atan2(major.elems[1], major.elems[0]) r_major = hypot(major.elems[0], major.elems[1]) r_minor = hypot(minor.elems[0], minor.elems[1]) pdf_canvas.saveState() pdf_canvas.translate(ellipse_center.elems[0], ellipse_center.elems[1]) pdf_canvas.rotate(degrees(angle)) pdf_canvas.ellipse(-r_major, -r_minor, r_major, r_minor) pdf_canvas.restoreState() elif layer.type == self.pyslip.TypeImage: raise NotImplementedError( "PDF output of image layers not implemented") elif layer.type == self.pyslip.TypePoint: for (lon, lat, place, radius, colour, x_off, y_off, pdata) in layer.data: if layer.map_rel: fs = self.pyslip.tiles.map_relative_to_picture_fast_slow( lon, lat) else: raise NotImplementedError( "PDF output in view-relative coordinates not implemented" ) pt = (fs[0] * inch / DPI, pdf_size[1] - fs[1] * inch / DPI) pen = wx.Pen(colour) pdf_canvas.setLineWidth(radius) pdf_canvas.setStrokeColorRGB(pen.Colour.Red() / 255, pen.Colour.Green() / 255, pen.Colour.Blue() / 255) pdf_canvas.circle(pt[0], pt[1], 0.5 * radius * inch / DPI) elif layer.type == self.pyslip.TypePolygon: for (p, place, width, colour, closed, filled, fillcolour, x_off, y_off, pdata) in layer.data: path = pdf_canvas.beginPath() for i in range(len(p)): if layer.map_rel: fs = self.pyslip.tiles.map_relative_to_picture_fast_slow( p[i][0], p[i][1]) else: raise NotImplementedError( "PDF output in view-relative coordinates not implemented" ) pt = (fs[0] * inch / DPI, pdf_size[1] - fs[1] * inch / DPI) if i == 0: path.moveTo(pt[0], pt[1]) else: path.lineTo(pt[0], pt[1]) if closed: path.close() pen = wx.Pen(colour) pdf_canvas.setFillColorRGB(pen.Colour.Red() / 255, pen.Colour.Green() / 255, pen.Colour.Blue() / 255) pdf_canvas.setLineWidth(width * LINE_WIDTH_FACTOR) pdf_canvas.setStrokeColorRGB(pen.Colour.Red() / 255, pen.Colour.Green() / 255, pen.Colour.Blue() / 255) pdf_canvas.drawPath(path, fill=filled) elif layer.type == self.pyslip.TypeText: for (lon, lat, tdata, placement, radius, colour, textcolour, fontname, fontsize, offset_x, offset_y, data) in layer.data: if placement != 'cc': print( Warning( "Only centered placement available when drawing text on pdf" )) if layer.map_rel: fs = self.pyslip.tiles.map_relative_to_picture_fast_slow( lon, lat) else: raise NotImplementedError( "PDF output in view-relative coordinates not implemented" ) from reportlab.pdfbase.pdfmetrics import stringWidth scale = 5 # XXX this scaleup by 5 is arbitrary! try: w = stringWidth(tdata, fontname, fontsize * scale) except KeyError: fontname = "Helvetica" w = stringWidth(tdata, fontname, fontsize * scale) if fs[0] - ( w / 2 ) < 0: # handle text falling off the left side txt = pdf_canvas.beginText(x=0, y=fs[1]) else: txt = pdf_canvas.beginText(x=fs[0] - (w / 2), y=fs[1]) txt.setFont(fontname, fontsize * scale) txt.setFillColor(textcolour) txt.setStrokeColor(textcolour) txt.textLine(tdata) pdf_canvas.drawText(txt) pdf_canvas.save() self.update_statusbar("Writing " + file_name + "..." + " Done.")
def OnPrintPage(self, page): fileSuffix = { wx.BITMAP_TYPE_BMP: 'bmp', wx.BITMAP_TYPE_JPEG: 'jpg', wx.BITMAP_TYPE_PCX: 'pcx', wx.BITMAP_TYPE_PNG: 'png', wx.BITMAP_TYPE_PNM: 'pnm', wx.BITMAP_TYPE_XPM: 'xpm', wx.BITMAP_TYPE_ICO: 'ico', wx.BITMAP_TYPE_CUR: 'cur', } try: fileSuffix[wx.BITMAP_TYPE_TIFF] = 'tiff' except: pass fileFormat = wx.BITMAP_TYPE_BMP fileExt = '.' + fileSuffix[fileFormat] exportGrid = self.prepareGrid(page) pxPerInch = 148 if self.orientation == wx.LANDSCAPE: bitmap = wx.Bitmap(pxPerInch * 11, int(pxPerInch * 8.5)) else: bitmap = wx.Bitmap(int(pxPerInch * 8.5), pxPerInch * 11) dc = wx.MemoryDC() dc.SelectObject(bitmap) dc.SetBrush(wx.WHITE_BRUSH) dc.Clear() dc.SetBrush(wx.BLACK_BRUSH) exportGrid.drawToFitDC(*([dc] + self.pageInfo[page][1:-1])) dc.SelectObject(wx.NullBitmap) dc = None image = bitmap.ConvertToImage() bitmap = None category = self.pageInfo[page][0] pageNumber = self.pageInfo[page][3] pageTotal = self.pageInfo[page][4] if pageTotal != 1: fname = u'{categoryName}-({pageNumber})-{fileBase}{fileExt}'.format( fileBase=self.fileBase, categoryName=category.fullname if category != 'Primes' else 'Primes', pageNumber=pageNumber, fileExt=fileExt, ) else: fname = u'{categoryName}-{fileBase}{fileExt}'.format( fileBase=self.fileBase, categoryName=category.fullname if category != 'Primes' else 'Primes', fileExt=fileExt, ) fname = Utils.RemoveDisallowedFilenameChars(fname).replace(' ', '-') if self.dir and not os.path.isdir(self.dir): os.mkdir(self.dir) fname = os.path.join(self.dir, fname) fnamePNG = os.path.splitext(fname)[0] + '.png' self.lastFName = fnamePNG # First same the file as a bitmap. image.SaveFile(fname, fileFormat) # Then convert the saved file to a png. # For some reason Windows requires this. with open(fname, 'rb') as f: image = wx.Image(f, fileFormat) image.SaveFile(fnamePNG, wx.BITMAP_TYPE_PNG) # Cleanup the old file. os.remove(fname) return True
def run(self): self._is_running = True # For identifying "chat:xxx" and "from:xxx" keywords query_parser = searchparser.SearchQueryParser() result = None while self._is_running: try: search = self._queue.get() if not search: continue # continue while self._is_running is_text_output = ("text" == search.get("output")) wrap_html = None # MessageParser wrap function, for HTML output if is_text_output: TEMPLATES = { "chat": templates.SEARCH_ROW_CHAT_TXT, "contact": templates.SEARCH_ROW_CONTACT_TXT, "message": templates.SEARCH_ROW_MESSAGE_TXT, "table": templates.SEARCH_ROW_TABLE_HEADER_TXT, "row": templates.SEARCH_ROW_TABLE_TXT, } wrap_b = lambda x: "**%s**" % x.group(0) output = {"format": "text"} else: TEMPLATES = { "chat": templates.SEARCH_ROW_CHAT_HTML, "contact": templates.SEARCH_ROW_CONTACT_HTML, "message": templates.SEARCH_ROW_MESSAGE_HTML, "table": templates.SEARCH_ROW_TABLE_HEADER_HTML, "row": templates.SEARCH_ROW_TABLE_HTML, } wrap_b = lambda x: "<b>%s</b>" % x.group(0) output = {"format": "html"} width = search.get("width", -1) if width > 0: dc = wx.MemoryDC() dc.SetFont( wx.Font(8, wx.FONTFAMILY_SWISS, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, face=conf.HistoryFontName)) wrap_html = lambda x: wx.lib.wordwrap.wordwrap( x, width, dc) output["wrap"] = True main.log('Searching "%(text)s" in %(table)s (%(db)s).' % search) self._stop_work = False self._drop_results = False parser = skypedata.MessageParser(search["db"], wrapper=wrap_html) # {"output": text with results, "map": link data map} # map data: {"contact:666": {"contact": {contact data}}, } result_type, result_count, count = None, 0, 0 result = { "output": "", "map": {}, "search": search, "count": 0 } sql, params, match_words = query_parser.Parse(search["text"]) # Turn wildcard characters * into regex-compatible .* match_words_re = [ ".*".join(map(re.escape, w.split("*"))) for w in match_words ] patt = "(%s)" % "|".join(match_words_re) # For replacing matching words with <b>words</b> pattern_replace = re.compile(patt, re.IGNORECASE) # Find chats with a matching title or matching participants chats = [] if search["table"] in ["conversations", "messages"]: chats = search["db"].get_conversations() chats.sort(key=lambda x: x["title"]) chat_map = {} # {chat id: {chat data}} template_chat = step.Template(TEMPLATES["chat"]) for chat in chats: chat_map[chat["id"]] = chat if "conversations" == search["table"] and match_words: title_matches = False matching_authors = [] if self.match_all(chat["title"], match_words): title_matches = True for participant in chat["participants"]: contact = participant["contact"] if contact: for n in filter(None, [ contact["fullname"], contact["displayname"], contact["identity"] ]): if self.match_all(n, match_words) \ and contact not in matching_authors: matching_authors.append(contact) if title_matches or matching_authors: count += 1 result_count += 1 result["output"] += template_chat.expand(locals()) key = "chat:%s" % chat["id"] result["map"][key] = {"chat": chat["id"]} if not count % conf.SearchResultsChunk \ and not self._drop_results: result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } if self._stop_work: break # break for chat in chats if result["output"] and not self._drop_results: result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } # Find contacts with a matching name if not self._stop_work and "contacts" == search["table"] \ and match_words: count = 0 contacts = search["db"].get_contacts() # Possibly more: country (ISO code, need map), birthday # (base has YYYYMMDD in integer field). match_fields = [ "displayname", "skypename", "province", "city", "pstnnumber", "phone_home", "phone_office", "phone_mobile", "homepage", "emails", "about", "mood_text", ] template_contact = step.Template(TEMPLATES["contact"]) for contact in contacts: match = False fields_filled = {} for field in match_fields: if contact[field]: val = contact[field] if self.match_all(val, match_words): match = True val = pattern_replace.sub(wrap_b, val) fields_filled[field] = val if match: count += 1 result_count += 1 result["output"] += template_contact.expand( locals()) if not (self._drop_results or count % conf.SearchResultsChunk): result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } if self._stop_work: break # break for contact in contacts if result["output"] and not self._drop_results: result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } # Find messages with a matching body if not self._stop_work and "messages" == search["table"]: template_message = step.Template(TEMPLATES["message"]) count, result_type = 0, "messages" chat_messages = {} # {chat id: [message, ]} chat_order = [] # [chat id, ] messages = search["db"].get_messages( additional_sql=sql, additional_params=params, ascending=False, use_cache=False) for m in messages: chat = chat_map.get(m["convo_id"]) body = parser.parse( m, pattern_replace if match_words else None, output) count += 1 result_count += 1 result["output"] += template_message.expand(locals()) key = "message:%s" % m["id"] result["map"][key] = { "chat": chat["id"], "message": m["id"] } if is_text_output or ( not self._drop_results and not count % conf.SearchResultsChunk): result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } if self._stop_work or (not is_text_output and count >= conf.MaxSearchMessages): break # break for m in messages infotext = search["table"] if not self._stop_work and "all tables" == search["table"]: infotext, result_type = "", "table row" # Search over all fields of all tables. template_table = step.Template(TEMPLATES["table"]) template_row = step.Template(TEMPLATES["row"]) for table in search["db"].get_tables(): table["columns"] = search["db"].get_table_columns( table["name"]) sql, params, words = query_parser.Parse( search["text"], table) if not sql: continue # continue for table in search["db"].. infotext += (", " if infotext else "") + table["name"] rows = search["db"].execute(sql, params) row = rows.fetchone() if not row: continue # continue for table in search["db"].. result["output"] = template_table.expand(locals()) count = 0 while row: count += 1 result_count += 1 result["output"] += template_row.expand(locals()) key = "table:%s:%s" % (table["name"], count) result["map"][key] = { "table": table["name"], "row": row } if not count % conf.SearchResultsChunk \ and not self._drop_results: result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } if self._stop_work or (not is_text_output and result_count >= conf.MaxSearchTableRows): break # break while row row = rows.fetchone() if not self._drop_results: if not is_text_output: result["output"] += "</table>" result["count"] = result_count self.postback(result) result = { "output": "", "map": {}, "search": search, "count": 0 } infotext += " (%s)" % util.plural("result", count) if self._stop_work or ( not is_text_output and result_count >= conf.MaxSearchTableRows): break # break for table in search["db"].. single_table = ("," not in infotext) infotext = "table%s: %s" % \ ("" if single_table else "s", infotext) if not single_table: infotext += "; %s in total" % \ util.plural("result", result_count) final_text = "No matches found." if self._drop_results: result["output"] = "" if result_count: final_text = "Finished searching %s." % infotext if self._stop_work: final_text += " Stopped by user." elif "messages" == result_type and not is_text_output \ and count >= conf.MaxSearchMessages: final_text += " Stopped at %s limit %s." % \ (result_type, conf.MaxSearchMessages) elif "table row" == result_type and not is_text_output \ and count >= conf.MaxSearchTableRows: final_text += " Stopped at %s limit %s." % \ (result_type, conf.MaxSearchTableRows) result[ "output"] += "</table><br /><br />%s</font>" % final_text if is_text_output: result["output"] = "" result["done"] = True result["count"] = result_count self.postback(result) main.log("Search found %(count)s results." % result) except Exception as e: if not result: result = {} result["done"], result["error"] = True, traceback.format_exc() result["error_short"] = repr(e) self.postback(result)
def __init__(self, parent, ID): wx.ScrolledWindow.__init__(self, parent, ID) self.shapes = [] self.dragImage = None self.dragShape = None self.hiliteShape = None self.SetCursor(wx.StockCursor(wx.CURSOR_ARROW)) self.bg_bmp = images.getBackgroundBitmap() # Make a shape from an image and mask. This one will demo # dragging outside the window bmp = images.getTestStarBitmap() ##bmp = wx.Bitmap('bitmaps/toucan.png') shape = DragShape(bmp) shape.pos = (5, 5) shape.fullscreen = True self.shapes.append(shape) # Make a shape from some text text = "Some Text" bg_colour = wx.Colour(57, 115, 57) # matches the bg image font = wx.Font(15, wx.ROMAN, wx.NORMAL, wx.BOLD) textExtent = self.GetFullTextExtent(text, font) # create a bitmap the same size as our text bmp = wx.EmptyBitmap(textExtent[0], textExtent[1]) # 'draw' the text onto the bitmap dc = wx.MemoryDC() dc.SelectObject(bmp) dc.SetBackground(wx.Brush(bg_colour, wx.SOLID)) dc.Clear() dc.SetTextForeground(wx.RED) dc.SetFont(font) dc.DrawText(text, 0, 0) dc.SelectObject(wx.NullBitmap) mask = wx.Mask(bmp, bg_colour) bmp.SetMask(mask) shape = DragShape(bmp) shape.pos = (5, 100) shape.text = "Some dragging text" self.shapes.append(shape) # Make some shapes from some playing card images. x = 200 for card in ['_01c_', '_12h_', '_13d_', '_10s_']: bmpFunc = getattr(images, "get%sBitmap" % card) bmp = bmpFunc() shape = DragShape(bmp) shape.pos = (x, 5) self.shapes.append(shape) x = x + 80 self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground) self.Bind(wx.EVT_PAINT, self.OnPaint) self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown) self.Bind(wx.EVT_LEFT_UP, self.OnLeftUp) self.Bind(wx.EVT_MOTION, self.OnMotion) self.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow)
def test_gcCreate2(self): bmp = wx.Bitmap(100, 100) mdc = wx.MemoryDC(bmp) gc = wx.GraphicsContext.Create(mdc) self.assertTrue(gc.IsOk())
def genImage(self): x1 = str(self.x1).rjust(4) y1 = str(self.y1).rjust(4) x2 = str(self.x2).rjust(4) y2 = str(self.y2).rjust(4) screen = wx.ScreenDC() size = screen.GetSize() bmp = wx.EmptyBitmap(size[0], size[1]) mem = wx.MemoryDC(bmp) mem.Blit(0, 0, size[0], size[1], screen, 0, 0) del mem bmp.SaveFile(self.filepath, wx.BITMAP_TYPE_PNG) if (self.comboColor.GetValue() == 'RGB'): foo = Image.open(self.filepath) else: foo = Image.open(self.filepath).convert('LA') x, y = foo.size if (self.comboQuality.GetValue() == '100%'): x_percent = 0 y_percent = 0 elif (self.comboQuality.GetValue() == '75%'): x_percent = x * 0.25 y_percent = y * 0.25 elif (self.comboQuality.GetValue() == '50%'): x_percent = x * 0.50 y_percent = y * 0.50 elif (self.comboQuality.GetValue() == '25%'): x_percent = x * 0.75 y_percent = y * 0.75 x3, y3 = math.floor(x - x_percent), math.floor(y - y_percent) foo = foo.resize((x3, y3), Image.NEAREST) img_quality = 0 left = int(x1) top = int(y1) right = int(x3) bottom = int(y3) if left > right: aux = left left = right right = aux if top > bottom: aux = top top = bottom bottom = aux foo = foo.crop((left, top, right, bottom)) output = BytesIO() foo.save(self.filepath, optimize=True, quality=img_quality) foo.convert("RGB").save(output, "BMP") data = output.getvalue()[14:] output.close() self.copyToClipboard(data) '''os._exit(0)
def __init__(self, parent, font_size): super(Frame_Gerenate, self).__init__(parent) self.dc = wx.MemoryDC() self.parent = parent self.parent.Disable() self.bmp = wx.Bitmap(RENDERSIZE, RENDERSIZE, depth=1)
def __init__(self, parent, id_, title, style=wx.DEFAULT_DIALOG_STYLE | wx.MINIMIZE_BOX): """Creates a standalone window that is used for downloading updates for the editor. @param parent: Parent Window of the dialog @param title: Title of dialog """ wx.Frame.__init__(self, parent, id_, title, style=style) util.SetWindowIcon(self) #---- Attributes/Objects ----# self.LOG = wx.GetApp().GetLog() panel = wx.Panel(self) self._progress = UpdateProgress(panel, self.ID_PROGRESS_BAR) fname = self._progress.GetCurrFileName() floc = self._progress.GetDownloadLocation() dl_file = wx.StaticText(panel, label=_("Downloading: %s") % fname) dl_loc = wx.StaticText(panel, wx.ID_ANY, _("Downloading To: %s") % floc) self._cancel_bt = wx.Button(panel, wx.ID_CANCEL, _("Cancel")) self._timer = wx.Timer(self, id=self.ID_TIMER) self._proghist = list() #---- Layout ----# self.CreateStatusBar(2) self._sizer = wx.GridBagSizer() bmp = wx.ArtProvider.GetBitmap(str(ed_glob.ID_WEB), wx.ART_TOOLBAR) mdc = wx.MemoryDC(bmp) tmp_bmp = wx.Image(ed_glob.CONFIG['SYSPIX_DIR'] + u"editra.png", wx.BITMAP_TYPE_PNG) tmp_bmp.Rescale(20, 20, wx.IMAGE_QUALITY_HIGH) mdc.DrawBitmap(tmp_bmp.ConvertToBitmap(), 11, 11) mdc.SelectObject(wx.NullBitmap) bmp = wx.StaticBitmap(panel, wx.ID_ANY, bmp) self._sizer.AddMany([(bmp, (1, 1), (3, 2)), (dl_file, (1, 4), (1, 4)), (dl_loc, (2, 4), (1, 4)), ((15, 15), (3, 5), (1, 1))]) self._sizer.Add(self._progress, (4, 1), (1, 10), wx.EXPAND) bsizer = wx.BoxSizer(wx.HORIZONTAL) bsizer.AddStretchSpacer() bsizer.Add(self._cancel_bt, 0, wx.ALIGN_CENTER_HORIZONTAL) bsizer.AddStretchSpacer() self._sizer.Add(bsizer, (6, 1), (1, 10), wx.EXPAND) self._sizer.Add((5, 5), (7, 1)) self._sizer.Add((5, 5), (7, 11)) panel.SetSizer(self._sizer) mwsz = wx.BoxSizer(wx.HORIZONTAL) mwsz.Add(panel, 1, wx.EXPAND) self.SetSizer(mwsz) self.SetInitialSize() self.SetStatusWidths([-1, 100]) self.SetStatusText(_("Downloading") + u"...", self.SB_INFO) #---- Bind Events ----# self.Bind(wx.EVT_BUTTON, self.OnButton) self.Bind(wx.EVT_CLOSE, self.OnClose) self.Bind(wx.EVT_TIMER, self.OnUpdate, id=self.ID_TIMER)
def Start(self): '''Initialize CPA ''' '''List of tables created by the user during this session''' self.user_tables = [] # splashscreen splashimage = cpa.icons.cpa_splash.ConvertToBitmap() # If the splash image has alpha, it shows up transparently on # windows, so we blend it into a white background. splashbitmap = wx.EmptyBitmapRGBA(splashimage.GetWidth(), splashimage.GetHeight(), 255, 255, 255, 255) dc = wx.MemoryDC() dc.SelectObject(splashbitmap) dc.DrawBitmap(splashimage, 0, 0) dc.Destroy() # necessary to avoid a crash in splashscreen splash = wx.SplashScreen( splashbitmap, wx.SPLASH_CENTRE_ON_SCREEN | wx.SPLASH_TIMEOUT, 2000, None, -1) self.splash = splash p = Properties.getInstance() if not p.is_initialized(): from cpa.guiutils import show_load_dialog splash.Destroy() if not show_load_dialog(): splash.Destroy() example_link_address = 'cellprofiler.org' dlg = wx.MessageDialog( None, 'CellProfiler Analyst requires a properties file. Download an example at %s' % (example_link_address), 'Properties file required', wx.OK) response = dlg.ShowModal() logging.error( 'CellProfiler Analyst requires a properties file. Exiting.' ) return False self.frame = MainGUI(p, None, size=(1000, -1)) db = DBConnect.getInstance() # Black magic: Bus errors occur on Mac OS X if we wait until # the JVM or the wx event look has started to connect. But it # has to be done after we have read the properties file. So we # do it here. db.connect() db.register_gui_parent(self.frame) # The JVM has to be started after db.connect(), otherwise bus errors # occur on Mac OS X. javabridge.start_vm(class_path=bioformats.JARS, run_headless=True) # removes the log4j warnings javabridge.attach() # TODO: check for updates try: if __version__ != -1: import cpa.util.check_for_updates as cfu cfu.check_for_updates( 'http://cellprofiler.org/updates/CPA.html', max(__version__, cpa.cpaprefs.get_skip_version()), new_version_cb, user_agent='CPAnalyst/%s' % (__version__)) except ImportError: logging.warn( "CPA was unable to check for updates. Could not import cpa.util.check_for_updates." ) self.frame.Show() # Show frame return True
def DrawView(self): """ Redraw elements. Method is used by EVT_PAINT handler. """ if os.name == 'nt': width, height = self.GraphicsWindow.GetVirtualSize() bitmap = wx.EmptyBitmap(width, height) dc = wx.BufferedDC(wx.ClientDC(self.GraphicsWindow), bitmap) dc.Clear() dc.BeginDrawing() if self.DraggingAxesPanel is not None: destBBox = self.DraggingAxesBoundingBox srcBBox = self.DraggingAxesPanel.GetAxesBoundingBox() srcBmp = _convert_agg_to_wx_bitmap( self.DraggingAxesPanel.get_renderer(), None) srcDC = wx.MemoryDC() srcDC.SelectObject(srcBmp) dc.Blit(destBBox.x, destBBox.y, int(destBBox.width), int(destBBox.height), srcDC, srcBBox.x, srcBBox.y) dc.EndDrawing() self.RefreshCanvasPosition() if not self.Fixed or self.Force: self.Force = False refresh_graphics = True else: refresh_graphics = False if self.DraggingAxesPanel is not None and self.DraggingAxesPanel not in self.GraphicPanels: self.DraggingAxesPanel.RefreshViewer(refresh_graphics) for panel in self.GraphicPanels: if isinstance(panel, DebugVariableGraphicViewer): panel.RefreshViewer(refresh_graphics) else: panel.RefreshViewer() if self.CursorTick is not None: tick = self.CursorTick elif len(self.Ticks) > 0: tick = self.Ticks[-1] else: tick = None if tick is not None: self.TickLabel.SetLabel(label=_("Tick: %d") % tick) tick_duration = int(tick * self.Ticktime) not_null = False duration = "" for value, format in [(tick_duration // DAY, _("%dd")), ((tick_duration % DAY) // HOUR, _("%dh")), ((tick_duration % HOUR) // MINUTE, _("%dm")), ((tick_duration % MINUTE) // SECOND, _("%ds"))]: if value > 0 or not_null: duration += format % value not_null = True duration += _("%03gms") % ((tick_duration % SECOND) / MILLISECOND) self.TickTimeLabel.SetLabel("t: %s" % duration) else: self.TickLabel.SetLabel("") self.TickTimeLabel.SetLabel("") self.TickSizer.Layout()
def draw(self, detal): # self.user.sync_scene() #self.user.match_time() if self.inited == False: return if self.user.ball_id == 0: return ball = self.user.get_ball() if ball == None: return self.lblFPS.SetLabel(": %d" % detal) if self.user.udp_pack_size != None: self.lblUDP.SetLabel(": %d" % self.user.udp_pack_size) else: self.lblUDP.SetLabel(": 未开启") self.lblPlayerNum.SetLabel(": %d" % len(self.user.players)) self.lblBallId.SetLabel(": %d" % self.user.ball_id) self.lblBallX.SetLabel(": %d" % int(ball.x * self.camera.scale)) self.lblBallY.SetLabel(": %d" % int(ball.y * self.camera.scale)) # print("sync_delta: ", self.user.sync_delta, " scale: ", self.camera.scale, " typeof(sync_delta): ", type(self.user.sync_delta), "typeof(scale): ", type(self.camera.scale)) self.lblBallDel.SetLabel(": %f" % (self.user.sync_delta * self.camera.scale)) self.lbl_max_dis.SetLabel(": %f" % (self.user.max_dis * self.camera.scale)) self.lbl_sync_interval.SetLabel(": %f" % ((self.user.thisSyncTime - self.user.lastSyncTime) * self.camera.scale)) self.user.mutex.acquire() rtData = self.right_top_data() myballs = {} for k, v in self.user.balls.items(): myballs[k] = v myballs_bg = {} for k, v in self.user.balls_bg.items(): myballs_bg[k] = v myplayerballs = {} for k, v in self.user.playerballs.items(): myplayerballs[k] = v mynofindball = {} for k, v in self.user.no_find_ball.items(): mynofindball[k] = v self.user.mutex.release() self.draw_right_top(rtData) mapsize = NET_SCALE * self.res.map["size"] x = 0 y = 0 if ball != None: x = ball.x y = ball.y viewdata = self.camera.get_view( \ wx.Size(PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT), \ wx.Point(x,y), \ wx.Size(mapsize, mapsize)) bitmap = wx.Bitmap(viewdata["width"], viewdata["height"]) m = wx.MemoryDC(bitmap) m.Clear() subBitMap = self.bg.GetSubBitmap(wx.Rect(viewdata["xbegin"], viewdata["ybegin"], PLAY_AREA_WIDTH, PLAY_AREA_HEIGHT)) m.DrawBitmap(subBitMap, 0, 0) m.SetBrush(wx.Brush(wx.Colour(184,134,11))) for block in self.res.map["nodes"]: x = block["px"] * NET_SCALE * self.camera.scale y = block["py"] * NET_SCALE * self.camera.scale tmps = block["radius"] * NET_SCALE * self.camera.scale if x > viewdata["xbegin"] - tmps * 2 and \ y > viewdata["ybegin"] - tmps * 2 and \ x < viewdata["xend"] + tmps * 2 and \ y < viewdata["yend"] + tmps * 2: if tmps < 5: #为了看的见 tmps = 5 tmpposx = (x - tmps) - viewdata["xbegin"] tmpposy = (y - tmps) - viewdata["ybegin"] m.DrawRectangle(tmpposx, tmpposy, tmps*2, tmps*2) myball = myplayerballs[self.user.ball_id] w = 1800 * self.camera.scale h = 1800 * self.camera.scale tmpposx = myball.x * self.camera.scale - viewdata["xbegin"] tmpposy = myball.y * self.camera.scale - viewdata["ybegin"] cellwidth = cellheight = int( math.ceil( NET_SCALE * 5 * self.camera.scale)) minX = int(math.floor((tmpposx - w/2)/cellwidth) * cellwidth) maxX = int(math.floor((tmpposx + w/2)/cellwidth) * cellwidth) minY = int(math.floor((tmpposy - h/2)/cellheight) * cellheight) maxY = int(math.floor((tmpposy + h/2)/cellheight) * cellheight) m.SetBrush(wx.Brush(wx.Colour(238,221,130))) for _, bg in myballs_bg.items(): x = bg.x * self.camera.scale y = bg.y * self.camera.scale tmps = 25 * self.camera.scale if x - viewdata["xbegin"] > minX and \ y - viewdata["ybegin"] > minY and \ x - viewdata["xbegin"] < maxX + cellwidth and \ y - viewdata["ybegin"] < maxY + cellheight: if tmps < 5: #为了看的见 tmps = 5 tmpposx = (x - tmps) - viewdata["xbegin"] tmpposy = (y - tmps) - viewdata["ybegin"] m.DrawRectangle(tmpposx, tmpposy, tmps*2, tmps*2) for _, ball in myballs.items(): tmpposx = ball.x * self.camera.scale - viewdata["xbegin"]# * self.camera.get_cell_size() tmpposy = ball.y * self.camera.scale - viewdata["ybegin"]# * self.camera.get_cell_size() tmps = int(self.res.food[ball.type]["size"] * NET_SCALE * self.camera.scale) if tmps < 5: #为了看的见 tmps = 5 t = self.res.food[ball.type]["type"] if t == proto.wilds_pb2.FoodNormal: m.SetBrush(wx.BLUE_BRUSH) m.DrawCircle(tmpposx, tmpposy, tmps) elif t == proto.wilds_pb2.FoodHammer: m.SetPen(wx.BLACK_PEN) m.DrawText("%s" % ("锤子"), tmpposx - 18, tmpposy - 10) elif t == proto.wilds_pb2.FoodBomb: m.SetPen(wx.BLACK_PEN) m.DrawText("%s" % ("炸弹"), tmpposx - 18, tmpposy - 10) elif t == proto.wilds_pb2.FeedNormal: m.SetBrush(wx.Brush(wx.Colour(153,50,204))) m.DrawCircle(tmpposx, tmpposy, tmps) elif t == proto.wilds_pb2.SkillHammer: m.SetBrush(wx.YELLOW_BRUSH) m.DrawCircle(tmpposx, tmpposy, tmps) m.DrawText("%s" % ("锤子"), tmpposx - 18, tmpposy - 10) elif t == proto.wilds_pb2.SkillBomb: m.SetBrush(wx.YELLOW_BRUSH) m.DrawCircle(tmpposx, tmpposy, tmps) m.DrawText("%s" % ("炸弹"), tmpposx - 18, tmpposy - 10) for _, ball in myplayerballs.items(): s = self.res.animal[ball.level]["scale"] if ball.id == self.user.ball_id: m.SetBrush(wx.GREEN_BRUSH) self.ballx = ball.x * self.camera.scale - viewdata["xbegin"] self.bally = ball.y * self.camera.scale - viewdata["ybegin"] prex = (ball.client_now_x - ball.client_pre_x ) * (ball.client_now_x - ball.client_pre_x ) prey = (ball.client_now_y - ball.client_pre_y ) * (ball.client_now_y - ball.client_pre_y ) self.lblMoveDisC.SetLabel(": %f (100ms)" % (math.sqrt(prex + prey))) prex = (ball.server_now_x - ball.server_pre_x ) * (ball.server_now_x - ball.server_pre_x ) prey = (ball.server_now_y - ball.server_pre_y ) * (ball.server_now_y - ball.server_pre_y ) self.lblMoveDisS.SetLabel(": %f (100ms)" % (math.sqrt(prex + prey))) else: m.SetBrush(wx.RED_BRUSH) m.SetPen(wx.BLACK_PEN) tmpposx = ball.x * self.camera.scale - viewdata["xbegin"] tmpposy = ball.y * self.camera.scale - viewdata["ybegin"] tmps = int(s * NET_SCALE * self.camera.scale) if tmps < 5: #为了看的见 tmps = 5 m.DrawCircle(tmpposx, tmpposy, tmps) m.SetPen(wx.RED_PEN) m.SetBrush(wx.TRANSPARENT_BRUSH) if ball.id == self.user.ball_id: m.DrawRectangle(tmpposx - w/2, tmpposy - h/2, w, h) m.DrawRectangle(minX, minY, maxX - minX + cellwidth, maxY - minY + cellheight) m.SetPen(wx.BLACK_PEN) tempv = None if ball.face != 0: if ball.face in myplayerballs: tempv = vector2.Vector(myplayerballs[ball.face].x - ball.x, myplayerballs[ball.face].y - ball.y) if tempv == None: angleX = math.cos(math.pi * ball.angle / 180.0) angleY = -math.sin(math.pi * ball.angle / 180.0) tempv = vector2.Vector(angleX, angleY) tempv.NormalizeSelf() tempv.ScaleBy(tmps) tempv.IncreaseBy(vector2.Vector(tmpposx, tmpposy)) m.DrawLine(tmpposx, tmpposy, tempv.x, tempv.y) if ball.state != 0: m.DrawText("%s" % state.NAME[ball.state], tmpposx - 20, tmpposy - 35) m.DrawText("hp:%d" % ball.hp, tmpposx - 20, tmpposy - 20) if ball.id == self.user.ball_id and ball.curmp!=None: m.DrawText("curmp:%d" % ball.curmp, tmpposx - 20, tmpposy - 5) m.DrawText("lvl:%d" % ball.level, tmpposx - 15, tmpposy + 10) # 经验条 if ball.id == self.user.ball_id: nextLevelExp = self.user.res.get_next_level_exp(ball.level) curLevelExp = 0 if ball.level > 1: curLevelExp = self.user.res.get_next_level_exp(ball.level - 1) if ball.curexp - curLevelExp > 0: angle = math.pi * 2 * (ball.curexp - curLevelExp) / (nextLevelExp - curLevelExp) # print("level:", ball.level, " nle:", nextLevelExp, " cle:", curLevelExp, " curexp:", ball.curexp, " angle:", angle / math.pi * 180) tox = tmpposx + math.cos(angle) * tmps toy = tmpposy - math.sin(angle) * tmps pen = wx.Pen(wx.Colour(255, 0, 0), 2) m.SetPen(pen) m.DrawArc(tmpposx + tmps, tmpposy, tox, toy, tmpposx, tmpposy) m.SetBrush(wx.WHITE_BRUSH) for _, ball in mynofindball.items(): tmpposx = ball.x * self.camera.scale - viewdata["xbegin"] tmpposy = ball.y * self.camera.scale - viewdata["ybegin"] tmps = 30 * self.camera.scale m.DrawCircle(tmpposx, tmpposy, tmps) m.DrawText("%d" % ball.id, tmpposx - 10, tmpposy - 15) if self.EndTime!=None: m.DrawText("剩余时间:%d" % (self.EndTime), PLAY_AREA_WIDTH / 2 - 50, 50) m.SelectObject(wx.NullBitmap) del m dc = wx.ClientDC(self.panel) #dc.DrawBitmap(bitmap, -viewdata["draw_xbegin"], -viewdata["draw_ybegin"]) dc.DrawBitmap(bitmap, 0, 0) del dc
def test_NativeHandle(self): dc = wx.MemoryDC(wx.Bitmap(10, 10)) h = dc.GetHandle() self.assertTrue(h is not None) self.assertNotEqual(int(h), 0)
def SetNextPos(self): self.user.mutex.acquire() mapsize = NET_SCALE * self.res.map["size"] radius = 0.25 * NET_SCALE # if self.pre_cal_speed_time == 0: # self.pre_cal_speed_time = int(round(time.time() * 1000)) now = int(round(time.time() * 1000)) # detal = now - self.pre_cal_speed_time # self.pre_cal_speed_time = now for _, v in self.user.playerballs.items(): #new # prex = v.x # prey = v.y # passTime = now - v.last_update_time # if now < v.this_cli_time: # v.x += v.vx * passTime / 50 # v.y += v.vy * passTime / 50 # moveDis = math.sqrt((v.x - prex) * (v.x - prex) + (v.y - prey) * (v.y - prey)) # # print("move dis ", moveDis, " passtime ", passTime, " vx ", v.vx) # elif v.last_update_time >= v.this_cli_time: # v.x += v.this_vx * passTime / 50 # v.y += v.this_vy * passTime / 50 # moveDis = math.sqrt((v.x - prex) * (v.x - prex) + (v.y - prey) * (v.y - prey)) # # print("move dis ", moveDis, " passtime ", passTime, " this_vx ", v.this_vx) # else: # t1 = v.this_cli_time - v.last_update_time # v.x += v.vx * t1 / 50 # v.y += v.vy * t1 / 50 # t2 = now - v.this_cli_time # v.x += v.this_vx * t2 / 50 # v.y += v.this_vy * t2 / 50 # moveDis = math.sqrt((v.x - prex) * (v.x - prex) + (v.y - prey) * (v.y - prey)) # # print("move dis ", moveDis, " passtime ", passTime, " (vx) ", v.vx, " ", v.this_vx) # #new # #old # # v.x += v.vx*detal/50 # # v.y += v.vy*detal/50 # #old # if v.x > mapsize - radius: # v.x = mapsize - radius # elif v.x < radius: # v.x = radius # if v.y > mapsize - radius: # v.y = mapsize - radius # elif v.y < radius: # v.y = radius # if abs(v.x - v.this_x) < 1: # v.x = v.this_x # if abs(v.y - v.this_y) < 1: # v.y = v.this_y # v.last_update_time = now self.user.gameSync.UpdateMove(v, mapsize, now, self) # if now >= v.this_cli_time + 100: # v.vx = v.this_vx # v.vy = v.this_vy if v.id == self.user.ball_id: if self.show_line: m = wx.MemoryDC(self.bg) m.SetBrush(wx.BLACK_BRUSH) m.DrawCircle(v.x, v.y, 1) m.SetBrush(wx.RED_BRUSH) m.DrawCircle(v.this_x, v.this_y, 1) interval = self.user.thisSyncTime - self.user.lastSyncTime if interval >= 150: m.DrawText("%dms" % interval, v.x, v.y) self.user.lastSyncTime = self.user.thisSyncTime m.SelectObject(wx.NullBitmap) del m for _, v in self.user.balls.items(): if v.isplayer != None: self.user.gameSync.UpdateMove(v, mapsize, now, self) self.user.mutex.release()
import wx import os import ftplib w = wx.App() screen = wx.ScreenDC() size = screen.GetSize() bmap = wx.Bitmap(size[0], size[1]) memo = wx.MemoryDC(bmap) memo.Blit(0, 0, size[0], size[1], screen, 0, 0) bmap.SaveFile("grabbed.png", wx.BITMAP_TYPE_PNG) sess_ = ftplib.FTP("localhost", "flypython", "flypython") file_ = open("grabbed.png", "rb") sess_.storbinary("STOR grabbed.png", file_) file_.close() sess_.quit()
# Este programa eh distribuido na expectativa de ser util, mas SEM # QUALQUER GARANTIA; sem mesmo a garantia implicita de # COMERCIALIZACAO ou de ADEQUACAO A QUALQUER PROPOSITO EM # PARTICULAR. Consulte a Licenca Publica Geral GNU para obter mais # detalhes. # -------------------------------------------------------------------------- import sys import numpy import wx from wx.lib import intctrl from invesalius.gui.widgets.inv_spinctrl import InvSpinCtrl try: dc = wx.MemoryDC() font = wx.SystemSettings.GetFont(wx.SYS_DEFAULT_GUI_FONT) dc.SetFont(font) PUSH_WIDTH = dc.GetTextExtent("M")[0] // 2 + 1 del dc del font except Exception: PUSH_WIDTH = 7 myEVT_SLIDER_CHANGED = wx.NewEventType() EVT_SLIDER_CHANGED = wx.PyEventBinder(myEVT_SLIDER_CHANGED, 1) myEVT_SLIDER_CHANGING = wx.NewEventType() EVT_SLIDER_CHANGING = wx.PyEventBinder(myEVT_SLIDER_CHANGING, 1) myEVT_THRESHOLD_CHANGED = wx.NewEventType()
def onTakeScreenShot(self, event, name): # """ # Делает скриншот выбранного фрагмента экрана # Основано на методе, предложенном Андреа Гавана start1 = clock() with open('coord_snapshot.txt', 'r') as f: # извлекаем из файла data2 = json.load(f) print('', data2) rect1 = data2 # win32gui.GetWindowRect(hwnd) # mfcDC = win32ui.CreateDCFromHandle(hwnd) print('rect', rect1) rect = self.GetRect() # получаем координаты своего окна rect.x = rect1[0] # +134 rect.y = rect1[1] # +275 rect.width = rect1[2] - rect1[0] # +1080) rect.height = rect1[3] - rect1[1] # +691) # print('координаты', rect.x, rect.y, rect.width, rect.height) # Настройка ширины для Linux обнаружено Джоном Торресом # http://article.gmane.org/gmane.comp.python.wxpython/67327 if sys.platform == 'linux2': client_x, client_y = self.ClientToScreen((0, 0)) border_width = client_x - rect.x title_bar_height = client_y - rect.y rect.width += (border_width * 2) rect.height += title_bar_height + border_width # Сделать скриншот всей зоны DC (контекста устройства) dcScreen = wx.ScreenDC() # Создать битмап, в котором сохранится скриншот # Учтите, что битмап должен быть достаточно большим, чтобы в него поместился скриншот # -1 значит использование текущей стандартной глубины цвета bmp = wx.Bitmap(rect.width, rect.height) # Создать в памяти DC, который будет использован непосредственно для скриншота memDC = wx.MemoryDC() # Прикажите DC использовать наш битмап # Все изображения из DC теперь переместится в битмап memDC.SelectObject(bmp) # Blit в данном случае скопируйте сам экран в кэш памяти # и, таким образом, он попадёт в битмап memDC.Blit( 0, # Скопируйте сюда координат Х 0, # Скопируйте сюда координат Y rect.width, # Скопируйте эту ширину rect.height, # Скопируйте эту высоту dcScreen, # Место, откуда нужно скопировать rect. x, # Какой офсет у Х в оригинальном DC (контексте устройства)? rect.y # Какой офсет у Y в оригинальном DC? ) # Select the Bitmap out of the memory DC by selecting a new # uninitialized Bitmap memDC.SelectObject(wx.NullBitmap) fileName = name + '.bmp' img = bmp.ConvertToImage() img.SaveFile(fileName, wx.BITMAP_TYPE_BMP) print('...saving as BMP!') end1 = clock() print("Result (iterativ): выполняется за " + "\nФункция %1.10f секунд" % (end1 - start1))
def OnPaint(self, event): """ Handles the ``wx.EVT_PAINT`` event for :class:`AquaButton`. :param `event`: a :class:`PaintEvent` event to be processed. """ dc = wx.BufferedPaintDC(self) gc = wx.GraphicsContext.Create(dc) xpos, ypos, width, height = self.GetClientRect() dc.SetBackground(wx.Brush(self._rectColour)) dc.Clear() gc.SetBrush(wx.WHITE_BRUSH) shadowOffset = 5 btnOffset = 0 clr = self._backColour if self._mouseAction == CLICK: shadowOffset = 3 clr = self._hoverColour btnOffset = 2 elif self._mouseAction == HOVER: clr = self._hoverColour elif self._hasFocus: clr = self._focusColour elif not self.IsEnabled(): clr = self._disableColour rc1 = wx.Rect(btnOffset, btnOffset, width-8-btnOffset, height-8-btnOffset) path1 = self.GetPath(gc, rc1, 10) br1 = gc.CreateLinearGradientBrush(0, 0, 0, rc1.height+6, clr, wx.WHITE) # Create shadow rc2 = wx.Rect(*rc1) rc2.Offset((shadowOffset, shadowOffset)) path2 = self.GetPath(gc, rc2, 10) br2 = gc.CreateRadialGradientBrush(rc2.x, rc2.y, rc2.x+rc2.width, rc2.y+rc2.height, rc2.width, self._shadowColour, wx.WHITE) # Create top water colour to give "aqua" effect rc3 = wx.Rect(*rc1) rc3.Inflate(-5, -5) rc3.height = 15 path3 = self.GetPath(gc, rc3, 10) br3 = gc.CreateLinearGradientBrush(rc3.x, rc3.y, rc3.x, rc3.y+rc3.height, wx.WHITE, wx.TransparentColour) # draw shapes gc.SetBrush(br2) gc.FillPath(path2) #draw shadow gc.SetBrush(br1) gc.FillPath(path1) #draw main gc.SetBrush(br3) gc.FillPath(path3) #draw top bubble font = gc.CreateFont(self.GetFont(), self._textColour) gc.SetFont(font) label = self.GetLabel() tw, th = gc.GetTextExtent(label) if self._bitmap: bw, bh = self._bitmap.GetWidth(), self._bitmap.GetHeight() else: bw = bh = 0 pos_x = (width-bw-tw)/2+btnOffset-shadowOffset # adjust for bitmap and text to centre if self._bitmap: pos_y = (height-bh-shadowOffset)/2+btnOffset gc.DrawBitmap(self._bitmap, pos_x, pos_y, bw, bh) # draw bitmap if available pos_x = pos_x + 2 # extra spacing from bitmap # Create a Path to draw the text gc.DrawText(label, pos_x + bw + btnOffset, (height-th-shadowOffset)/2+btnOffset) # draw the text if self._saveBitmap: # Save the bitmap using wx.MemoryDC for later use self._saveBitmap = False memory = wx.MemoryDC() self._storedBitmap = wx.Bitmap.FromRGBA(max(width, 1), max(height, 1)) memory.SelectObject(self._storedBitmap) gcMemory = wx.GraphicsContext.Create(memory) gcMemory.SetBrush(br1) gcMemory.FillPath(path1) #draw main gcMemory.SetBrush(br3) gcMemory.FillPath(path3) #draw top bubble if self._bitmap: gcMemory.DrawBitmap(self._bitmap, pos_x - 2, pos_y, bw, bh) gcMemory.SetFont(font) gcMemory.DrawText(label, pos_x + bw + btnOffset, (height-th-shadowOffset)/2+btnOffset) memory.SelectObject(wx.NullBitmap) self._storedBitmap = self._storedBitmap.ConvertToImage()