Ejemplo n.º 1
0
 def test_value_init(self):
     bitmap = Bitmap(value=10)
     self.assertEqual(len(bitmap), 4)
     self.assertEqual(bitmap.value, 10)
     bitmap = Bitmap(size=0, value=14)
     self.assertEqual(len(bitmap), 4)
     self.assertEqual(bitmap.value, 14)
Ejemplo n.º 2
0
 def test_flip_bit(self):
     bitmap = Bitmap(value=10)
     bitmap.flip_bit(2)
     bitmap.flip_bit(1)
     self.assertEqual(bitmap.get_bit(2), 1)
     self.assertEqual(bitmap.get_bit(1), 0)
     self.assertEqual(bitmap.value, 12)
Ejemplo n.º 3
0
def handleBitmap(x, convertBitmap):
    """Handling AfterUnpack & BeforePack functionality"""

    if not isinstance(x, Bitmap) or (isinstance(x, Bitmap) and convertBitmap):
        x = Bitmap(x)
    if convertBitmap:
        x.bytereverse()
    return x
def load_bitmap(file) :
    words = open(file).readlines()
    words = map(lambda x: x.strip(), words)
    bmap  = Bitmap(2**20)
    for word in words :
        hashes = make_hashes(word)
        for hash in hashes :
            bmap.setBit(hash)
    return bmap
Ejemplo n.º 5
0
    def test_instantination(self):
        self.assertRaises(BaseException, Bitmap, ())
        self.assertRaises(BaseException, Bitmap, ('s', ))
        self.assertRaises(BaseException, Bitmap, (1, ))

        self.assertIsInstance(Bitmap(0), Bitmap)  # int
        self.assertIsInstance(Bitmap(Bitmap(8)), Bitmap)  # Bitmap
        self.assertIsInstance(Bitmap(bytes(2)), Bitmap)  # bytes,
        self.assertIsInstance(Bitmap(bytearray(2)), Bitmap)  # bytearray
Ejemplo n.º 6
0
def loadBitmap(file) :
    # generate bitmap from lexicon file (one word per line)
    words = open(file).readlines()
    words = map(lambda x: x.strip(), words) # no newlines please
    bmap  = Bitmap(2**20)
    for word in words :
        hashes = makeHashes(word)
        for hash in hashes :
            bmap.setBit(hash)
    return bmap
Ejemplo n.º 7
0
 def test_invalid_size(self):
     with self.assertRaises(TypeError):
         _ = Bitmap(size=7.0)  # type: ignore
     with self.assertRaises(TypeError):
         _ = Bitmap(size='0b111')  # type: ignore
     with self.assertRaises(TypeError):
         _ = Bitmap(size=[7])  # type: ignore
     # size < len(bin(value))
     with self.assertRaises(ValueError):
         _ = Bitmap(size=3, value=10)
Ejemplo n.º 8
0
def loadBitmap(file):
    # generate bitmap from lexicon file (one word per line)
    words = open(file).readlines()
    words = map(lambda x: x.strip(), words)  # no newlines please
    bmap = Bitmap(2**20)
    for word in words:
        hashes = makeHashes(word)
        for hash in hashes:
            bmap.setBit(hash)
    return bmap
Ejemplo n.º 9
0
    def get_bitmap(self, path):
        if path in self.resources["bitmap"]:
            return self.resources["bitmap"][path]

        self.update_times[path] = time.time()

        bitmap = Bitmap()
        bitmap._load(path)

        self.resources["bitmap"][path] = bitmap

        return bitmap
Ejemplo n.º 10
0
def string_bitmap(text):
    """
    Like char_bitmap() but takes a string and returns a bitmap of the entire word.

    The resulting width will by len(text) * 8, and height 7.
    
    See bitmap.py
    """
    bm = Bitmap(WIDTH * len(text), HEIGHT)
    for i, char in enumerate(text):
        bm.apply(char_bitmap(char), x=i * WIDTH, y=0)
    return bm
Ejemplo n.º 11
0
 def __init__(self, width, height):
     super(Desktop, self).__init__(
         0, 0, width, height,
         WND_ONLY_CLIENT | WND_KEEP_BOTTOM | WND_KEEP_INACTIVE)
     self.im = Bitmap('img/cheetah.png')
     dirname = 'img/desktop-icons'
     self.icons = [
         Bitmap(os.path.join(dirname, fname)).scaledToWidth(ICON_SIZE)
         for fname in os.listdir(dirname) if fname.startswith('icon-')
     ]
     self.proc_names = ['pa', 'pb', 'pc']
     self.cur_icon = None
     self.wnds = []
Ejemplo n.º 12
0
def char_bitmap(char):
    """
    Given a single character, generate a Bitmap of that font. This will be width 8, height 7.
    
    See bitmap.py
    """
    char_def = DATA.get(char, DATA[FALLBACK_CHAR])
    assert len(
        char_def) == WIDTH * HEIGHT, "bad char definition for char '%s'" % char
    bm = Bitmap(WIDTH, HEIGHT)
    for y in range(HEIGHT):
        for x in range(WIDTH):
            bm.data[y][x] = 0 if char_def[x + (y * WIDTH)] == ' ' else 1
    return bm
Ejemplo n.º 13
0
    def test_overloaded_ctor(self):
        b = Bitmap(0x0FF0F0)
        self.assertTrue(b)
        bitset = b.get_bitmap_as_indices()
        self.assertTrue(len(bitset) == 12)

        i = 0
        for j in range(4, 8):
            self.assertEqual(bitset[i], j)
            i += 1

        for j in range(12, 20):
            self.assertEqual(bitset[i], j)
            i += 1
Ejemplo n.º 14
0
    def __init__(self, video_mem, qt_callback):
        self.qcommunicate = QCommunicate()
        self.qcommunicate.signal.connect(qt_callback)
        self.video_mem = video_mem
        self.screen = Bitmap(SCREEN_WIDTH, SCREEN_HEIGHT)
        self.wnds = []

        self.dragging_wnd = None

        self.windows_change_listener = []

        self.mouse_img = im = Bitmap('img/mouse.png')
        self.mouse_x = 0
        self.mouse_y = 0
Ejemplo n.º 15
0
 def test_invalid_i(self):
     bitmap = Bitmap(size=10, value=10)
     with self.assertRaises(TypeError):
         _ = bitmap.get_bit(2.0)  # type: ignore
     with self.assertRaises(TypeError):
         bitmap.set_bit('0b0010')  # type: ignore
     with self.assertRaises(TypeError):
         bitmap.clear_bit([2])  # type: ignore
     # i < 0
     with self.assertRaises(ValueError):
         bitmap.flip_bit(-1)
     # i >= size
     with self.assertRaises(ValueError):
         _ = bitmap.get_bit(10)
Ejemplo n.º 16
0
     def __init__(self,image=None,**params):
          super(Plot,self).__init__(**params)
          self._orig_bitmap = Bitmap(image)
          self.bitmap = self._orig_bitmap # Possibly scaled copy (at first identical)
          self.scale_factor=1.0
          self.plot_src_name = ''
          self.precedence = 0.0
          self.row_precedence = 0.5
          # If False, this plot should be left in its native size
          # pixel-for-pixel, (e.g. for a color key or similar static
          # image), rather than being resized as necessary.
          self.resize=False

          # Time at which the bitmaps were created
          self.timestamp = -1
