Exemple #1
0
    def __init__(self, *args, **kwargs):
        #--call the super-class constructor--
        wx.Panel.__init__(self, *args, **kwargs)

        #--globals--
        global boldFont12

        #--setup parent--
        self.parent = args[0]

        #--set the background color--
        self.SetBackgroundColour(wx.Color(0, 0, 128))

        #--attributes--
        self.playQueue = []

        #--add static text label--
        label = wx.StaticText(self, id=wx.ID_ANY, label="Playlist:")
        label.SetForegroundColour(wx.Color(255, 255, 255))
        label.SetFont(boldFont12)

        #--play queue--
        self.playQueueDisplay = wx.ListBox(parent=self, id=wx.ID_ANY)
        self.playQueueDisplay.SetBackgroundColour(wx.Color(102, 102, 255))
        self.playQueueDisplay.Bind(wx.EVT_LISTBOX, self.onSelect_song)
        #self.playQueueDisplay.Disable() #disable since it is read-only

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(label, 0, wx.ALL, 10)
        sizer.Add(self.playQueueDisplay, 1, wx.ALL | wx.EXPAND, 10)
        self.SetSizer(sizer)
        self.Fit()
        return
    def Paint(self):
        #log.debug("OnPaint event")
        dc = wx.MemoryDC()
        dc.SelectObject(self.bitmap)
        dc.Clear()
        dc.BeginDrawing()
        dc.SetBrush(wx.Brush(wx.Color(*self.falling_block.color), wx.SOLID))
        for (i, j) in self.falling_block.absolute_positions():
            dc.DrawRectangle(j * Tetris.BLOCK_SIZE,
                             i * Tetris.BLOCK_SIZE,
                             Tetris.BLOCK_SIZE,
                             Tetris.BLOCK_SIZE)

        for i in xrange(len(self.used_positions)):
            for j in xrange(len(self.used_positions[i])):
                if self.used_positions[i][j]:
                    dc.SetBrush(wx.Brush(wx.Color(*self.used_positions[i][j]), wx.SOLID))
                    dc.DrawRectangle(j * Tetris.BLOCK_SIZE,
                                     i * Tetris.BLOCK_SIZE,
                                     Tetris.BLOCK_SIZE,
                                     Tetris.BLOCK_SIZE)
        dc.EndDrawing()

        dest_dc = wx.PaintDC(self.panel)
        dest_dc.Blit(0, 0, Tetris.BOARD_SIZE[0], Tetris.BOARD_SIZE[1],
                     dc, 0, 0)
Exemple #3
0
 def drawParticules(self, bool, col=wx.Color(255, 0, 0), valeur=None):
     obj = self.getObjFromType('particules')
     txt = []
     if obj == None: return
     lignes = obj.getObject()
     data = obj.getData()
     if type(valeur) == type((3, 4)):
         if len(valeur) >= 1: valeur = valeur[0]
     if col == None: col = wx.Color(255, 0, 0)
     a = col.Get()
     col = (a[0] / 255, a[1] / 255, a[2] / 255)
     for i in range(len(lignes)):
         lignes[i].set_visible(bool)
         lignes[i].set_color(col)
     obj = self.getObjFromType('partTime')
     if obj == None: return
     if (valeur == None) or (bool == False): obj.setVisible(bool)
     elif (valeur > 0) and bool:
         obj.setVisible(False)
         for p in data:
             X, Y, T = p
             tx, ty, tt = self.ptsPartic(X, Y, T, valeur)
             for i in range(len(tx)):
                 a = str(tt[i])
                 b = a.split('.')
                 ln = max(4, len(b[0]))
                 txt.append(pl.text(tx[i], ty[i], a[:ln], fontsize='8'))
         obj = GraphicObject('partTime', txt, False, None)
         self.addGraphicObject(obj)
     self.gui_repaint()
     self.draw()
    def create_container(self, parent):
        color = self.item.feed.color or settings.POPUP_BORDER_COLOR

        panel1 = wx.Panel(parent, -1, style=wx.WANTS_CHARS)
        panel1.SetBackgroundColour(wx.Color(*color))
        panel1.SetForegroundColour(wx.Color(*color))
        panel2 = wx.Panel(panel1, -1)
        panel2.SetBackgroundColour(wx.BLACK)
        panel2.SetForegroundColour(wx.BLACK)
        panel3 = wx.Panel(panel2, -1)
        panel3.SetBackgroundColour(wx.WHITE)
        panel3.SetForegroundColour(wx.BLACK)
        contents = self.create_contents(panel3)

        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(panel2, 1, wx.EXPAND|wx.ALL, settings.POPUP_BORDER_SIZE)
        panel1.SetSizer(sizer)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(panel3, 1, wx.EXPAND|wx.ALL, 1)
        panel2.SetSizer(sizer)
        sizer = wx.BoxSizer(wx.VERTICAL)
        sizer.Add(contents, 1, wx.EXPAND|wx.ALL)
        panel3.SetSizer(sizer)

        panel1.Fit()
        self.bind_widgets([panel1, panel2, panel3])
        return panel1
