VA-Control-for-linux/reference/decompiled/child_unit.py

# Source Generated with Decompyle++
# File: child_unit.pyc (Python 2.6)

if __name__ == '__main__':
    import main
    main.run()

import mytime
import ConfigParser
import os.path as os
import sys
import marshal
import cPickle
import wx
import datetime
import control_panel
import svg_panel
import data_model
import countDSPs
import threading
import svg
import svg.document as svg
import traceback
import future
import protocol
import main
import dialog
import base64
import StringIO
import tempfile
import math
import socket
import server
import shutil
import d_protocol
from tetris.TetrisGame import TetrisGame
import zipfile
import one_unit
import string
import my_menu
import inspect
from definitions import *
default_encryption_key = 'nvbhfwieahscoiuafnrakjdfhaskjdhvlskdjncailsuydkdfjnalsuvhesrioiclioswoqweymdpwkxmnakcnxenwoawkomoqxsojdinoskdcmskjdfmaxkjnsdcjkndlkscntnvlakjsbxnlkjdbhvkjdgnlfcusxnl'
dspArchitectures = {
    '1.9.16': 'MK2.1',
    '1.9.31': 'MK2.2',
    '1.10.16': 'MK2.2',
    '1.10.18': 'MK2.1',
    '1.10.30': 'MK2.2',
    '1.10.31': 'MK2.3',
    '1.10.37': 'MK2.1',
    '1.10.51': 'MK2.1',
    '1.10.65': 'MK3.1',
    '1.10.66': 'MK3.1',
    '1.10.67': 'MK3.1',
    '1.11.16': 'MK2.3',
    '1.11.30': 'MK2.2',
    '1.11.31': 'MK2.5',
    '1.11.37': 'MK2.1',
    '18.20.71': 'MK2.1',
    '54.1.1': 'MK2.2',
    '54.10.51': 'MK2.1' }

def Key(*args):
    return data_model.Key(*args)


def getString(str):
    return one_unit.getString(str)

if os.name in mac_names:
    newline = '\n'
else:
    newline = '\r\n'