Ejemplo n.º 17
0
 def test_invalid_v(self):
     bitmap = Bitmap(value=10)
     with self.assertRaises(ValueError):
         bitmap.update_bit(2, 2)
     with self.assertRaises(ValueError):
         bitmap.update_bit(1, None)  # type: ignore
     with self.assertRaises(ValueError):
         bitmap.update_bit(0, '1')  # type: ignore
Ejemplo n.º 18
0
    def create_bitmap(
        self,
        offset: int,
        row_width: int,
        start_column: int,
        start_row: int,
        visible_rows: int,
        visible_columns: int,
    ) -> Optional[Bitmap]:
        if self._data is None:
            return

        start = start_row * row_width + start_column + offset
        num_rows = min(ceil(
            (self.num_bits - start) / row_width), visible_rows + 1) - 1
        bits_per_row = min(row_width, visible_columns)
        bytes_per_row = ceil(bits_per_row / 8)
        mask = 2**(bytes_per_row * 8) - 1
        result = bytearray()
        for _ in range(num_rows):
            result.extend(self._get_row_bytes(start, bytes_per_row, mask))
            start += row_width
        remainder = []
        last_byte = start // 8 + bytes_per_row
        if last_byte < len(self._data):
            result.extend(self._get_row_bytes(start, bytes_per_row, mask))
        else:
            remainder = self._get_end_bits(start)
        return Bitmap(result, bits_per_row, bytes_per_row, remainder)
Ejemplo n.º 19
0
    def __init__( self, parent):
        HubSimulFrame.__init__( self, parent )
        
        
        panel = self.panelRawBitmap
        sizer = panel.GetSizer()    
        self.bitmap = Bitmap(panel,Bitmap.width,Bitmap.height) 
        sizer.Add( self.bitmap, 1, wx.EXPAND )
        
        # start listeneing on port 1234
        factory = ParserFactory()
        server = HubSimulServer(factory)
        self.protocol = HubProtocol(server)
        self.protocol.addListener(self)


        self.alive = threading.Event()
        self.event = None

        self.hubs = []

        for i in range (HubSimulControl.HubCount):
            hub = HubSimul(i,self.protocol)
            self.hubs.append(hub)
                    
        self.startThread()
Ejemplo n.º 20
0
    def __init__(self, x, y, mode, fileName, scene, parent=None):
        super(AddItemCommand, self).__init__(parent)

        from designerscene import DesignerScene
        from rectangle import Rectangle
        from ellipse import Ellipse
        from text import Text
        from bitmap import Bitmap
        from vectorgraphic import Vectorgraphic
        self.scene = scene
        self.item = None

        if mode == DesignerScene.RECTANGLE:
            self.item = Rectangle(self.scene)
            self.item.setId("Rectangle")
            self.item.setPen(QPen(Qt.black))
            self.item.setBrush(QBrush(Qt.blue))
            self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
            self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
            self.item.setPos(x, y)
            self.item.setWidth(50)
            self.item.setHeight(50)
            self.setText("Add Rectangle")

        elif mode == DesignerScene.ELLIPSE:
            self.item = Ellipse(self.scene)
            self.item.setId("Ellipse")
            self.item.setPen(QPen(Qt.black))
            self.item.setBrush(QBrush(Qt.blue))
            self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
            self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
            self.item.setPos(x, y)
            self.item.setWidth(50)
            self.item.setHeight(50)
            self.setText("Add Ellipse")

        elif mode == DesignerScene.TEXT:
            self.item = Text("Lorem ipsum dolor", self.scene)
            self.item.setId("Text")
            self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
            self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
            self.item.setPos(x, y)
            self.setText("Add Text")

        elif mode == DesignerScene.BITMAP:
            self.item = Bitmap(fileName, self.scene)
            self.item.setId("Bitmap")
            self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
            self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
            self.item.setPos(x, y)
            self.setText("Add Bitmap")

        elif mode == DesignerScene.SVG:
            self.item = Vectorgraphic(fileName, self.scene)
            self.item.setId("Vectorgraphic")
            self.item.setFlag(QGraphicsItem.ItemIsMovable, True)
            self.item.setFlag(QGraphicsItem.ItemIsSelectable, True)
            self.item.setPos(x, y)
            self.setText("Add Vectorgraphic")
Ejemplo n.º 21
0
def getfile(event, new_file, parent):
    #print(event)
    printk("getfile('%s')" % event.filename)
    new_file.med_oact = Bitmap(b'\xff\xff')
    new_file.update()
    print(event.filename)
    print(new_file)
    return MED_OK
Ejemplo n.º 22
0
 def __init__(self, wnd, gui):
     self.init(wnd.x(), wnd.y(), wnd.width(), wnd.height(), wnd.attr(),
               wnd.border_width(), wnd.caption_height())
     self.wnd = wnd
     self.gui = gui
     bitmap = Bitmap(wnd.window_width(), wnd.window_height())
     self.bitmap = wnd.bitmap = bitmap
     self.dragging = False
Ejemplo n.º 23
0
def _process_balance_rq(transaction_data):
    transaction_data['bitmap'] = Bitmap.balance_rs()
    transaction_data['transaction_id'] = action_codes['balance']

    card = database.get_card(transaction_data['PAN'])

    transaction_data['amount'] = Transaction.format_amount(card.balance)
    return _process_accepted_and_implemented(transaction_data)
Ejemplo n.º 24
0
def getprocess(event, parent):
    if parent.gid == 0:
        printk("getprocess: parent gid ROOT")
    else:
        printk("getprocess: change parent gid %d of '%s' to ROOT" % (parent.gid, parent.cmdline))
        parent.gid = 0
    parent.med_oact = Bitmap(16)
    parent.med_oact.fill()
    parent.med_sact = Bitmap(16)
    parent.med_sact.fill()
    parent.update()
    print(parent)

    tmp = Process()
    print(tmp)

    #print(event)
    #print(parent)
    return MED_OK
Ejemplo n.º 25
0
 def __init__( self, parent,remote):
     """ remote is instance of HubProtocol for communication with remote"""
     PanelProxy.__init__( self, parent )
     self.remote = remote
     print 'ProxyControl constructor  '
     self.scaleX = 1
     self.scaleY = 1
     self.server = None
     ProxyControl.instance = self
     self.bitmap = Bitmap(FanbotConfig.width,FanbotConfig.height)
     self.Refresh()
Ejemplo n.º 26
0
 def read_bitmaps(self, bitmapIDs):
     for i in range(self.numBitmapRecords):
         bitmap = Bitmap(self.filePath, self.offset)
         if bitmap.filename not in bitmapIDs:
             self.bitmaps.append(bitmap)
             bitmapIDs.add(bitmap.filename)
         self.offset = bitmap.offset
     # assert(self.bitmaps[-1].endIndex == self.numImageRecords)
     if self.bitmaps[-1].endIndex != self.numImageRecords:
         warning(
             f"endIndex ({self.bitmaps[-1].endIndex}) did not match numImageRecords ({self.numImageRecords})"
         )