Exemple #5
0
    def __init__(self,
                 parent,
                 bitmap,
                 drawDropArrow=False,
                 hoverBitmap=None,
                 drawHoverBox=True,
                 style=wx.NO_BORDER):
        self.bitmap = bitmap
        self.disabledBitmap = None
        self.hoverBitmap = hoverBitmap
        self.drawHoverBox = drawHoverBox
        self.drawDropArrow = drawDropArrow

        self.borderColor = getDefaultControlBorderColor()
        self.hoverBackgroundColor = wx.Color(254, 225, 119)
        self.clickBackgroundColor = wx.Color(251, 209, 61)

        wx.PyControl.__init__(self, parent, wx.ID_ANY, style=style)
        ZClickableControlMixin.__init__(self)
        ZHoverableControlMixin.__init__(self)

        self.Bind(wx.EVT_PAINT, self.onPaint, self)
        self.Bind(wx.EVT_ERASE_BACKGROUND, self.onEraseBackground, self)

        sizeW = self.bitmap.GetWidth()
        sizeH = self.bitmap.GetHeight()
        if self.drawHoverBox or self.drawDropArrow:
            sizeW += 4
            sizeH += 4
        self.SetSizeHints(sizeW, sizeH)
Exemple #6
0
    def __init__(self):
        super(LcdTest, self).__init__(None, size=(200, 200))

        self._p = wx.Panel(self)

        colors = [
            wx.Color(128, 128, 128),
            wx.Color(192, 0, 0),
            wx.Color(0, 192, 0),
            wx.Color(0, 0, 192),
        ]
        l1 = LED(self._p, colors=colors)
        l2 = LED(self._p, colors=colors)
        l3 = LED(self._p, colors=colors)
        self._led_lst = (l1, l2, l3)

        sz = wx.BoxSizer(wx.VERTICAL)
        flg = wx.ALL | wx.ALIGN_CENTER
        sz.Add(l1, 0, flg, 5)
        sz.Add(l2, 0, flg, 5)
        sz.Add(l3, 0, flg, 5)

        self._p.SetSizerAndFit(sz)
        self.SetClientSize(sz.GetSize())
        self.Show()

        wx.FutureCall(125, self._time_passed)
Exemple #7
0
	def TreeColourItem(self, tree, item, mode):
		if mode == "normal":
			tree.SetItemTextColour(item, wx.Color(0, 0, 0))
		elif mode == "updating":
			tree.SetItemTextColour(item, wx.Color(0, 0, 255))
		elif mode == "removing":
			tree.SetItemTextColour(item, wx.Color(255, 0, 0))
    def draw(self, dc):
        """ Draws this DrawingObject into our window.
            'dc' is the device context to use for drawing.
        """
        psize = self.parent.GetSizeTuple()

        # Setup the dimensions of the main bar
        # The main bar spans the width of the parent
        x1, y1 = 0, 0
        w1, h1, c1 = psize[0], psize[1], 0  # c1 is the intended curve
        rect = (x1, y1, h1, c1)

        # Define Gradient colours
        clr1 = wx.Color(59, 59, 59)
        clr2 = wx.Color(190, 190, 190)

        # Setup drawing tools
        dc.SetPen(wx.Pen('white', 10, wx.TRANSPARENT))
        dc.SetBrush(wx.Brush('gray', wx.SOLID))
        #br1 = gc.CreateLinearGradientBrush(x1,y1,x1,(y1+h1),clr1,clr2) # +5 ensures that gradient repetition does not show

        # Setup and draw the main horizontal bar
        #gc.SetBrush(br1)
        dc.DrawRoundedRectangle(x1, y1, w1, h1, c1)

        x2 = (0.698 * psize[0])
        y2 = (0.29 * psize[1])
        w2 = (0.259 * psize[0])
        h2 = (0.47 * psize[1])
        dc.SetPen(wx.Pen('white', 1, wx.SOLID))
        dc.SetBrush(wx.Brush('white', wx.SOLID))
        dc.DrawRoundedRectangle(x2, y2, w2, h2, 3)