class logPanel(wx.Frame):
    
    def __init__(self, parent):
        
        try:
            title = 'Hardware Log for ' + parent.active_unit.name.strip()
        except:
            title = 'Hardware Log'

        wx.Frame.__init__(self, None, -1, title = title, size = (800, 430))
        self.title = title
        self.parent = parent
        self.pdfDataSet = { }
        self.isTCS = self.parent.isTCS
        self.isZwembad = False
        if self.parent.active_unit.name.lower().find('zwembad') >= 0:
            self.isZwembad = True
        
        tempP = wx.Panel(self)
        if os.name in mac_names:
            ph = 30
        else:
            ph = 10
        wx.StaticText(tempP, -1, 'Fetching Data...', pos = (10, 10))
        alkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACTIVITY_LOG, 0, 0)
        parent.remote_link.set_get_key(alkey)
        
        try:
            self.SetPosition(parent.lastLogPosition)
        except:
            pass

        self.Show(True)
        one_unit.tryYield()
        parent.waitForSync('cu.lP', key = alkey)
        if parent.active_unit.MAC not in one_unit.app.unitLogs:
            wx.StaticText(tempP, -1, 'No available data.', pos = (10, 10))
            return None
        tempP.Destroy()
        self.p = wx.Panel(self, size = (800, 400 + ph))
        self.nb = wx.Notebook(self.p, size = (800, 370 + ph))
        self.signalLevelPanel = wx.Panel(self.nb)
        self.signalLevelPanel.Bind(wx.EVT_PAINT, self.OnPaintSignalLevel)
        if self.isTCS:
            if self.isZwembad:
                self.nb.AddPage(self.signalLevelPanel, 'Zwembad')
            else:
                self.nb.AddPage(self.signalLevelPanel, 'CO2 Level')
        else:
            self.nb.AddPage(self.signalLevelPanel, 'Input Signal Level')
        self.gainReductionPanel = wx.Panel(self.nb)
        self.gainReductionPanel.Bind(wx.EVT_PAINT, self.OnPaintGainReduction)
        if self.isTCS:
            if self.isZwembad:
                self.nb.AddPage(self.gainReductionPanel, 'Lucht')
            else:
                self.nb.AddPage(self.gainReductionPanel, 'Pressure Change')
        else:
            self.nb.AddPage(self.gainReductionPanel, 'Output Gain Reduction')
        self.temperaturePanel = wx.Panel(self.nb)
        self.temperaturePanel.Bind(wx.EVT_PAINT, self.OnPaintTemperature)
        if self.isZwembad:
            self.nb.AddPage(self.temperaturePanel, 'Verwarming')
        else:
            self.nb.AddPage(self.temperaturePanel, 'Temperature')
        self.messagesPanel = wx.Panel(self.nb)
        self.nb.AddPage(self.messagesPanel, 'Messages')
        (self.w, self.h) = self.GetSize()
        self.bw = 10
        self.msgLabels = { }
        self.writeMessages()
        if one_unit.app.mijnpc == True:
            self.resetLogButton = wx.Button(self.p, -1, 'Clear', pos = (5, 373 + ph))
            self.Bind(wx.EVT_BUTTON, self.onClear, self.resetLogButton)
        
        self.refreshLogButton = wx.Button(self.p, -1, 'Refresh', pos = (705, 373 + ph))
        self.Bind(wx.EVT_BUTTON, self.onRefresh, self.refreshLogButton)
        self.exportLogButton = wx.Button(self.p, -1, 'Export', pos = (620, 373 + ph))
        self.Bind(wx.EVT_BUTTON, self.onExport, self.exportLogButton)
        self.SetSize((800, 450))
        self.parent.lastLogPosition = self.GetPosition()
        
        try:
            self.nb.SetSelection(self.parent.lastLogPage)
        except:
            pass


    
    def onExport(self, e):
        print mytime.displayTime(), 'export'
        dlg = wx.FileDialog(self, message = 'Save as....', defaultDir = one_unit.app.library_path, defaultFile = self.title + '.pdf', style = wx.SAVE | wx.CHANGE_DIR)
        if dlg.ShowModal() == wx.ID_OK:
            filename = dlg.GetPath()
            if filename[-4:] not in ('.pdf',):
                filename += '.txt'
            
            one_unit.app.library_path = os.path.split(filename)[0]
            dlg.Destroy()
        else:
            dlg.Destroy()
            return None
        print (dlg.ShowModal() == wx.ID_OK).displayTime(), 'cu.Saving Log to', filename
        localtime = localtime
        strftime = strftime
        import time
        timeString = strftime('%a, %d %b %Y %H:%M:%S', localtime())
        import makePDF
        res = makePDF.MyPDF(headerText = self.title + ' (MAC: ' + self.parent.active_unit.MAC + ') ' + timeString)
        res.reset()
        res.add_page()
        res.set_font('Arial', size = 9)
        for category in sorted(self.pdfDataSet.keys()):
            if category == 'Messages':
                continue
            
            dataSet = self.pdfDataSet[category]
            for line in dataSet:
                res.multi_cell(400, 4, txt = line, align = 'L')
            
        
        dataSet = self.pdfDataSet['Messages']
        for line in dataSet:
            res.multi_cell(400, 4, txt = line, align = 'L')
        
        res.output(filename)
        res.close()

    
    def onRefresh(self, e):
        self.parent.lastLogPosition = self.GetPosition()
        self.parent.lastLogPage = self.nb.GetSelection()
        wx.CallAfter(self.parent.showHardwareLog)
        self.Destroy()

    
    def onClear(self, e):
        dlgMessage = getString('dlm')
        dlgTitle = getString('hl')
        res = wx.MessageBox(dlgMessage, dlgTitle, wx.OK | wx.CANCEL)
        if res != wx.OK:
            return None
        key = data_model.Key(protocol.STRUCT_ID_COMMAND, protocol.MEMBER_ID_COMMAND, 0, protocol.cmdResetLog)
        self.parent.set_value(key, 1)
        mytime.sleep(1)
        self.parent.set_value(key, 0)

    
    def writeMessages(self):
        self.pdfDataSet['Messages'] = []
        self.pdfDataSet['Messages'].append('')
        self.pdfDataSet['Messages'].append('Status Messages:')
        
        try:
            log = one_unit.app.unitLogs[self.parent.active_unit.MAC]
            data = { }
            minutes = None
            hour = None
            hours = None
            days = None
            i = 0
            for logEntry in log['6 minute']:
                data[i] = logEntry
                i += 1
            
            minutes = i
            for logEntry in log['1 hour']:
                data[i] = logEntry
                i += 1
            
            hour = i
            for logEntry in log['16 hour']:
                data[i] = logEntry
                i += 1
            
            hours = i
            for logEntry in log['10 day']:
                data[i] = logEntry
                i += 1
            
            days = i
        except:
            print mytime.displayTime(), 'ou.lp.opsl No data'
            traceback.print_exc(file = sys.stdout)
            return None

        line = 0
        lastMessage = ''
        for t in data:
            res = data[t]
            timeString = str((1 + t) * 6) + ' minutes ago'
            if t >= minutes and t < hour:
                timeString = str(1 + t - minutes) + ' hours ago'
            
            if t >= hour and t < hours:
                timeString = str(int((1 + t - hour) * 16 / 24)) + ' days ago'
            
            if t >= hours:
                timeString = str((1 + t - hours) * 10) + ' days ago'
            
            lastMessage = text
            if os.name in mac_names:
                splitLimit = 120
            else:
                splitLimit = 150
            if len(text) > splitLimit:
                while len(text) > splitLimit:
                    pos = text.find(',', splitLimit - 30)
                    text1 = text[:pos + 1]
                    text = '         ' + text[pos + 2:]
                    self.msgLabels[line] = wx.StaticText(self.messagesPanel, -1, text1, pos = (10, 10 + line * 20))
                    self.pdfDataSet['Messages'].append(text1)
                    line += 1
                self.msgLabels[line] = wx.StaticText(self.messagesPanel, -1, text, pos = (10, 10 + line * 20))
                self.pdfDataSet['Messages'].append(text)
                line += 1
                continue
            self.msgLabels[line] = wx.StaticText(self.messagesPanel, -1, text, pos = (10, 10 + line * 20))
            self.pdfDataSet['Messages'].append(text)
            line += 1
        
        if line == 0:
            print mytime.displayTime(), 'No messages'
            self.msgLabels['None'] = wx.StaticText(self.messagesPanel, -1, 'No messages.', pos = (10, 10))
            self.pdfDataSet['Messages'].append('No Messages')
        

    
    def drawScale(self, dc, low, high, unit, vlines):
        dc.SetPen(wx.Pen(wx.BLACK, 2))
        offset = 41
        dc.DrawLine(offset - 1, self.h - 100, self.w - 30, self.h - 100)
        dc.DrawLine(offset - 1, 20, offset - 1, self.h - 100)
        dc.SetTextForeground(wx.BLACK)
        if os.name in mac_names:
            dc.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))
        else:
            dc.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))
        if self.isTCS:
            dc.DrawText('hours', 30, self.h - 93)
        else:
            dc.DrawText('minutes', 30, self.h - 93)
        (w, h) = dc.GetTextExtent(unit)
        dc.DrawText(unit, offset - 1 - w, 0)
        dc.SetPen(wx.Pen(wx.BLACK, 1))
        scale = (self.h - 120) / vlines
        notch = (high - low) / vlines
        for i in range(vlines + 1):
            labelString = str(low + i * notch)
            (w, h) = dc.GetTextExtent(labelString)
            dc.DrawLine(offset - 1, self.h - 100 - i * scale, offset - 8, self.h - 100 - i * scale)
            dc.DrawText(labelString, offset - 11 - w, self.h - 100 - h / 2 - i * scale)
        

    
    def drawDataSet(self, dc, data1, data2, low, high, yellow, red, unit, noPeak = False, title = ''):
        self.pdfDataSet[title] = []
        self.pdfDataSet[title].append('')
        self.pdfDataSet[title].append(title)
        
        try:
            if os.name in mac_names:
                dc.SetFont(wx.Font(12, wx.SWISS, wx.NORMAL, wx.NORMAL))
            else:
                dc.SetFont(wx.Font(10, wx.SWISS, wx.NORMAL, wx.NORMAL))
            log = one_unit.app.unitLogs[self.parent.active_unit.MAC]
            data = { }
            minutes = None
            hour = None
            hours = None
            days = None
            maxVal = -100
            maxI = 0
            i = 0
            for logEntry in log['6 minute']:
                data[i] = (logEntry[data1], logEntry[data2])
                if data[i][1] >= maxVal:
                    maxVal = data[i][1]
                    maxI = i
                
                i += 1
            
            minutes = i
            for logEntry in log['1 hour']:
                data[i] = (logEntry[data1], logEntry[data2])
                if data[i][1] >= maxVal:
                    maxVal = data[i][1]
                    maxI = i
                
                i += 1
            
            hour = i
            for logEntry in log['16 hour']:
                data[i] = (logEntry[data1], logEntry[data2])
                if data[i][1] >= maxVal:
                    maxVal = data[i][1]
                    maxI = i
                
                i += 1
            
            hours = i
            for logEntry in log['10 day']:
                data[i] = (logEntry[data1], logEntry[data2])
                if data[i][1] >= maxVal:
                    maxVal = data[i][1]
                    maxI = i
                
                i += 1
            
            days = i
        except:
            print mytime.displayTime(), 'ou.lp.opsl No data'
            traceback.print_exc(file = sys.stdout)
            return None

        scale = (self.h - 120) / (high - low)
        offset = 41
        maxX = None
        textMinutes = 0
        textHours = 0
        textDays = 0
        for t in data:
            if t < minutes:
                if self.isTCS:
                    text = str(t + 1) + ' hours ago: '
                else:
                    text = str((t + 1) * 6) + ' minutes ago: '
            elif t < hour:
                if self.isTCS:
                    text = str(t + 1 - minutes) + ' days ago: '
                else:
                    text = str(t + 1 - minutes) + ' hours ago: '
            elif t < hours:
                if self.isTCS:
                    text = str((t + 1 - hour) / 2) + ' weeks ago: '
                else:
                    text = str((t + 1 - hour) / 2) + ' days ago: '
            elif t < days:
                if self.isTCS:
                    text = str((t + 1 - hours) * 10) + ' weeks ago: '
                else:
                    text = str((t + 1 - hours) * 10) + ' days ago: '
            
            if t in (minutes, hour, hours):
                dc.SetPen(wx.Pen(wx.BLACK, 2))
                dc.DrawLine(offset + t * self.bw + 1, self.h - 85, offset + t * self.bw + 1, self.h - 100)
            
            if t == minutes:
                if self.isTCS:
                    dc.DrawText('days', offset + t * self.bw + 4, self.h - 93)
                else:
                    dc.DrawText('hours', offset + t * self.bw + 4, self.h - 93)
            
            if t == hour:
                if self.isTCS:
                    dc.DrawText('weeks', offset + t * self.bw + 4, self.h - 93)
                else:
                    dc.DrawText('days', offset + t * self.bw + 4, self.h - 93)
            
            v = data[t][0]
            text += 'Average: ' + str(v)
            if v < low:
                v = low
            
            if v > high:
                v = high
            
            if v < yellow:
                dc.SetPen(wx.Pen(wx.Colour(0, 220, 0), 1))
                dc.SetBrush(wx.Brush(wx.Colour(0, 220, 0)))
            elif v < red:
                dc.SetPen(wx.Pen(wx.Colour(255, 142, 0), 1))
                dc.SetBrush(wx.Brush(wx.Colour(255, 142, 0)))
            else:
                dc.SetPen(wx.Pen(wx.RED, 1))
                dc.SetBrush(wx.Brush(wx.RED))
            v = round((v - low) * scale, 0)
            dc.DrawRectangle(offset + t * self.bw + 2, self.h - 101 - v, self.bw - 2, v)
            v = data[t][1]
            text += ', Peak: ' + str(v)
            self.pdfDataSet[title].append(text)
            if v < low:
                v = low
            
            if v > high:
                v = high
            
            dc.SetPen(wx.Pen(wx.BLACK, 1))
            v = (v - low) * scale
            if t == 0:
                x = offset + 1 + t * self.bw
                y = self.h - 103 - v
            
            if noPeak == False:
                dc.DrawLine(offset + t * self.bw + 2, self.h - 103 - v, offset + t * self.bw + self.bw, self.h - 103 - v)
            
            x = offset + 1 + t * self.bw
            y = self.h - 103 - v
            if t == maxI:
                maxX = x
                maxY = y
            
            dc.SetPen(wx.Pen(wx.BLACK, 1))
            dc.DrawLine(offset + t * self.bw + 1, self.h - 95, offset + t * self.bw + 1, self.h - 100)
            textPos = offset + t * self.bw - 6
            if self.isTCS:
                if t == 6 and t < minutes:
                    dc.DrawText('6', textPos, self.h - 93)
                
                if t == 12 and t < minutes:
                    dc.DrawText('12', textPos, self.h - 93)
                
                if t == 18 and t < minutes:
                    dc.DrawText('18', textPos, self.h - 93)
                
                if t == 24 and t < minutes:
                    dc.DrawText('24', textPos, self.h - 93)
                
                if t == 30 and t < minutes:
                    dc.DrawText('30', textPos, self.h - 93)
                
                if t - minutes == 6 and t > minutes and t < hour:
                    dc.DrawText('3', textPos, self.h - 93)
                
                if t - minutes == 14 and t > minutes and t < hour:
                    dc.DrawText('7', textPos, self.h - 93)
                
                if t - hour == 4 and t > hour and t < hours:
                    dc.DrawText('4', textPos, self.h - 93)
                
                if t - hour == 8 and t > hour and t < hours:
                    dc.DrawText('8', textPos, self.h - 93)
                
                if t - hour == 12 and t > hour and t < hours:
                    dc.DrawText('12', textPos, self.h - 93)
                
                if t - hours == 1:
                    dc.DrawText('15', textPos, self.h - 93)
                
                if t - hours == 3:
                    dc.DrawText('45', textPos, self.h - 93)
                
            t - hours == 3
            if t == 9 and t < minutes:
                dc.DrawText('60', textPos, self.h - 93)
            
            if t == 19 and t < minutes:
                dc.DrawText('120', textPos, self.h - 93)
            
            if t == 29 and t < minutes:
                dc.DrawText('180', textPos, self.h - 93)
            
            if t - minutes == 6 and t > minutes and t < hour:
                dc.DrawText('6', textPos + 3, self.h - 93)
            
            if t - minutes == 12 and t > minutes and t < hour:
                dc.DrawText('12', textPos, self.h - 93)
            
            if t - hour == 6 and t > hour and t < hours:
                dc.DrawText('4', textPos, self.h - 93)
            
            if t - hour == 12 and t > hour and t < hours:
                dc.DrawText('8', textPos, self.h - 93)
            
            if t - hours in (1, 3):
                dc.DrawText(str((t - hours) * 10), textPos, self.h - 93)
                continue
        
        if maxX != None:
            if os.name in mac_names:
                offset = 5
            else:
                offset = 7
            dc.DrawText('X', maxX + self.bw / 2 - 4, maxY - offset)
            dc.DrawText(str(maxVal) + unit, maxX + self.bw / 2 + 3, maxY - 13 - offset)
        

    
    def OnPaintSignalLevel(self, event = None):
        dc = wx.PaintDC(self.signalLevelPanel)
        dc.Clear()
        if self.isTCS:
            if self.isZwembad:
                self.drawScale(dc, 10, 40, u'°C', 30)
                self.drawDataSet(dc, 3, 4, 10, 40, 100, 100, u'°C', noPeak = True, title = 'Zwembad:')
            else:
                self.drawScale(dc, 400, 1400, 'ppm', 20)
                self.drawDataSet(dc, 3, 4, 400, 1400, 900, 1300, 'ppm', noPeak = True, title = 'CO2 reading (ppm):')
        else:
            self.drawScale(dc, -48, 24, 'dBu', 12)
            self.drawDataSet(dc, 3, 4, -48, 24, 8, 14, 'dBu', title = 'Input Signal Level (dBu):')

    
    def OnPaintGainReduction(self, event = None):
        dc = wx.PaintDC(self.gainReductionPanel)
        dc.Clear()
        if self.isTCS:
            if self.isZwembad:
                self.drawScale(dc, -10, 40, u'°C', 50)
                self.drawDataSet(dc, 1, 2, -10, 40, 100, 100, u'°C', noPeak = True, title = 'Lucht:')
            else:
                self.drawScale(dc, -1250, 1250, 'Pa', 25)
                self.drawDataSet(dc, 5, 6, -1250, 1250, 400, 500, 'Pa', noPeak = True, title = 'Pressure Deviation (Pa):')
        else:
            self.drawScale(dc, 0, 15, 'dB', 15)
            self.drawDataSet(dc, 5, 6, 0, 15, 0, 6, 'dB', title = 'Gain Reduction (dB):')

    
    def OnPaintTemperature(self, event = None):
        dc = wx.PaintDC(self.temperaturePanel)
        dc.Clear()
        if self.isTCS:
            if self.isZwembad:
                self.drawScale(dc, 0, 60, u'°C', 60)
                self.drawDataSet(dc, 5, 6, 0, 60, 100, 100, u'°C', noPeak = True, title = 'Verwarming:')
            else:
                self.drawScale(dc, 0, 100, u'°C', 10)
                self.drawDataSet(dc, 1, 2, 0, 100, 66, 71, u'°C', noPeak = True, title = u'Temperature (°C):')
        else:
            self.drawScale(dc, 0, 100, u'°C', 10)
            self.drawDataSet(dc, 1, 2, 0, 100, 66, 71, u'°C', title = u'Temperature (°C):')