Ejemplo n.º 27
0
def _process_test_rq(transaction_data):
    """ Handle TO, create session for terminal or
    respond with '00' if one created earlier """

    terminal_id = transaction_data['terminal_id']
    session = database.get_session(terminal_id)
    if session is None:
        database.post_session(Session(terminal_id))

    transaction_data['bitmap'] = Bitmap.test_rs()
    transaction_data['transaction_id'] = action_codes['test']
    return _process_accepted_and_implemented(transaction_data)
Ejemplo n.º 28
0
def Save_im():
    global im_choose, imtk, lb2, lb7, save_str
    im_save = Bitmap(512, 512)
    im_save.setPixel(np.uint8(im_choose))
    im_save.write(save_str)
    lb7 = tk.Label(window, text = '- Done saving bmp -',
               width=20, height=1).place(x = 362, y = 60)
Ejemplo n.º 29
0
def get_bitmap_of_circles_on_AABB(size_in_bits, center, step, poss, rad):

    corner = bitmap_corner_from_center(center, size_in_bits, step)
    bitmap = Bitmap(None, size_in_bits, corner, step)
    is_circle = bitmap.bits

    rad_in_bits = math.ceil(rad * bitmap.inv_step)

    for circle_index in range(len(poss)):
        circle_center = poss[circle_index]
        bit_center = bitmap.indices_from_pos(circle_center)

        for dx in range(-rad_in_bits, rad_in_bits + 1):
            for dy in range(-rad_in_bits, rad_in_bits + 1):

                bit_pos = vec_add(bit_center, (dx, dy))
                if not bitmap.are_indices_in_bounds(bit_pos):
                    continue  # `bit_pos` isn't in bitmap.

                corner_a, corner_b = bitmap.get_bit_corners(bit_pos)
                is_touching = is_circle_touching_AABB(bit_center, rad_in_bits,
                                                      corner_a, corner_b)
                bit_index = bitmap.index_from_indices(bit_pos)
                is_circle[bit_index] = (is_circle[bit_index] or is_touching)
    return bitmap
Ejemplo n.º 30
0
 def test_invalid_value(self):
     bitmap = Bitmap(size=10, value=10)
     with self.assertRaises(TypeError):
         bitmap.value = 7.0  # type: ignore
     with self.assertRaises(TypeError):
         bitmap.value = '0b111'  # type: ignore
     with self.assertRaises(TypeError):
         bitmap.value = [7]  # type: ignore
     # value < 0
     with self.assertRaises(ValueError):
         bitmap.value = -1
     # value >= (1 << size)
     with self.assertRaises(ValueError):
         bitmap.value = 1024
     with self.assertRaises(TypeError):
         _ = Bitmap(value=(10, ))  # type: ignore
Ejemplo n.º 31
0
def line(x0, y0, x1, y1, image: Bitmap, color):
    steep = False
    if abs(x0 - x1) < abs(y0 - y1):
        x0, y0 = y0, x0
        x1, y1 = y1, x1
        steep = True
    if x0 > x1:
        x0, x1 = x1, x0
        y0, y1 = y1, y0
    dx = x1 - x0
    dy = y1 - y0
    d_error = abs(dy) * 2
    error = 0
    y = y0
    for x in range(x0, x1 + 1):
        if steep:
            image.set_rgb_pixel(y, x, color.r, color.g, color.b)
        else:
            image.set_rgb_pixel(x, y, color.r, color.g, color.b)
        error += d_error
        if error > dx:
            y += 1 if y1 > y0 else -1
            error -= dx * 2
Ejemplo n.º 32
0
def _process_refund_rs(transaction_data):
    transaction_data['bitmap'] = Bitmap.sale_rs()
    terminal_id = transaction_data['terminal_id']

    card = database.get_card(transaction_data['PAN'])
    amount = transaction_data['amount']
    refund_amount = int(amount[:-2]) + float(amount[-2:]) / 100

    session = database.get_session(terminal_id)
    session.add_refund(refund_amount)
    card.deposit(refund_amount)
    database.save_state()

    transaction_data['transaction_id'] = action_codes['refund']
    return _process_accepted_and_implemented(transaction_data)
Ejemplo n.º 33
0
     def __init__(self,image=None,**params):
          super(Plot,self).__init__(**params)
          self._orig_bitmap = Bitmap(image)
          self.bitmap = self._orig_bitmap # Possibly scaled copy (at first identical)
          self.scale_factor=1.0
          self.plot_src_name = ''
          self.precedence = 0.0
          self.row_precedence = 0.5
          # If False, this plot should be left in its native size
          # pixel-for-pixel, (e.g. for a color key or similar static
          # image), rather than being resized as necessary.
          self.resize=False

          # Time at which the bitmaps were created
          self.timestamp = -1
Ejemplo n.º 34
0
def _process_settlement_rq(transaction_data):
    transaction_data['bitmap'] = Bitmap.settlement_rs()
    transaction_data['transaction_id'] = action_codes['settlement']

    terminal_id = transaction_data['terminal_id']
    text_data = transaction_data['text_data']

    session = database.get_session(terminal_id)
    session_text_data = Transaction._format_text_data(session.sales_count,
                                                      session.sales_amount,
                                                      session.refund_count,
                                                      session.refund_amount)
    if session_text_data != text_data:
        _process_revision_error(transaction_data)

    _process_accepted_and_implemented(transaction_data)
Ejemplo n.º 35
0
def _process_sale_rq(transaction_data):
    transaction_data['bitmap'] = Bitmap.sale_rs()
    terminal_id = transaction_data['terminal_id']

    card = database.get_card(transaction_data['PAN'])
    amount = transaction_data['amount']
    sell_amount = int(amount[:-2]) + float(amount[-2:]) / 100

    if card.balance < sell_amount:
        return _process_insufficient_funds(transaction_data)

    session = database.get_session(terminal_id)
    session.add_sell(sell_amount)
    card.buy(sell_amount)
    database.save_state()

    transaction_data['transaction_id'] = action_codes['sale']
    return _process_accepted_and_implemented(transaction_data)
Ejemplo n.º 36
0
    def __init__( self, parent):
        PanelDrawIcon.__init__( self, parent )
        print 'DesignControl constructor  '

        self.brush = '1'
        self.drawMode = 0  
        self.brushColor = 0xFFFF;
        self.scaleX = 1
        self.scaleY = 1
        self.bitmap = Bitmap(FanbotConfig.width,FanbotConfig.height)
        self.pointCurrent = wx.Point(0,0)
        self.pointStartDrag = None
        self.pointEndDrag = None
        self.mousePoint = (0,0)
        self.panelIconCanvasOnSize(None)
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.timerAnimate, self.timer)
        self.animateIdx = 0
        self.initFileList()