Exemple #9
0
    def OnPaint(self, event):
        pdc = wx.PaintDC(self)
        mdc = wx.MemoryDC()
        bitmap = wx.EmptyBitmap(*self.GetSize())
        mdc.SelectObject(bitmap)

        rect = wx.RectS(self.GetSize())

        mdc.SetBrush(wx.WHITE_BRUSH)
        mdc.SetPen(wx.TRANSPARENT_PEN)

        mdc.DrawRectangleRect(rect)

        mdc.SetBrush(wx.Brush(wx.Color(*self.color)))

        mdc.SetPen(
            wx.Pen(
                wx.Color(self.color[0] / 2, self.color[1] / 2,
                         self.color[2] / 2), 1, wx.SOLID))

        mdc.DrawRoundedRectangleRect(rect, 5)
        mdc.SelectObject(wx.NullBitmap)
        #        image=Image.new('RGB',(bitmap.GetWidth(),bitmap.GetHeight()))
        #        image.fromstring(bitmap.ConvertToImage().GetData())
        #
        #        enhancer = ImageEnhance.Sharpness(image)
        #        image=enhancer.enhance(0)
        #
        #        wximage=wx.EmptyImage(*image.size)
        #        wximage.SetData(image.convert('RGB').tostring())

        #wx.BitmapFromBuffer(Image.string)
        pdc.DrawBitmap(bitmap, 0, 0)  #wximage.ConvertToBitmap(),0,0)
Exemple #10
0
    def LoadState(self):
        # Показывать ли номера строк?
        self.lineNumbers = configelements.BooleanElement(
            self.__config.lineNumbers, self.lineNumbersCheckBox)

        # Шрифт для редактора
        fontOption = FontOption(self.__config.fontName, self.__config.fontSize,
                                self.__config.fontIsBold,
                                self.__config.fontIsItalic)

        self.fontEditor = configelements.FontElement(fontOption,
                                                     self.fontPicker)

        # Размер табуляции
        self.tabWidth = configelements.IntegerElement(self.__config.tabWidth,
                                                      self.tabWidthSpin,
                                                      self.MIN_TAB_WIDTH,
                                                      self.MAX_TAB_WIDTH)

        if self.__config.homeEndKeys.value == 0:
            self.homeEndCombo.SetSelection(0)
        else:
            self.homeEndCombo.SetSelection(1)

        if StcStyle.checkColorString(self.__config.fontColor.value):
            self.fontColorPicker.SetColour(self.__config.fontColor.value)
        else:
            self.fontColorPicker.SetColour(wx.Color(0, 0, 0))

        if StcStyle.checkColorString(self.__config.backColor.value):
            self.backColorPicker.SetColour(self.__config.backColor.value)
        else:
            self.backColorPicker.SetColour(wx.Color(255, 255, 255))
    def PopulateList(self):

        x = 0
        for data in self.datamap:
            attr, val = data
            if attr == "Instance ID":
                self.list.InsertImageStringItem(x, attr, self.comp_bmp)
            elif attr == "InPort Attr.":
                self.list.InsertImageStringItem(x, attr, self.inp_bmp)
            elif attr == "OutPort Attr.":
                self.list.InsertImageStringItem(x, attr, self.outp_bmp)
            else:
                self.list.InsertImageStringItem(x, attr, self.blank_bmp)
            self.list.SetStringItem(x, 1, val)

            if attr == "InPort Attr.":
                print "InPort Attr."
                self.list.SetItemBackgroundColour(x,
                                                  wx.Color(0xdd, 0xdd, 0xdd))
            elif attr == "OutPort Attr.":
                print "OutPort Attr."
                self.list.SetItemBackgroundColour(x,
                                                  wx.Color(0xdd, 0xdd, 0xdd))
            x += 1

        # show how to select an item
        self.list.SetItemState(5, wx.LIST_STATE_SELECTED,
                               wx.LIST_STATE_SELECTED)

        self.currentItem = 0