class Child_frame(wx.Frame):
    
    def __init__(self, parent, *args, **kwds):
        mystyle = wx.MINIMIZE_BOX | wx.CAPTION | wx.CLOSE_BOX | wx.CLIP_CHILDREN | wx.SYSTEM_MENU | wx.MAXIMIZE_BOX
        self.main_config = parent.main_config
        self.my_start_time = mytime.clock()
        self.last_sorry_time = 0
        self.history = { }
        self.lastRestoredId = None
        self.updating_from_nww = False
        self.startTime = mytime.clock()
        self.printedSyncTime = False
        self.__name__ = 'Child Frame'
        self.windowReference = None
        self.modelNameFromUi = [
            '',
            '',
            '',
            '']
        self.executeTask = None
        self.isClosed = False
        self.fastTimerRunning = False
        self.flashSizePrinted = False
        self.lastSelectedChannel = None
        self.lastSnapshotTime = datetime.datetime.now()
        self.blockSwitchViewWhenNotSynced = False
        self.shouldBeVisible = True
        self.clickTime = mytime.clock() + 1
        self.isVisible = False
        self.userBits = { }
        self.MAC = 'Uninitialized'
        
        try:
            import keyfile
        except:
            print mytime.displayTime() + ' Failed to import keyfile'
            traceback.print_exc(file = sys.stdout)

        
        try:
            self.preset_encryption_key = keyfile.preset_encryption_key
        except:
            self.preset_encryption_key = None

        
        try:
            self.backup_encryption_key = keyfile.backup_encryption_key
        except:
            self.backup_encryption_key = None

        
        try:
            self.no_border = self.main_config.get('ROOT', no_border)
            if self.no_border == 'yes':
                self.no_border = True
        except:
            if os.name in mac_names:
                self.no_border = False
            else:
                self.no_border = True

        if args[3] == True:
            self.mv_panel = True
        else:
            self.mv_panel = False
        args = args[:3]
        
        try:
            self.bgcolour = eval(self.main_config.get('ROOT', 'bgcolour'))
        except:
            self.bgcolour = (0, 0, 0)

        
        try:
            self.preset_extension = self.main_config.get('ROOT', 'preset_extension')
        except:
            self.preset_extension = 'preset'

        
        try:
            self.spk_lib_id = self.main_config.get('ROOT', 'speaker_lib_id')
        except:
            self.spk_lib_id = '#'

        self.svg_scale_x = 1
        self.svg_scale_y = 1
        self.svg_file_scale_x = 1
        self.svg_file_scale_y = 1
        if self.no_border:
            mystyle = wx.BORDER_NONE
        
        mystyle &= ~(wx.RESIZE_BORDER | wx.RESIZE_BOX | wx.MAXIMIZE_BOX)
        wx.Frame.__init__(self, style = mystyle, *args)
        if os.name in mac_names:
            self.bgpanel = wx.Panel(self, wx.ID_ANY, size = (2000, 2000))
            self.bgpanel.SetBackgroundColour(self.bgcolour)
        
        self.Show(False)
        self.init_done = False
        self.parent = parent
        self.updatingFirmware = False
        self.restartingAfterFirmwareUpdate = False
        self.restartingAfterFirmwareUpdateDelay = None
        self.SetBackgroundColour(self.bgcolour)
        self.server = parent.server
        self.last_index = 0
        self.index_button_name = ''
        self.progress = None
        self.alwaysGrantAccessToOutPanel = False
        self.views = None
        self.preset_accessrights = 0
        self.CanMaximize = False
        self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
        self.Bind(wx.EVT_SIZE, self.OnSize)
        self.storeWithKey = None

    
    def OnSize(self, e):
        if self.init_done == False:
            return None
        if self.no_border == True:
            self.frame_height = 0
        else:
            self.frame_height = 22
        self.AutoCenter(self.current_view, self.GetSize())

    
    def AutoCenter(self, view, size):
        
        try:
            client_area = wx.Display().GetClientArea()
            x = client_area[2]
            width = view.GetSize()[0]
            height = view.GetSize()[1] + self.frame_height
            x_pos = (size[0] - width) / 2
            if self.menubar != None:
                view.SetPosition((x_pos, self.menubar.GetSize()[1]))
                self.menubar.SetSize((size[0], self.menubar.GetSize()[1]))
            else:
                view.SetPosition((x_pos, 0))
        except:
            pass


    
    def OnLeftUp(self, e):
        pass

    
    def OnLeftDown(self, e):
        pass

    
    def refreshAccess(self):
        accesskey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_ACCESS_RIGHTS, 0, 0)
        self.remote_link.set_get_key(accesskey)
        userkey = data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0)
        self.remote_link.set_get_key(userkey)
        self.waitForSync('cu.rA', key = userkey)
        self.waitForSync('cu.rA', key = accesskey)
        current_user = self.model.get(data_model.Key(protocol.STRUCT_ID_GLOBAL, protocol.MEMBER_ID_CURRENT_USER, 0, 0), self.MAC)
        accesskey = data_model.Key(protocol.STRUCT_ID_PRESET_GLOBAL, protocol.MEMBER_ID_USER_ACCESS_RIGHTS, 0, current_user)
        self.remote_link.set_get_key(accesskey)
        self.waitForSync('cu.rA', key = accesskey)

    
    def get_access(self):
        
        try:
            if mytime.clock() - self.my_start_time > 10:
                skip_retry = True
            else:
                skip_retry = False
        except:
            skip_retry = False

        accessrights = 0
        current_user = 0
        
        try:
            if self.MAC[:4] in ('DEMO', 'GRPdeactivated', 'VN::'):
                self.full_access = True
                user_levels = {
                    one_unit.app.demo_locked_password: protocol.uLocked,
                    one_unit.app.demo_user_password: protocol.uUser,
                    one_unit.app.demo_admin_password: protocol.uAdmin,
                    one_unit.app.demo_developer_password: protocol.uDeveloper }
                accessrights = 0xFFFFFFFFL
                
                try:
                    current_user = user_levels[one_unit.app.check_password]
                except:
                    current_user = protocol.uUser

                self.accessrights = accessrights
                preset_accessrights = 0xFFFFFFFFL
                self.preset_accessrights = preset_accessrights
                if self.active_unit.link_type == 'USB' and self.MK2 == True:
                    if current_user < protocol.uAdmin:
                        current_user = protocol.uAdmin
                    
                
                if one_unit.app.always_show_full_graphics == True:
                    accessrights |= protocol.arShowFullSkin
                
                self.current_user = current_user
                self.a