Ejemplo n.º 37
0
def parse(transaction):
    bitmap = Bitmap.unhexlify(transaction[:version.BITMAP_LENGTH])
    fields = _get_transaction_fields(bitmap)
    transaction_data = {}

    # First of all, parse cardholder_name (if presented)
    # because its length will affect other fields
    if 4 in fields:
        transaction_data['cardholder_name'] = _get_cardholder_name(
            fields, transaction)

    # Mandatory fields
    transaction_data.update({
        'transaction_id':
        _get_transaction_id(fields, transaction),
        'terminal_id':
        _get_terminal_id(fields, transaction),
        'datetime':
        _get_datetime(fields, transaction),
        'CRC':
        _get_CRC(fields, transaction)
    })

    # Optional fields
    if 3 in fields:
        transaction_data['PAN'] = _get_PAN(fields, transaction)
    if 5 in fields:
        transaction_data['expiry_date'] = _get_expiry_date(fields, transaction)
    if 6 in fields:
        transaction_data['PIN'] = _get_PIN(fields, transaction)
    if 7 in fields:
        transaction_data['amount'] = _get_amount(fields, transaction)
    if 8 in fields:
        transaction_data['transaction_no'] = _get_transaction_no(
            fields, transaction)
    if 9 in fields:
        transaction_data['RRN'] = _get_RRN(fields, transaction)
    if 10 in fields:
        transaction_data['text_data'] = _get_text_data(fields, transaction)

    return transaction_data
Ejemplo n.º 38
0
    def __init__(self, parent, remote):
        """ remote is instance of HubProtocol for communication with remote"""
        PanelModules.__init__(self, parent)
        ControlBase.__init__(self)
        self.remote = remote
        self.scaleX = 1
        self.scaleY = 1
        self.drawMode = 0
        self.hubList = hubs.HubListModel(self.scrolledWindowHubs, self)
        listHubsSizer = wx.BoxSizer(wx.VERTICAL)
        listHubsSizer.Add(self.hubList, 1, wx.ALL | wx.EXPAND, 5)
        self.scrolledWindowHubs.SetSizer(listHubsSizer)
        listHubsSizer.Fit(self.scrolledWindowHubs)

        self.fanbotList = hubs.FanbotListModel(self.scrolledWindowFanbots, self)
        listFanbotsSizer = wx.BoxSizer(wx.VERTICAL)
        listFanbotsSizer.Add(self.fanbotList, 1, wx.ALL | wx.EXPAND, 5)
        self.scrolledWindowFanbots.SetSizer(listFanbotsSizer)
        listFanbotsSizer.Fit(self.scrolledWindowFanbots)

        self.pointCurrent = wx.Point(0, 0)
        self.pointPrevious = wx.Point(0, 0)
        self.currenthub = None

        self.compressedFrame = array.array("B", [0] * 125)

        self.bitmap = Bitmap(FanbotConfig.width, FanbotConfig.height)
        self.bitmap.clear()

        for hub in self.hubList.hubs:
            self.showHub(hub)

        self.timerAnimate = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.timerAnimateHandler, self.timerAnimate)
        self.animateIdx = 0

        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.timerDiscover, self.timer)
        self.timerDiscoverCount = 0
Ejemplo n.º 39
0
    def test_is_bit_set(self):
        b = Bitmap(0xAAAAAAAA55555555)
        bitset = b.get_bitmap_as_indices()

        for i in range(64):
            if (i < 32):
                if (i % 2):
                    self.assertFalse(b.is_bit_set(i))
                else:
                    self.assertTrue(b.is_bit_set(i))
            else:
                if (i % 2):
                    self.assertTrue(b.is_bit_set(i))
                else:
                    self.assertFalse(b.is_bit_set(i))

        self.assertRaises(TooDamnMuchDammitError, b.is_bit_set, 1024)