Exemple #12
0
    def OnPaint(self, event):
        dc = wx.AutoBufferedPaintDC(self)
        rect = wx.RectS(self.Size)

        dc.Brush = wx.WHITE_BRUSH
        dc.Pen = wx.TRANSPARENT_PEN
        dc.DrawRectangleRect(rect)

        if rect.Contains(self.ScreenToClient(wx.GetMousePosition())):
            dc.Brush = wx.Brush(wx.Color(238, 239, 255))
            dc.Pen = wx.Pen(wx.Color(128, 128, 255))
            dc.DrawRoundedRectangleRect(rect, 4)
            if wx.GetMouseState().LeftDown():
                rect2 = rect.Deflate(5, 5)
                dc.Pen = wx.TRANSPARENT_PEN
                dc.Brush = wx.Brush(wx.Color(200, 200, 255))
                dc.DrawRectangleRect(rect2)

        if self.selected:
            rect2 = rect.Deflate(4, 4)
            dc.Pen = wx.TRANSPARENT_PEN
            dc.Brush = wx.Brush(wx.Color(128, 128, 255))
            dc.DrawRectangleRect(rect2)

        dc.DrawBitmap(self.bitmap, 8, 8, True)
Exemple #13
0
    def _init_text_controls(self, parent, sizer):
        self._text_static = wx.StaticText(parent=parent,
                                          id=wx.ID_ANY,
                                          label="Text")

        self._text_text = wx.TextCtrl(parent=parent,
                                      id=wx.ID_ANY,
                                      size=(self._default_width, -1),
                                      style=wx.TE_READONLY | wx.TE_MULTILINE)

        color_white = wx.Color(255, 255, 255)
        color_blue = wx.Color(0, 0, 128)

        self._image_static_bitmap.SetBackgroundColour(color_white)

        font = wx.Font(pointSize=14,
                       family=wx.FONTFAMILY_SWISS,
                       style=wx.FONTSTYLE_NORMAL,
                       weight=wx.FONTWEIGHT_NORMAL,
                       underline=False,
                       face="Verdana",
                       encoding=wx.FONTENCODING_SYSTEM)

        self._text_text.SetFont(font)
        self._text_text.SetForegroundColour(color_blue)
        self._text_text.SetBackgroundColour(color_white)

        sizer.Add(item=self._text_static)
        sizer.Add(item=self._text_text, flag=wx.EXPAND)

        self._set_current_row_growable(sizer)
Exemple #14
0
    def Draw(self, DC):
        print "In Draw"
        DC.SetBackground(wx.Brush("White"))
        DC.Clear()

        GC = wx.GraphicsContext.Create(DC)

        Pen = GC.CreatePen(wx.Pen("Black", 4))

        GC.SetPen(Pen)
        GC.DrawLines([(0, 0), (100, 100), (300, 100)])
        GC.SetPen(wx.TRANSPARENT_PEN)
        c1 = wx.Color(255, 0, 0, 255)
        c2 = wx.Color(255, 0, 0, 0)
        Brush = GC.CreateLinearGradientBrush(20, 150, 300, 150, c1, c2)
        GC.SetBrush(Brush)
        GC.DrawRectangle(20, 150, 200, 1)

        Path = GC.CreatePath()
        Path.MoveToPoint(0, 0)
        Path.AddLineToPoint(500, 300)
        Path.AddLineToPoint(500, 298)
        Path.AddLineToPoint(0, -2)

        GC.SetPen(wx.Pen("Blue", 3))
        #GC.SetBrush(wx.Brush("Red"))
        #GC.DrawPath(Path)
        Brush = GC.CreateLinearGradientBrush(-2, -2, 500, 300, c1, c2)
        GC.SetBrush(Brush)
        GC.FillPath(Path)
