code: public void tick (long now)
      {
          if (!_enabled) {
              return;
          }
  
          // Initialize the starting time if necessary
          if (_start == Long.MIN_VALUE) {
              _start = now - Math.round(_duration * _complete);
          }
  
          // Initialize the timestamp of the rendering error if necessary
          if (_renderOffsetTime == Long.MIN_VALUE) {
              _renderOffsetTime = now;
          }
  
          // If the timer was just unpaused, handle the updates that
          // need a timestamp
          if (_processUnpause) {
              _processUnpause = false;
              _start += now - _lastUpdate;
          }
  
          // Update the completion and triggers when the timer is running
          if (running())
          {
              // Figure out how what percent the timer has completed
              _lastUpdate = now;
              _complete = ((float) (_lastUpdate - _start)) / _duration;
  
              // Handle warning trigger if necessary
              if (triggeredWarning()) {
                  handleWarning();
              }
  
              // Handle completion trigger if necessary
              if (triggeredCompleted()) {
                  handleCompleted();
              }
          }
  
          // Add error to the render completion percent if the interpolation
          // hasn't finished yet
          _renderComplete = _complete;
          if (_renderOffsetTime + _transitionTime > now) {
              _renderComplete += _renderOffset *
                  (1f - (now - _renderOffsetTime) / (float) _transitionTime);
              _renderComplete = Math.max(0f, Math.min(1f, _renderComplete));
          }
  
          // Possibly orce a repaint if the render level changed (highly
          // probable but not guaranteed)
          if (_renderComplete != _paintComplete)
          {
              // Always force a repaint when changing to or from a boundary
              if (_renderComplete <= 0f || _paintComplete <= 0f ||
                  _renderComplete >= 1f || _paintComplete >= 1f)
              {
                  invalidate();
              }
  
              // Also force a repaint if the completion state sufficiently
              // changed
              else if (Math.abs(_renderComplete - _paintComplete) >
                       _changeThreshold)
              {
                  invalidate();
              }
          }
      }
docs: documentation inherited