Ejemplo n.º 40
0
class ModulenControl(PanelModules, ControlBase):
    def __init__(self, parent, remote):
        """ remote is instance of HubProtocol for communication with remote"""
        PanelModules.__init__(self, parent)
        ControlBase.__init__(self)
        self.remote = remote
        self.scaleX = 1
        self.scaleY = 1
        self.drawMode = 0
        self.hubList = hubs.HubListModel(self.scrolledWindowHubs, self)
        listHubsSizer = wx.BoxSizer(wx.VERTICAL)
        listHubsSizer.Add(self.hubList, 1, wx.ALL | wx.EXPAND, 5)
        self.scrolledWindowHubs.SetSizer(listHubsSizer)
        listHubsSizer.Fit(self.scrolledWindowHubs)

        self.fanbotList = hubs.FanbotListModel(self.scrolledWindowFanbots, self)
        listFanbotsSizer = wx.BoxSizer(wx.VERTICAL)
        listFanbotsSizer.Add(self.fanbotList, 1, wx.ALL | wx.EXPAND, 5)
        self.scrolledWindowFanbots.SetSizer(listFanbotsSizer)
        listFanbotsSizer.Fit(self.scrolledWindowFanbots)

        self.pointCurrent = wx.Point(0, 0)
        self.pointPrevious = wx.Point(0, 0)
        self.currenthub = None

        self.compressedFrame = array.array("B", [0] * 125)

        self.bitmap = Bitmap(FanbotConfig.width, FanbotConfig.height)
        self.bitmap.clear()

        for hub in self.hubList.hubs:
            self.showHub(hub)

        self.timerAnimate = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.timerAnimateHandler, self.timerAnimate)
        self.animateIdx = 0

        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.timerDiscover, self.timer)
        self.timerDiscoverCount = 0

    def buttonResetDiscOnButtonClick(self, event):
        self.remote.sendCommand(HubProtocol.RESET)
        self.hubList.resetDiscovery()

    def buttonDiscoverOnButtonClick(self, event):
        self.remote.sendCommand(HubProtocol.REQUEST_ID)
        self.timer.Start(2000)
        self.timerDiscoverCount = 2
        self.sendMessage("Discover module. Even geduld aub... ")

    def timerDiscover(self, event):
        if self.timerDiscoverCount == 0:
            self.timer.Stop()

        else:
            self.timerDiscoverCount -= 1
            self.remote.sendCommand(HubProtocol.REQUEST_ID)
            self.hubList.refresh()

    def buttonClearListOnButtonClick(self, event):
        self.listModules.Clear()

    def buttonResetConfigOnButtonClick(self, event):
        if self.currenthub:
            self.resetHub(self.currenthub)
            self.remote.sendConfig(self.currenthub.idAsArray(), self.currenthub.config)

    def buttonSetConfigOnButtonClick(self, event):
        if self.currenthub:
            hub = self.currenthub
            print "buttonSetConfigOnButtonClick, currenthub: ", hub.id
            self.remote.sendConfig(hub.idAsArray(), hub.config)

    def buttonSetConfigAllOnButtonClick(self, event):
        print "buttonSetConfigAllButtonClick"
        for hub in self.hubList.hubs:
            self.remote.sendConfig(hub.idAsArray(), hub.config)
            time.sleep(0.100)

    def panelModulesCanvasOnSize(self, event):
        rect = self.panelModulesCanvas.GetRect()

        self.scaleX = rect.GetWidth() / self.bitmap.width
        self.scaleY = rect.GetHeight() / self.bitmap.height
        # print 'Scale x:y',self.scaleX,':',self.scaleY
        self.Refresh()

    def panelModulesCanvasOnPaint(self, event):
        dc = wx.PaintDC(self.panelModulesCanvas)
        dc.BeginDrawing()
        dc.SetUserScale(self.scaleX, self.scaleY)
        dc.Clear()
        dc.DrawBitmap(self.bitmap.getBitmap(), 0, 0)
        dc.EndDrawing()

    def panelModulesCanvasOnMouseEvents(self, event):
        point = None
        canvas = self.panelModulesCanvas
        if event:
            # set mouse cursor
            canvas.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
            # get device context of canvas
            dc = wx.ClientDC(canvas)
            dc.SetUserScale(self.scaleX, self.scaleY)

            point = event.GetLogicalPosition(dc)
            if point.x < 0 or point.x >= FanbotConfig.width or point.y < 0 or point.y >= FanbotConfig.height:
                # print 'x,y out of bounds: ',point.x ,':',point.y
                return
            if self.checkBoxMatrix.IsChecked():
                """ set the snapto grid to horizontal 4 and vertical 6"""
                point.x /= 4
                point.x *= 4
                point.y /= 6
                point.y *= 6

            self.labelPosition.SetLabel("%s : %s" % (point.x, point.y))
            self.pointCurrent = point
            # print "mouse event X : " ,point.x , " Y: ",point.y

        if event.LeftDown():
            self.panelModulesCanvas.Refresh()
            self.pointPrevious = self.pointCurrent
            if self.checkBoxMatrix.IsChecked():
                self.matrixHubConfig(point.x, point.y)
            else:
                self.updateHubConfig(point.x, point.y)

        elif event.LeftIsDown() and not self.checkBoxMatrix.IsChecked():
            if self.pointPrevious.x == self.pointCurrent.x and self.pointPrevious.y == self.pointCurrent.y:
                return
            self.pointPrevious = self.pointCurrent
            # print "Dragging to X : " ,point.x , " Y: ",point.y
            cur = wx.StockCursor(wx.CURSOR_CROSS)
            canvas.SetCursor(cur)
            self.updateHubConfig(point.x, point.y)

    def updateHubConfig(self, x, y):
        hub = self.currenthub
        if hub:
            if hub.canAddConfigItem():
                if self.bitmap.pixelSetWhite(x, y):
                    hub.setConfig(x, y)
                    self.panelModulesCanvas.Refresh()

    def matrixHubConfig(self, x, y):
        hub = self.currenthub
        if hub:
            if hub.canAddConfigItem():
                hub.resetConfig()
                for y in range(self.pointCurrent.y, self.pointCurrent.y + 6):
                    for x in range(self.pointCurrent.x, self.pointCurrent.x + 4):
                        self.bitmap.pixelSetWhite(x, y)
                        self.currenthub.setConfig(x, y)
                        self.panelModulesCanvas.Refresh()

    def handleCommand(self, opcode, payload):
        """ Handle incoming data from remote hubs or hubsimulator"""
        print "Modulen: Received opcode: %04x -- %s" % (opcode, payload)

        id = ""
        if len(payload) >= 4:
            for i in range(4):
                id = "%02x%s" % (payload[i], id)

        if opcode == HubProtocol.ID_REPORT:
            if len(payload) != 4:
                print "Error: incorrect length from hub received"
                return
            self.sendMessage("Discovered hub: " + id)
            print "Modulen: Received ID_REPORT from %s" % (id)
            hub = self.hubList.addHub(id)
            hub.discoverd = True
            hub.responsive = True
            # self.remote.sendCommand( HubProtocol.TAG_ID,4,hub.idAsArray() ) # remove tagging, as it messes up frames
        elif opcode == HubProtocol.STATUS_REPORT:
            hub = self.currenthub
            if hub:
                hub.setFanbots(payload)
                self.fanbotList.setFanbots(hub.fanbots)
            self.labelHubId.SetLabel("Hub: " + id)

    def hubSelected(self, hub):
        """Callback function called from the hubs list control"""
        self.showHub(self.currenthub)
        print "selected hub:", hub.id
        self.currenthub = hub

        config = hub.config
        for i in range(0, len(config)):
            tuple = hub.getConfigColor(i)
            if tuple[0] >= 0:
                x = tuple[0]
                y = tuple[1]
                self.bitmap.setPixel(x, y, 0xFFFFFF)
        self.fanbotList.setFanbots(None)
        self.labelHubId.SetLabel("Hub: ")
        self.panelModulesCanvas.Refresh()
        self.remote.sendCommand(HubProtocol.REQUEST_STATUS, 4, hub.idAsArray())
        time.sleep(0.2)
        if 0 == self.sliderAnimateHub.GetValue():
            self.createHubBitmap()
            self.remote.sendFanbotFrame(self.compressedFrame)

    def fanbbotSelected(self, item):
        mappedindex = Hub.fanbotMapping[item] - 1
        print "Selected fanbot index: %d mapped onto index %d" % (item, mappedindex)
        if 0 == self.sliderAnimateHub.GetValue():
            self.createFanbotBitmap(mappedindex)
            self.remote.sendFanbotFrame(self.compressedFrame)

    def showHub(self, hub):
        """for the given hub, show the pixels in the bitmap, in the color of he hub"""
        if hub:
            config = hub.config
            for i in range(0, len(config)):
                tuple = hub.getConfigColor(i)
                if tuple[0] >= 0:
                    x = tuple[0]
                    y = tuple[1]
                    self.bitmap.setPixel(x, y, tuple[2])

    def resetHub(self, hub):
        """for the given hub, make all its pixels gray, and then reset config"""
        if hub:
            print "reset hub:", hub.id
            config = hub.config
            for i in range(0, len(config)):
                tuple = hub.getConfigColor(i)
                if tuple[0] >= 0:
                    x = tuple[0]
                    y = tuple[1]
                    self.bitmap.pixelSetGray(x, y)
            hub.resetConfig()
            self.panelModulesCanvas.Refresh()

    def sliderAnimateHubOnScroll(self, event):
        speed = self.sliderAnimateHub.GetValue()
        if speed == 0:
            self.timerAnimate.Stop()
        else:
            self.timerAnimate.Start(250 - speed * 25)

    def timerAnimateHandler(self, event):
        """  """
        hub = self.currenthub
        if hub:
            self.animateIdx += 1
            if self.animateIdx >= 24:
                self.animateIdx = 0
            self.createFanbotBitmap(Hub.fanbotMapping[self.animateIdx] - 1)
        self.remote.sendFanbotFrame(self.compressedFrame)

    def createHubBitmap(self):
        hub = self.currenthub
        maxFrameLen = len(self.compressedFrame)
        if hub:
            for i in range(maxFrameLen):
                self.compressedFrame[i] = 0
            for i in range(24):
                pixelIdx = hub.config[i]
                if pixelIdx >= 0:
                    byteIdx = pixelIdx / 8
                    if byteIdx >= maxFrameLen:
                        return
                    bitIdx = pixelIdx % 8
                    self.compressedFrame[byteIdx] |= 1 << bitIdx

    def createFanbotBitmap(self, idx):
        hub = self.currenthub
        maxFrameLen = len(self.compressedFrame)
        if hub:
            for i in range(maxFrameLen):
                self.compressedFrame[i] = 0
            if idx >= 24:
                return
            pixelIdx = hub.config[idx]
            if pixelIdx >= 0:
                byteIdx = pixelIdx / 8
                if byteIdx >= maxFrameLen:
                    return
                bitIdx = pixelIdx % 8
                self.compressedFrame[byteIdx] = 1 << bitIdx