Exemple #15
0
 def draw_popup(self, dc, region=None):
     if self.popupTrendGraph != None:
         self.popupTrendGraph.Close(True)
         self.popupTrendGraph = None
         
     if len(self.selected_shape_ids) == 0:
         return
     
     selected_ids = []
     if self.layer.name in self.selected_shape_ids:
         selected_ids = self.selected_shape_ids[self.layer.name]
         
         
     self.popupTrendGraph = SubTrendGraph(
         self.parent, 
         self.layer, 
         [self.trendgraph_data, selected_ids, self.interval_labels, self.tick, self.time_gstar,self.time_gstar_z, self.t_neighbors]
         )
     self.popupTrendGraph.Hide()
   
     # start draw a popup within window
     if region:
         x,y = region[2],region[3]
     else:
         x,y = self.layer.centroids[selected_ids[0]][0]
         x,y = self.view.view_to_pixel(x,y)
         x,y = int(x),int(y)
     w = int(math.ceil(self.bufferWidth * 0.5))
     if w < 300: w = 300
     if w > 450: w = 450
     h = w * 0.7
     if x + w > self.bufferWidth: 
         if x - w > 0:
             x = x - w
         else:
             x = self.bufferWidth - w
     if y + h > self.bufferHeight: 
         if y - h > 0:
             y = y - h
         else:
             y = self.bufferHeight - h
     
     dc.SetPen(wx.TRANSPARENT_PEN)
     dc.SetBrush(wx.Brush(wx.Color(120,120,120,160)))
     dc.DrawRectangle(x+5,y+h, w, 5)
     dc.DrawRectangle(x+w,y+5, 5, h)
     dc.SetPen(wx.Pen(wx.Color(100,100,100,100)))
     dc.SetBrush(wx.TRANSPARENT_BRUSH)
     dc.DrawRectangle(x,y,w,h)
     
     self.popupTrendGraph.bufferWidth = w
     self.popupTrendGraph.bufferHeight = h
     self.popupTrendGraph.buffer = wx.EmptyBitmapRGBA(w,h,255,255,255,222)
     tmp_dc = wx.BufferedDC(None, self.popupTrendGraph.buffer)
     if not 'Linux' in stars.APP_PLATFORM \
        and 'Darwin' != stars.APP_PLATFORM:
         tmp_dc = wx.GCDC(tmp_dc)
     self.popupTrendGraph.DoDraw(tmp_dc)
     dc.DrawBitmap(self.popupTrendGraph.buffer,x,y)
Exemple #16
0
 def SetFormat(self, font, fgc, bgc):
     tc = self.tc
     tc.Font = font
     tc.SetFont(font)
     tc.ForegroundColour = wx.BLACK
     tc.ForegroundColour = wx.Color(*fgc)
     tc.BackgroundColour = wx.Color(*bgc)
     self.UpdateDisplay()
	def __init__(self, parent, client, server, mapdir):
		wx.Notebook.__init__(self, parent, -1, style=wx.BOTTOM|wx.RIGHT)
		self.SetBackgroundColour(wx.Color(0,0,128))
		self.SetForegroundColour(wx.Color(255,255,255))
		self.AddPage(BasicServerOptionsPanel(self, client, server, mapdir),
					 "Basic")
		self.AddPage(AdvancedServerOptionsPanel(self, client, server),
					 "Advanced")
    def __init__(self, *args, **kwargs):
        ct.CustomTreeCtrl.__init__(self, *args, **kwargs)

        self.SetBorderPen(wx.Pen((0, 0, 0), 0, wx.TRANSPARENT))
        self.EnableSelectionGradient(True)
        self.SetGradientStyle(True)
        self.SetFirstGradientColour(wx.Color(46, 46, 46))
        self.SetSecondGradientColour(wx.Color(123, 123, 123))
    def SetValue(self, signal):
        #v3print ( '************** PyPLOT')
        self.line = []
        SLEN = 0
        pp = 0
        # walk through all the input signals
        for i, Input in enumerate(self.Brick.In[1:]):
            if (Input != None) and (i < self.NCurve):
                #Signals, Signal_Attribs = Split_TIO_ARRAY ( Input )#, True )
                #v3print ( 'PyPlot', type(Input),len(Input) )
                Signals, Signal_Attribs = Analyze_TIO_Array(Input)
                #v3print ( 'PyPlot', type(Input),len(Input),type(Signals),len(Signals) )

                for s, Signal in enumerate(Signals):
                    #v3print ( 'PyPlot', type(Signal) )
                    SLEN = len(Signal)
                    if SLEN:
                        P = self.pointer[pp]
                        for x in range(SLEN):
                            self.curve[pp][P] = [P, Signal[x]]
                            P = (P + 1) % self.Nx
                        self.pointer[pp] = P
                        pp += 1

                        while len(self.Legends) <= pp:
                            self.Legends.append('Signal-' + str(pp))
                            self.Colors.append(wx.Color(0, 0, 0))
                            self.LineWidths.append(1)

                        if len(Signal_Attribs) > s:
                            """
              Legend = Signal_Attribs[s].Get ( 'Name', 'Signal-' + str(pp))
              Color  = Signal_Attribs[s].Get ( 'Color', (0,0,0) )
              Width  = Signal_Attribs[s].Get ( 'LineWidth', 1 )
              Color  = wx.Color ( *Color)
              """
                            self.Legends [pp] =\
                              Signal_Attribs[s].Get ( 'Name', 'Signal-' + str(pp))
                            self.Colors  [pp] =\
                              wx.Color ( *Signal_Attribs[s].Get ( 'Color', (0,0,0) ) )
                            self.LineWidths [pp] =\
                              Signal_Attribs[s].Get ( 'LineWidth', 1 )

                            #v3print ('TTTT',pp,len ( Signal_Attribs ),Color )
                            #self.line.append ( plot.PolyLine (
                            #  self.curve [i], legend = Legend, colour = Color, width = Width ))
                        else:
                            #self.line.append ( plot.PolyLine ( self.curve [i] ))
                            pass

                        self.line.append(
                            plot.PolyLine(self.curve[i],
                                          legend=self.Legends[pp],
                                          colour=self.Colors[pp],
                                          width=self.LineWidths[pp]))

        self.Canvas.Draw(plot.PlotGraphics(self.line), (0, self.Nx), (-10, 10))
        self.Canvas.SetShowScrollbars(False)
