BeremizIDE.py
branchsvghmi
changeset 3166 275eadf598e8
parent 2704 4ba3bdc7d71f
child 2728 10d8ca7a3d31
equal deleted inserted replaced
3165:2db69e2c5673 3166:275eadf598e8
   133     def write(self, s, style=None):
   133     def write(self, s, style=None):
   134         if self.lock.acquire():
   134         if self.lock.acquire():
   135             self.stack.append((s, style))
   135             self.stack.append((s, style))
   136             self.lock.release()
   136             self.lock.release()
   137             current_time = gettime()
   137             current_time = gettime()
   138             self.TimerAccessLock.acquire()
   138             with self.TimerAccessLock:
   139             if self.LastRefreshTimer:
   139                 if self.LastRefreshTimer is not None:
   140                 self.LastRefreshTimer.cancel()
   140                     self.LastRefreshTimer.cancel()
   141                 self.LastRefreshTimer = None
   141                     self.LastRefreshTimer = None
   142             self.TimerAccessLock.release()
   142             elapsed = current_time - self.LastRefreshTime
   143             if current_time - self.LastRefreshTime > REFRESH_PERIOD and self.RefreshLock.acquire(False):
   143             if elapsed > REFRESH_PERIOD:
   144                 self._should_write()
   144                 self._should_write()
   145             else:
   145             else:
   146                 self.TimerAccessLock.acquire()
   146                 with self.TimerAccessLock:
   147                 self.LastRefreshTimer = Timer(REFRESH_PERIOD, self._timer_expired)
   147                     if self.LastRefreshTimer is None:
   148                 self.LastRefreshTimer.start()
   148                         self.LastRefreshTimer = Timer(REFRESH_PERIOD - elapsed, self._timer_expired)
   149                 self.TimerAccessLock.release()
   149                         self.LastRefreshTimer.start()
   150 
   150 
   151     def _timer_expired(self):
   151     def _timer_expired(self):
   152         if self.RefreshLock.acquire(False):
   152         self._should_write()
   153             self._should_write()
   153         with self.TimerAccessLock:
   154         else:
   154             self.LastRefreshTimer = None
   155             self.TimerAccessLock.acquire()
       
   156             self.LastRefreshTimer = Timer(REFRESH_PERIOD, self._timer_expired)
       
   157             self.LastRefreshTimer.start()
       
   158             self.TimerAccessLock.release()
       
   159 
   155 
   160     def _should_write(self):
   156     def _should_write(self):
   161         app = wx.GetApp()
       
   162         if app is not None:
       
   163             wx.CallAfter(self._write)
       
   164 
       
   165         if MainThread == currentThread().ident:
   157         if MainThread == currentThread().ident:
       
   158             app = wx.GetApp()
   166             if app is not None:
   159             if app is not None:
       
   160                 self._write()
   167                 if self.YieldLock.acquire(0):
   161                 if self.YieldLock.acquire(0):
   168                     app.Yield()
   162                     app.Yield()
   169                     self.YieldLock.release()
   163                     self.YieldLock.release()
       
   164         else:
       
   165             with self.RefreshLock:
       
   166                 if not self.refreshPending:
       
   167                     self.refreshPending = True
       
   168                     wx.CallAfter(self._write)
   170 
   169 
   171     def _write(self):
   170     def _write(self):
   172         if self.output:
   171         if self.output:
   173             self.output.Freeze()
   172             with self.RefreshLock:
   174             self.lock.acquire()
   173                 self.output.Freeze()
   175             for s, style in self.stack:
   174                 self.lock.acquire()
   176                 if style is None:
   175                 for s, style in self.stack:
   177                     style = self.black_white
   176                     if style is None:
   178                 if style != self.black_white:
   177                         style = self.black_white
   179                     self.output.StartStyling(self.output.GetLength(), 0xff)
   178                     if style != self.black_white:
   180 
   179                         self.output.StartStyling(self.output.GetLength(), 0xff)
   181                 # Temporary deactivate read only mode on StyledTextCtrl for
   180 
   182                 # adding text. It seems that text modifications, even
   181                     # Temporary deactivate read only mode on StyledTextCtrl for
   183                 # programmatically, are disabled in StyledTextCtrl when read
   182                     # adding text. It seems that text modifications, even
   184                 # only is active
   183                     # programmatically, are disabled in StyledTextCtrl when read
   185                 start_pos = self.output.GetLength()
   184                     # only is active
   186                 self.output.SetReadOnly(False)
   185                     start_pos = self.output.GetLength()
   187                 self.output.AppendText(s)
   186                     self.output.SetReadOnly(False)
   188                 self.output.SetReadOnly(True)
   187                     self.output.AppendText(s)
   189                 text_len = self.output.GetLength() - start_pos
   188                     self.output.SetReadOnly(True)
   190 
   189                     text_len = self.output.GetLength() - start_pos
   191                 if style != self.black_white:
   190 
   192                     self.output.SetStyling(text_len, style)
   191                     if style != self.black_white:
   193             self.stack = []
   192                         self.output.SetStyling(text_len, style)
   194             self.lock.release()
   193                 self.stack = []
   195             self.output.Thaw()
   194                 self.lock.release()
   196             self.LastRefreshTime = gettime()
   195                 self.output.Thaw()
   197             try:
   196                 self.LastRefreshTime = gettime()
   198                 self.RefreshLock.release()
   197                 newtime = time.time()
   199             except Exception:
   198                 if newtime - self.rising_timer > 1:
   200                 pass
   199                     self.risecall(self.output)
   201             newtime = time.time()
   200                 self.rising_timer = newtime
   202             if newtime - self.rising_timer > 1:
   201                 self.refreshPending = False
   203                 self.risecall(self.output)
   202 
   204             self.rising_timer = newtime
       
   205 
   203 
   206     def write_warning(self, s):
   204     def write_warning(self, s):
   207         self.write(s, self.red_white)
   205         self.write(s, self.red_white)
   208 
   206 
   209     def write_error(self, s):
   207     def write_error(self, s):