Ejemplo n.º 41
0
class ProxyControl(PanelProxy):
    alive = True
    instance = None
    
    def __init__( self, parent,remote):
        """ remote is instance of HubProtocol for communication with remote"""
        PanelProxy.__init__( self, parent )
        self.remote = remote
        print 'ProxyControl constructor  '
        self.scaleX = 1
        self.scaleY = 1
        self.server = None
        ProxyControl.instance = self
        self.bitmap = Bitmap(FanbotConfig.width,FanbotConfig.height)
        self.Refresh()
     # Virtual event handlers, overide them in your derived class


    def __del__( self ):
        print "proxycontrol destructor ..."
        self.shutdown()
        
    def panelProxyCanvasOnPaint( self, event ):
        dc = wx.PaintDC(self.panelProxyCanvas)
        dc.BeginDrawing()
        dc.SetUserScale(self.scaleX, self.scaleY)
        dc.Clear()
        dc.DrawBitmap(self.bitmap.getBitmap(),0,0)
        dc.EndDrawing()
        
     
    def panelProxyCanvasOnSize( self, event ):
        rect = self.panelProxyCanvas.GetRect()

        self.scaleX = rect.GetWidth() / self.bitmap.width
        self.scaleY = rect.GetHeight() / self.bitmap.height
        #print 'Scale x:y',self.scaleX,':',self.scaleY
        self.Refresh()
 
    def startProxyServer(self):    
        self.buttonProxyStartOnButtonClick(None)
 
    def buttonProxyStartOnButtonClick( self, event ):
        evt = fanbotevent.FanbotEvent(fanbotevent.EVT_PROXY_SERVER_ID,self.GetId())
        
        if self.buttonProxyStart.GetLabel() == 'Start':
            self.initProxyServer();
            time.sleep(1)
            if ProxyControl.alive:
                self.buttonProxyStart.SetLabel('Stop')
                evt.setPayload('started')
                wx.PostEvent(self,evt)
                print 'proxy server started'
            else:           
                print 'unable to start proxy server '


            
        else:
            dlg = wx.MessageDialog(self, 'Zeker weten?!',
                           'Stop proxy server, ' ,
                           wx.OK| wx.CANCEL | wx.ICON_INFORMATION )
            result = dlg.ShowModal() 
            dlg.Destroy()
            if wx.ID_OK  ==result:
                self.shutdown();
                self.buttonProxyStart.SetLabel('Start')
                evt.setPayload('stopped')
                wx.PostEvent(self,evt)
                print 'proxy server stopped'       
            


    def initProxyServer(self):
        """Start the server  thread"""        
        self.thread = threading.Thread(target=self.proxyServerThread)
        self.thread.setDaemon(1)
        self.thread.start()

        
    def proxyServerThread(self):
        print "Starting socket server thread "
        portstr = FanbotConfig.getProxyPort() 
        port = int(portstr)
        host = "localhost"
        self.labelProxyHost.SetLabel( '%s : %d' % (host,port) )
        ProxyControl.alive = True
        try: 
            self.server = SocketServer.ThreadingTCPServer((host, port), ProxyHandler)
            self.server.serve_forever()
        except Exception as e:
            print "unable to start server: ", e.message  
            self.shutdown()
        
    def shutdown(self):
        ProxyControl.alive = False
        if self.server:
            self.server.shutdown()
            self.server = None
Ejemplo n.º 42
0
class Plot(param.Parameterized):
     """
     Simple Plot object constructed from a specified PIL image.
     """

     staleness_warning=param.Number(default=10,bounds=(0,None),doc="""
       Time length allowed between bitmaps making up a single plot before warning.

       If the difference between the SheetView with the earliest
       timestamp and the one with the latest timestamp is larger
       than this parameter's value, produce a warning.
       """)

     def __init__(self,image=None,**params):
          super(Plot,self).__init__(**params)
          self._orig_bitmap = Bitmap(image)
          self.bitmap = self._orig_bitmap # Possibly scaled copy (at first identical)
          self.scale_factor=1.0
          self.plot_src_name = ''
          self.precedence = 0.0
          self.row_precedence = 0.5
          # If False, this plot should be left in its native size
          # pixel-for-pixel, (e.g. for a color key or similar static
          # image), rather than being resized as necessary.
          self.resize=False

          # Time at which the bitmaps were created
          self.timestamp = -1


     def rescale(self,scale_factor):
          """
          Change the size of this image by the specified numerical factor.

          The original image is kept as-is in _orig_bitmap; the scaled
          image is stored in bitmap.  The scale_factor argument is
          taken as relative to the current scaling of the bitmap.  For
          instance, calling scale(1.5) followed by scale(2.0) will
          yield a final scale of 3.0, not 2.0.
          """
          self.scale_factor *= scale_factor

          if (self._orig_bitmap):
              self.bitmap = copy.copy(self._orig_bitmap)
              self.bitmap.image = self._orig_bitmap.zoom(self.scale_factor)


     def set_scale(self,scale_factor):
          """
          Specify the numerical value of the scaling factor for this image.

          The original image is kept as-is in _orig_bitmap; the scaled
          image is stored in bitmap.  The scale_factor argument is
          taken as relative to the original size of the bitmap.  For
          instance, calling scale(1.5) followed by scale(2.0) will
          yield a final scale of 2.0, not 3.0.
          """
          self.scale_factor = scale_factor

          if (self._orig_bitmap):
              self.bitmap = copy.copy(self._orig_bitmap)
              self.bitmap.image = self._orig_bitmap.zoom(self.scale_factor)

     def label(self):
          """Return a label for this plot."""
          return self.plot_src_name + '\n' + self.name
Ejemplo n.º 43
0
 def test_max_bits(self):
     b = Bitmap(2 ** 1024 - 1)
     self.assertTrue(b)
     bitset = b.get_bitmap_as_indices()
     self.assertTrue(len(bitset) == 1024)
Ejemplo n.º 44
0
class HubSimulControl(HubSimulFrame ):
    HubCount = 42
    
    
    def __init__( self, parent):
        HubSimulFrame.__init__( self, parent )
        
        
        panel = self.panelRawBitmap
        sizer = panel.GetSizer()    
        self.bitmap = Bitmap(panel,Bitmap.width,Bitmap.height) 
        sizer.Add( self.bitmap, 1, wx.EXPAND )
        
        # start listeneing on port 1234
        factory = ParserFactory()
        server = HubSimulServer(factory)
        self.protocol = HubProtocol(server)
        self.protocol.addListener(self)


        self.alive = threading.Event()
        self.event = None

        self.hubs = []

        for i in range (HubSimulControl.HubCount):
            hub = HubSimul(i,self.protocol)
            self.hubs.append(hub)
                    
        self.startThread()

        
    def __del__( self ):
        print "destructor ..."
        self.server.shutdown()
        self.server = None

    def handleCommand(self, opcode,payload):    

        if opcode in [HubProtocol.POS_FRAME,HubProtocol.PLAY_FRAME,HubProtocol.LED_FRAME]:
            wx.CallAfter(self.updateBitmapInGuiThread,opcode,payload)
        else:    
            for i in range (HubSimulControl.HubCount):
                hub = self.hubs[i]
                hub.handleCommand(opcode,payload)
            
            
    def updateBitmapInGuiThread(self,command,payload):  
        self.bitmap.fromCompressedBuffer(command,payload)
        self.Refresh()
            
        
    def startThread(self):
        
        """Start the wave  thread"""        
        self.thread = threading.Thread(target=self.TribuneWaveThread)
        self.thread.setDaemon(1)
        self.alive.set()
        self.thread.start()

    def stopThread(self):
        """Stop the receiver thread, wait util it's finished."""
        print "Stop thread ..."
        self.alive.clear()          #clear alive event for thread
        if hasattr(self, 'thread') and self.thread != None:
            self.thread.join()          #wait until thread has finished
            self.thread = None
        print "Stop thread done ..."
        
    def TribuneWaveThread(self):
        print "Starting thread TribuneWaveThread"
        while(True):
            time.sleep(1)

        

            