Exemple #20
0
    def on_paint(self, e):
        dc = wx.AutoBufferedPaintDC(self)
#        gc = wx.GraphicsContext.Create(dc)
        o = wx.Color(254,214,76) # skin!
        y = wx.Color(255,251,184)
        dc.SetPen(wx.Pen(o))
        dc.SetBrush(wx.Brush(y))
        dc.DrawPolygon(self.poly)
        self.draw_content(dc)
Exemple #21
0
    def drawNote(self, gcdc, node, level = 1):
        
            # nakresli poznamku ?
            if not node.getNote() or not self.control.isNodeCommented(node):
                return
            
            # ohraniceni
            (x, y, w, h) = self.control.getNodeBoundary(node)
                
            note, (note_w, note_h, note_dw, note_dh) = self.control.getNoteView(node)
            
            # nastaveni
            color = wx.Color(200, 200, 200)
            textcolor = wx.Color(150, 150, 150)
            
            lib.setFont(gcdc, -1)
            
            if level == 0 or level == 1 :
                
                # kresleni trojuhelniku
                pt1 = (x + w/2, y + h + 5)
                pt2 = (x + w/2 - 7, y + h + 10)
                pt3 = (x + w/2 + 7, y + h + 10)
                
                # kresleni obdelniku
                gcdc.SetBrush(wx.Brush(color))
                gcdc.DrawPolygon((pt1, pt2, pt3))
                gcdc.DrawRoundedRectangle(x, y + h + 10, note_w, note_h + note_dh, 10)
                
                gcdc.SetBrush(wx.Brush('WHITE'))
                d = 2
                gcdc.DrawRoundedRectangle(x + d, y + h + 10 + d, note_w -2*d, note_h + note_dh -2*d, 10)
                
                # kresleni textu
                gcdc.SetTextForeground(textcolor)
                gcdc.DrawLabel(note, wx.Rect(x  + note_dw/2, y + h + 10 + note_dh/2, 0, 0)) 
 
            else:
                
                # kresleni trojuhelniku
                pt1 = (x + 40, y + h - 5)
                pt2 = (x + 40 - 7, y + h)
                pt3 = (x + 40 + 7, y + h)
                
                # kresleni obdelniku
                gcdc.SetBrush(wx.Brush(color))
                gcdc.DrawPolygon((pt1, pt2, pt3))
                gcdc.DrawRoundedRectangle(x + 20, y + h, note_w + note_dw, note_h + note_dh/2, 10)
                
                gcdc.SetBrush(wx.Brush('WHITE'))
                d = 2
                gcdc.DrawRoundedRectangle(x + 20 + d, y + h + d, note_w + note_dw -2*d, note_h + note_dh/2 -2*d, 10)
                
                # kresleni textu
                gcdc.SetTextForeground(textcolor)
                gcdc.DrawLabel(note, wx.Rect(x + 20 + note_dw/2, y + h + note_dh/4, 0, 0)) 
