TypeScript signaling.ISignal类代码示例

  /**
   * Handle a tab key press.
   */
  protected onTabEvent(event: KeyboardEvent, ch: number, line: number): void {
    const editor = this.editor;
    const doc = editor.getDoc();

    // If there is a text selection, no completion requests should be emitted.
    if (doc.getSelection()) {
      return;
    }

    const currentValue = doc.getValue();
    const currentLine = currentValue.split('\n')[line];

    // A completion request signal should only be emitted if the current
    // character or a preceding character is not whitespace.
    //
    // Otherwise, the default tab action of creating a tab character should be
    // allowed to propagate.
    if (!currentLine.substring(0, ch).match(/\S/)) {
      return;
    }

    event.preventDefault();
    event.stopPropagation();
    event.stopImmediatePropagation();

    const chHeight = editor.defaultTextHeight();
    const chWidth = editor.defaultCharWidth();
    const coords = editor.charCoords({ line, ch }, 'page') as ICoords;
    const position = editor.getDoc().indexFromPos({ line, ch });
    let data = {
      line, ch, chHeight, chWidth, coords, position, currentValue
    };
    this.completionRequested.emit(data as ICompletionRequest);
  }

 private _collapse() {
   this._collapsed = true;
   if (this._content) {
     this._content.hide();
   }
   this.removeClass(COLLAPSE_CLASS_OPEN);
   this.collapseChanged.emit(void 0);
 }

 private _uncollapse() {
   this._collapsed = false;
   if (this._content) {
     this._content.show();
   }
   this.addClass(COLLAPSE_CLASS_OPEN);
   this.collapseChanged.emit(void 0);
 }

 /**
  * Handle the DOM events for the widget.
  *
  * @param event - The DOM event sent to the widget.
  *
  * #### Notes
  * This method implements the DOM `EventListener` interface and is
  * called in response to events on the dock panel's node. It should
  * not be called directly by user code.
  */
 handleEvent(event: Event): void {
   switch (event.type) {
   case 'change':
     this.delimiterChanged.emit(this.selectNode.value);
     break;
   default:
     break;
   }
 }

 /**
  * Parse the content using the model's delimiter.
  *
  * #### Notes
  * This method will always return parsed content that has at most the display
  * limit worth of rows, currently maxing out at 1000 rows.
  */
 parse(): dsv.DSVParsedArray<dsv.DSVRowString> {
   let output = dsv.dsvFormat(this._delimiter).parse(this._content);
   let available = output.length;
   let maximum = DISPLAY_LIMIT;
   if (available > maximum) {
     // Mutate the array instead of slicing in order to conserve memory.
     output.splice(maximum);
     this.maxExceeded.emit({ available, maximum });
   }
   return output;
 }

 /**
  * Remove the item from the list at the specified index.
  *
  * @param index - The index of the item to remove. This must be
  *   an integer in the range `[0, internal.length)`.
  *
  * @returns The item removed from the list.
  *
  * #### Notes
  * This may be reimplemented by subclasses to customize the behavior.
  */
 protected removeItem(index: number): T {
   let item = this.internal.removeAt(index);
   this.changed.emit({
     type: 'remove',
     newIndex: -1,
     newValue: void 0,
     oldIndex: index,
     oldValue: item,
   });
   return item;
 }

 /**
  * Add an item to the list at the specified index.
  *
  * @param index - The index at which to add the item. This must be
  *   an integer in the range `[0, internal.length]`.
  *
  * @param item - The item to add at the specified index.
  *
  * @returns The index at which the item was added.
  *
  * #### Notes
  * This may be reimplemented by subclasses to customize the behavior.
  */
 protected addItem(index: number, item: T): number {
   this.internal.insert(index, item);
   this.changed.emit({
     type: 'add',
     newIndex: index,
     newValue: item,
     oldIndex: -1,
     oldValue: void 0,
   });
   return index;
 }

 /**
  * Set the item at a specific index in the list.
  *
  * @param index - The index of interest. This must be an integer in
  *   the range `[0, internal.length)`.
  *
  * @param item - The item to set at the index.
  *
  * @returns The item which previously occupied the specified index.
  *
  * #### Notes
  * This may be reimplemented by subclasses to customize the behavior.
  */
 protected setItem(index: number, item: T): T {
   let old = this.internal.at(index);
   this.internal.set(index, item);
   this.changed.emit({
     type: 'set',
     newIndex: index,
     newValue: item,
     oldIndex: index,
     oldValue: old,
   });
   return old;
 }

 let firstPass = () => {
   let now = (new Date()).getTime();
   let delta = now - start;
   if (delta > timeout) {
     expect(called).to.be(true);
     expect(emission).to.be(firstEmission);
     done();
     return;
   }
   signal.emit(secondEmission);
   // Restart the clock.
   start = (new Date()).getTime();
   setTimeout(secondPass, timeout - 100);
 };

 it('should be emitted after the signal has fired and a timeout', (done) => {
   let called = false;
   let monitor = new ActivityMonitor({ signal, timeout: 100 });
   monitor.activityStopped.connect((sender, args) => {
     expect(sender).to.be(monitor);
     expect(args.sender).to.be(testObj);
     expect(args.args).to.be(10);
     called = true;
   });
   signal.emit(10);
   expect(called).to.be(false);
   setTimeout(() => {
     expect(called).to.be(true);
     done();
   }, 100);
 });