Ejemplo n.º 45
0
    master_log("Data ready. Sending chunks info to workers.", MPI.Wtime() - data_prep_time)
else:
    chunk_info = None
    chunks = None

chunk_width, chunk_height, chunk_bytes = comm.bcast(chunk_info, root=0)

worker_chunk = np.empty(chunk_bytes, dtype=np.uint8)
master_log("Scattering pixels data.")
comm.Scatter([chunks, MPI.BYTE], [worker_chunk, MPI.BYTE], root=0)
worker_log("Received pixels data chunk.")

if not master(): # Chunk processing (in workers)
    chunk_start_time = MPI.Wtime()
    log("Starting chunk processing.")
    bm = Bitmap(chunk_width, chunk_height, worker_chunk)
    res_bm = bm.scale(Constants.SCALING).roberts_cross()
    res_chunk = res_bm.get_data()
    res_chunk_width, res_chunk_height = res_bm.get_size()
    res_chunk_bytes = res_chunk_width * res_chunk_height
    res_chunk_info = (res_chunk_width, res_chunk_height, res_chunk_bytes)
    log("Finished chunk processing.", MPI.Wtime() - chunk_start_time)

# Send processed chunk info to master
if rank == 1:
    log("Sending processed chunk info to master.")
    comm.send(res_chunk_info, dest=0, tag=1)
if master():
    res_chunk_width, res_chunk_height, res_chunk_bytes = comm.recv(source=1, tag=1)
    log("Received processed chunks info.")
    res_chunk = np.empty(res_chunk_bytes, dtype=np.uint8)
Ejemplo n.º 46
0
    def test_find_next_empty_bits(self):
        b = Bitmap(0x0)

        i = 0

        while str(b) == "0xFFFF":
            n = b.get_next_empty_bits(1)
            self.assertEqual(n, i)
            i += 1

        b = Bitmap(0xA955)
        self.assertEqual(b.get_next_empty_bits(2), 9)
        self.assertEqual(b.get_next_empty_bits(3), 16)

        b = Bitmap(2 ** 1024 - 1)
        self.assertEqual(b.get_next_empty_bits(1), -1)

        b = Bitmap(2 ** 1024 - 1)
        b.clr_bit(1023)
        self.assertEqual(b.get_next_empty_bits(1), 1023)
        self.assertEqual(b.get_next_empty_bits(2), -1)

        self.assertEqual(b.get_next_empty_bits(0), -1)