Exemple #22
0
 def draw_space_in_buffer(self, space_shp, width=6000,height=6000):
     """
     Function for fast space-time query: how many points
     sit in each polygon
     """
     from stars.visualization.maps.BaseMap import PolygonLayer
     from stars.visualization.utils import View2ScreenTransform,DrawPurePoints
     # specify different color for each polygon
     poly_color_dict = {}
     n = len(space_shp)
     
     if n > 10000:
         width = 9000
         height = 9000
     
     id_group = []
     color_group = []
     color_range = 254*254*254 - 1
     used_color = {}
     for i in range(n):
         color_idx = random.randint(1,color_range)
         while color_idx in used_color: 
             color_idx = random.randint(1,color_range)
         used_color[color_idx] = True
         r = color_idx & 255
         g = (color_idx>>8) & 255
         b = (color_idx>>16) & 255
         id_group.append([i])
         color_group.append(wx.Color(r,g,b))
         poly_color_dict[(r,g,b)] = i
         
     # draw polygon to an empty_buffer
     polygon_layer = PolygonLayer(self, space_shp)
     polygon_layer.set_edge_color(wx.Color(0,0,0,0))
     polygon_layer.set_data_group(id_group)
     polygon_layer.set_fill_color_group(color_group)
     #polygon_layer.set_edge_color_group(color_group)
     
     view = View2ScreenTransform(space_shp.extent, width, height)
     buffer = wx.EmptyBitmap(width, height)
     dc = wx.BufferedDC(None, buffer)
     dc.Clear()
     polygon_layer.draw(dc, view, drawRaw=True)
     
     """
     _points = []
     for p in points: 
         x,y = view.view_to_pixel(p[0],p[1])
         x,y = int(round(x)), int(round(y))
         _points.append((x,y))
     DrawPurePoints(dc, _points)
     """
     bmp = wx.ImageFromBitmap(buffer)
     #buffer.SaveFile('test.bmp',wx.BITMAP_TYPE_BMP)
     return bmp,view,poly_color_dict
    def OnSetViewMode(self, mode):
        self.viewMode = mode
        if mode == 'static':
            self.SetBackgroundColour(wx.Color(*Config.backgroundColorStatic))
        elif mode == 'dynamic':
            self.SetBackgroundColour(wx.Color(*Config.backgroundColorDynamic))

        for id, shape in self.nodeShapes.items():
            shape.SetViewMode(mode)

        self.Refresh()
Exemple #24
0
    def stroke_highlights(self, gc, rect):
        hw = max(2, self.pen.Width)
        seq = []

        if self.highlight:
            c1, c2 = wx.Color(255, 255, 255, 100), wx.Color(255, 255, 255, 150)

            seq.extend([((rect.x, rect.y), [(rect.x, rect.Bottom),
                                            (rect.x + hw, rect.Bottom - hw),
                                            (rect.x + hw, rect.y + hw),
                                            (rect.x, rect.y)],
                         gc.CreateLinearGradientBrush(rect.x, rect.y,
                                                      rect.x + hw, rect.y, c1,
                                                      c2)),
                        ((rect.x, rect.y), [(rect.Right + 1, rect.y),
                                            (rect.Right - hw, rect.y + hw),
                                            (rect.x + hw, rect.y + hw),
                                            (rect.x, rect.y)],
                         gc.CreateLinearGradientBrush(rect.x, rect.y, rect.x,
                                                      rect.y + hw, c1, c2))])

        if self.shadow:
            sc1, sc2 = wx.Color(0, 0, 0, 50), wx.Color(0, 0, 0, 100)

            seq.extend([
                ((rect.Right + 1, rect.Bottom + 1), [
                    (rect.x, rect.Bottom + 1),
                    (rect.x + hw, rect.Bottom - hw + 1),
                    (rect.Right - hw + 1, rect.Bottom - hw + 1),
                    (rect.Right + 1, rect.Bottom + 1)
                ],
                 gc.CreateLinearGradientBrush(rect.x, rect.Bottom - hw + 1,
                                              rect.x, rect.Bottom + 1, sc1,
                                              sc2)),
                ((rect.Right + 1, rect.Bottom + 1),
                 [(rect.Right + 1, rect.y), (rect.Right - hw + 1, rect.y + hw),
                  (rect.Right - hw + 1, rect.Bottom - hw + 1),
                  (rect.Right + 1, rect.Bottom + 1)],
                 gc.CreateLinearGradientBrush(rect.Right - hw + 1, rect.Bottom,
                                              rect.Right + 1, rect.Bottom, sc1,
                                              sc2))
            ])

        if seq:
            for origin, pts, brush in seq:
                p = gc.CreatePath()
                p.MoveToPoint(*origin)
                for pt in pts:
                    p.AddLineToPoint(*pt)

                gc.SetBrush(brush)
                gc.FillPath(p)
Exemple #25
0
def GetRoundBitmap(w, h, r):
    maskColor = wx.Color(0, 0, 0)
    shownColor = wx.Color(5, 5, 5)
    b = wx.EmptyBitmap(w, h)
    dc = wx.MemoryDC(b)
    dc.SetBrush(wx.Brush(maskColor))
    dc.DrawRectangle(0, 0, w, h)
    dc.SetBrush(wx.Brush(shownColor))
    dc.SetPen(wx.Pen(shownColor))
    dc.DrawRoundedRectangle(0, 0, w, h, r)
    dc.SelectObject(wx.NullBitmap)
    b.SetMaskColour(maskColor)
    return b
Exemple #26
0
 def getColorConfig(self, section, option, default=[0, 0, 0, 0]):
     try:
         value = self.configIDE.get(section,option)
         value = value[1:-1].split(",")
         value = map(lambda x:int(x), value)
         color = wx.Color()
         color.Set(*value)
         return color
     except:
         color = wx.Color()
         color.Set(*default)
         self.setConfig(section, option, default)
         return color
Exemple #27
0
    def __init__(self, *args, **kwargs):
        #--call the super-class constructor--
        wx.Panel.__init__(self, *args, **kwargs)

        #--setup parent--
        self.parent = args[0]

        #--globals--
        global btn_playFilename
        global btn_stopFilename

        #--set background color--
        self.SetBackgroundColour("BLACK")

        #--buttons--
        #play button
        self.btn_play = wx.BitmapButton(self,
                                        id=wx.ID_ANY,
                                        bitmap=wx.Bitmap(btn_playFilename),
                                        size=(80, 80))
        self.btn_play.SetBackgroundColour(wx.Color(0, 0, 128))
        self.btn_play.Bind(wx.EVT_BUTTON, self.onClick_play)
        self.btn_play.SetToolTip(wx.ToolTip("Play"))

        #stop button
        self.btn_stop = wx.BitmapButton(self,
                                        id=wx.ID_ANY,
                                        bitmap=wx.Bitmap(btn_stopFilename),
                                        size=(80, 80))
        self.btn_stop.SetBackgroundColour(wx.Color(0, 0, 128))
        self.btn_stop.Bind(wx.EVT_BUTTON, self.onClick_stop)
        self.btn_stop.SetToolTip(wx.ToolTip("Stop"))
        self.btn_stop.Disable()  #disable to start with

        #--now playing label--
        self.nowPlayingDisplay = wx.StaticText(self,
                                               id=wx.ID_ANY,
                                               style=wx.SIMPLE_BORDER
                                               | wx.EXPAND,
                                               label="")
        self.nowPlayingDisplay.SetForegroundColour(wx.Color(0, 0, 255))

        #--add sizer--
        sizer = wx.BoxSizer(wx.HORIZONTAL)
        sizer.Add(self.btn_play, 0, wx.ALL, 10)
        sizer.Add(self.btn_stop, 0, wx.ALL, 10)
        sizer.Add(self.nowPlayingDisplay, 1, wx.ALL, 10)
        self.SetSizer(sizer)
        self.Fit()

        return
Exemple #28
0
 def BrushForNode(self, node, depth=0):
     """Create brush to use to display the given node"""
     if node == self.selectedNode:
         color = wx.SystemSettings_GetColour(wx.SYS_COLOUR_HIGHLIGHT)
     elif node == self.highlightedNode:
         color = wx.Color(red=0, green=255, blue=0)
     else:
         color = self.adapter.background_color(node, depth)
         if not color:
             red = (depth * 10) % 255
             green = 255 - ((depth * 10) % 255)
             blue = 200
             color = wx.Color(red, green, blue)
     return wx.Brush(color)
Exemple #29
0
    def OnPaint(self, evt):
        dc = wx.AutoBufferedPaintDC(self)
        o = wx.Color(254, 214, 76)
        y = wx.Color(255, 251, 184)

        dc.SetPen(wx.Pen(o))
        dc.SetBrush(wx.Brush(y))

        dc.DrawPolygon(self.GetPolyPoints())
        self.DrawContent(dc)

        dc.SetFont(self.GetFont())
        textSize = wx.Size(dc.GetTextExtent(self._labelText))
        dc.DrawText(self._labelText, 10,
                    (self.GetSize().y - textSize.y) / 2 - 5)
Exemple #30
0
def get_social_css():
    import wx
    minor_color = get('infobox.fontcolors.minor', lambda: wx.Color(128, 128, 128)).GetAsString(wx.C2S_HTML_SYNTAX)
    postrow_hover_color =  get('infobox.backgrounds.socialhovercolor', lambda: wx.Color(128, 128, 128)).GetAsString(wx.C2S_HTML_SYNTAX)
    return '''
.minor_border {{
    border-color: {minor_color};
}}
.social_background_hover:hover {{
    background-color: {postrow_hover_color};
}}
.social_background_hover_on {{
    background-color: {postrow_hover_color};
}}
'''.format(**locals())