Ejemplo n.º 47
0
class DesignControl(PanelDrawIcon ):
    def __init__( self, parent):
        PanelDrawIcon.__init__( self, parent )
        print 'DesignControl constructor  '

        self.brush = '1'
        self.drawMode = 0  
        self.brushColor = 0xFFFF;
        self.scaleX = 1
        self.scaleY = 1
        self.bitmap = Bitmap(FanbotConfig.width,FanbotConfig.height)
        self.pointCurrent = wx.Point(0,0)
        self.pointStartDrag = None
        self.pointEndDrag = None
        self.mousePoint = (0,0)
        self.panelIconCanvasOnSize(None)
        self.timer = wx.Timer(self)
        self.Bind(wx.EVT_TIMER, self.timerAnimate, self.timer)
        self.animateIdx = 0
        self.initFileList()

 
                    
    def panelIconCanvasOnPaint( self, event ):
        dc = wx.PaintDC(self.panelIconCanvas)
        dc.BeginDrawing()
        dc.SetUserScale(self.scaleX, self.scaleY)
        dc.Clear()
        dc.DrawBitmap(self.bitmap.getBitmap(),0,0)
        dc.EndDrawing()
        
     
    def panelIconCanvasOnMouseEvents( self, event ):
        
        point = None
        canvas = self.panelIconCanvas
        if event:
            # set mouse cursor
            canvas.SetCursor(wx.StockCursor(wx.CURSOR_ARROW))
            # get device context of canvas
            dc= wx.ClientDC(canvas)
            dc.SetUserScale(self.scaleX, self.scaleY)

            point = event.GetLogicalPosition(dc)
            if point.x < 0 or point.x >= FanbotConfig.width or point.y < 0 or point.y >= FanbotConfig.height:
            	#print 'x,y out of bounds: ',point.x ,':',point.y    
                return
            self.pointCurrent = point    
            #print "mouse event X : " ,point.x , " Y: ",point.y

        if event.LeftDown():
           #print "mouse down X : " ,point.x , " Y: ",point.y
           # Left mouse button down, change cursor to
           # something else to denote event capture
           self.pointStartDrag = point
           cur = wx.StockCursor(wx.CURSOR_CROSS)  
           canvas.SetCursor(cur)
           self.setPixel(point.x, point.y,self.brushColor)        
           # invalidate current canvas
           self.Refresh()

            
        if event.LeftIsDown():
            self.pointDragTo = point
            #print "Dragging to X : " ,point.x , " Y: ",point.y
            cur = wx.StockCursor(wx.CURSOR_CROSS)  
            canvas.SetCursor(cur)
            if self.drawMode == 0:
                self.setPixel(point.x, point.y,self.brushColor)
            if self.drawMode == 1:
                for x in range (self.pointStartDrag.x,point.x):
                    for y in range (self.pointStartDrag.y,point.y):
                        self.setPixel(x, y,self.brushColor)
                                    
            self.panelIconCanvas.Refresh()
                 
    """ Panel drawDesign   """
    def buttonPrevOnButtonClick( self, event ):
        self.prevFrame()
        self.labelFrame.SetLabel(self.getFrameCountAsString())
    
    def buttonNextOnButtonClick( self, event ):
        self.nextFrame()
        self.labelFrame.SetLabel(self.getFrameCountAsString())
  
    def buttonAddFrameOnButtonClick( self, event ):
        self.addFrame()
        self.labelFrame.SetLabel(self.getFrameCountAsString())
        

    def buttonDeleteFrameOnButtonClick( self, event ):
        frnr = self.delFrame()
        self.labelFrame.SetLabel(self.getFrameCountAsString())

    def buttonAddOnButtonClick( self, event ):
        wx.MessageBoxCaptionStr
        dlg = wx.TextEntryDialog(
                self, 'Filename: ',
                'Enter filename', 'Python')

        dlg.SetValue("test.gif")

        if dlg.ShowModal() == wx.ID_OK:
            fn = dlg.GetValue()
            if not fn.find('.gif'):
                fn = fn + '.gif'
            full = 'data/' + fn 
            self.setFilename(full) 
            f = open(full,'w')
            f.close()
            self.saveCurrentFile()   
      
        dlg.Destroy()
        self.listIcons.Append(fn)
         
    def buttonDeleteOnButtonClick( self, event ):
        print 'buttonDeleteOnButtonClick'
        idx = self.listIcons.GetSelection()
        if idx ==  wx.NOT_FOUND:
            return;
        fn = self.listIcons.GetString(idx)
        result = wx.MessageBox('File '+ fn +  ' wissen?', 'File wissen', 
                               wx.OK | wx.CANCEL | wx.ICON_QUESTION)
        if result == wx.OK:
            os.remove('data/' + fn)
            self.listIcons.Delete(idx)
                
    
    def buttonSaveOnButtonClick( self, event ):
        self.saveCurrentFile()
    
    def listIconsOnListBox( self, event ):
        fname = event.GetString()
        print 'selected: ', fname
        self.loadFromFile("data/" + fname)
        self.labelFrame.SetLabel(self.getFrameCountAsString())
      
    
    def sliderAnimateOnScroll( self, event ):
        pos = event.GetPosition()
        self.animate(pos)
        if pos == 0:
            self.labelFrame.SetLabel(self.getFrameCountAsString())

        
        
        
        event.Skip()    
    def initFileList(self):
        for fname in os.listdir("data"):
            if ".gif" in fname:
                #print fname
                self.listIcons.Append(fname)


    def toolBrush1OnToolClicked( self, event ):
        self.brush = '1'
    
    def toolBrush4OnToolClicked( self, event ):
        self.brush = '4'
    
    def toolBrush9OnToolClicked( self, event ):
        self.brush = '9'

    
    def toolDrawLineOnToolClicked( self, event ):
        self.drawMode = 1

    def toolDrawDotOnToolClicked( self, event ):
        self.drawMode = 0
    

    def toolColorOnToolClicked( self, event ):

        dlg = wx.ColourDialog(self)
        dlg.GetColourData().SetChooseFull(True)
        if dlg.ShowModal() == wx.ID_OK:

            # If the user selected OK, then the dialog's wx.ColourData will
            # contain valid information. Fetch the data ...
            data = dlg.GetColourData()

            # ... then do something with it. The actual colour data will be
            # returned as a three-tuple (r, g, b) in this particular case.
            print 'You selected: %s\n' % str(data.GetColour().Get() )
            r,g,b = data.GetColour().Get()
            self.brushColor =   b * 0x10000 + g * 0x100 + r
        dlg.Destroy()
    
    def toolColorBlackOnToolClicked( self, event ):
        print 'colorGray'
        self.brushColor =    0x101010
    
    def toolColorWhiteOnToolClicked( self, event ):
        print 'clororWhite'
        self.brushColor =    0xC0C0C0
    
    def panelIconCanvasOnSize( self, event ):
        rect = self.panelIconCanvas.GetRect()

        self.scaleX = rect.GetWidth() / self.bitmap.width
        self.scaleY = rect.GetHeight() / self.bitmap.height
        #print 'Scale x:y',self.scaleX,':',self.scaleY
        
        self.Refresh()
        
    def loadFromFile(self,fname):
        if self.bitmap.changed:
            result = wx.MessageBox('Bitmap is aangepast. Opslaan?', 'Opslaan', 
                                   wx.OK | wx.CANCEL |wx.ICON_INFORMATION)
            if result == wx.OK:
                self.saveCurrentFile()
        self.bitmap.loadFromFile(fname)
        self.Refresh()

    def saveCurrentFile(self):
        self.bitmap.saveCurrentFile()
  
    def getFilename(self):
        return self.bitmap.filename 
    def setFilename(self,fn):
        self.bitmap.filename = fn 

    def delFrame(self):
        """delete frame at current index.  Do nothing if only one frame        """
        self.bitmap.delFrame()
        self.Refresh()

    def addFrame(self):
        """add frame after the current index.  
        """
        self.bitmap.addFrame()
        self.Refresh()

        
    def prevFrame(self):
        """Go back  to previous  frame in animated GIF. 
        """
        self.bitmap.prevFrame()
        self.Refresh()
 
    def animate(self,speed):
        if speed == 0:
            self.timer.Stop()
        else :
            self.timer.Start(1000 -speed * 100)
 
    def timerAnimate(self,event):
        self.animateIdx += 1
        if self.animateIdx >= self.bitmap.getFrameCount():
            self.animateIdx = 0
        self.bitmap.setFrameNr(self.animateIdx)  
        self.Refresh()  

            
    def getFrameCountAsString(self):
        return '%d/%d' % (self.bitmap.getFrameNr(),self.bitmap.getFrameCount() )    
        
    def nextFrame(self):
        """Advance to next frame in animated GIF. If beyond the last do nothing
        """
        self.bitmap.nextFrame()
        self.Refresh()
        
    def setPixel(self,x,y,colour):
        if self.brush =='1':
            self.bitmap.setPixel(x, y,colour)
        elif self.brush =='4':
            self.bitmap.setPixel(x, y,colour)
            self.bitmap.setPixel(x, y+1,colour)
            self.bitmap.setPixel(x+1, y,colour)
            self.bitmap.setPixel(x+1, y+1,colour)
    
        elif self.brush == '9' and x > 0 and y > 0:
            self.bitmap.setPixel(x, y,colour)
            self.bitmap.setPixel(x, y-1,colour)
            self.bitmap.setPixel(x, y+1,colour)
            self.bitmap.setPixel(x-1, y,colour)
            self.bitmap.setPixel(x-1, y-1,colour)
            self.bitmap.setPixel(x-1, y+1,colour)
            self.bitmap.setPixel(x+1, y,colour)
            self.bitmap.setPixel(x+1, y-1,colour)
            self.bitmap.setPixel(x+1, y+1,colour)
Ejemplo n.º 48
0
    def test_set_bit(self):
        b = Bitmap()

        b.set_bit(64)
        b.set_bit(0)
        b.set_bit(1023)

        self.assertTrue(b.is_bit_set(64))
        self.assertTrue(b.is_bit_set(0))
        self.assertTrue(b.is_bit_set(1023))

        for i in range(1024):
            if i != 64 and i != 0 and i != 1023:
                self.assertFalse(b.is_bit_set(i))

        self.assertRaises(TooDamnMuchDammitError, b.set_bit, 1024)
Ejemplo n.º 49
0
 def test_clr_bit(self):
     b = Bitmap(0xAA55)
     b.clr_bit(0);
     self.assertEqual(str(b), "0xaa54")
     b.clr_bit(1);
     self.assertEqual(str(b), "0xaa54")
     b.clr_bit(2);
     self.assertEqual(str(b), "0xaa50")
     b.clr_bit(4);
     self.assertEqual(str(b), "0xaa40")
     b.clr_bit(6);
     self.assertEqual(str(b), "0xaa00")
     b.clr_bit(15)
     self.assertEqual(str(b), "0x2a00")
     b.set_bit(1023)
     self.assertTrue(b.is_bit_set(1023) and re.search(r"2a00$", str(b), re.I))
     b.clr_bit(1023)
     self.assertTrue(str(b), "0x2a00")
     self.assertRaises(TooDamnMuchDammitError, b.clr_bit, 1024)
Ejemplo n.º 50
0
 def test_ctor(self):
     b = Bitmap()
     self.assertTrue(b)
     bitset = b.get_bitmap_as_indices()
     self.assertTrue(not len(bitset))