Convenient Method for the vibrato effekt
@param aktMemo
528
protected void doVibratoEffekt(ChannelMemory aktMemo)
	{
		int periodAdd;
		switch (aktMemo.vibratoType & 0x03)
		{
			case 1: periodAdd = (Helpers.ModRampDownTable[aktMemo.vibratoTablePos]);	// Sawtooth
					break;
			case 2: periodAdd = (Helpers.ModSquareTable  [aktMemo.vibratoTablePos]);	// Squarewave
					break;
			case 3:	periodAdd = (Helpers.ModRandomTable  [aktMemo.vibratoTablePos]);	// Random.
					break;
			default:periodAdd = (Helpers.ModSinusTable   [aktMemo.vibratoTablePos]);	// Sinus
					break;
		}
		
		periodAdd = ((periodAdd<<4)*aktMemo.vibratoAmplitude) >> 7;
		setNewPlayerTuningFor(aktMemo, aktMemo.currentNotePeriod + periodAdd);
		
		aktMemo.vibratoTablePos = (aktMemo.vibratoTablePos + aktMemo.vibratoStep) & 0x3F;
	}
482025
@Override
	public void propagate(int evtmask) throws ContradictionException {
		ISet ker = g.getMandatoryNodes();
		ISet succ;
		for (int i : ker) {
			succ = g.getMandSuccOf(i);
			for (int j : succ) {
				g.enforceArc(j, i, this);
			}
		}
		gdm.unfreeze();
	}
1005966
def tremolo(self, freq, depth=40):
        """"""
        self.command.append("tremolo")
        self.command.append(freq)
        self.command.append(depth)
        return self
101882
public void setFeedback(final SpecTopic feedback) {
        if (feedback == null && this.feedback == null) {
            return;
        } else if (feedback == null) {
            removeChild(this.feedback);
            this.feedback = null;
        } else if (this.feedback == null) {
            feedback.setTopicType(TopicType.FEEDBACK);
            this.feedback = new KeyValueNode<SpecTopic>(CommonConstants.CS_FEEDBACK_TITLE, feedback);
            appendChild(this.feedback, false);
        } else {
            feedback.setTopicType(TopicType.FEEDBACK);
            this.feedback.setValue(feedback);
        }
    }
757601
protected int getFineTunePeriod(final ChannelMemory aktMemo)
	{
		if (frequencyTableType>=Helpers.AMIGA_TABLE)
			return (aktMemo.assignedNoteIndex==0)?0:getFineTunePeriod(aktMemo, aktMemo.assignedNoteIndex + aktMemo.currentTranspose);
		else
		if (frequencyTableType==Helpers.IT_LINEAR_TABLE || frequencyTableType==Helpers.STM_S3M_TABLE)
			return (aktMemo.assignedNoteIndex==0)?0:getFineTunePeriod(aktMemo, aktMemo.assignedNoteIndex);
		else
			return (aktMemo.assignedNotePeriod==0)?0:getFineTunePeriod(aktMemo, aktMemo.assignedNotePeriod<<4);
	}
280131
function() {

      var data = window.kelmu.data[id];
      var elemData = data.definitions['step' + data.stepNumber][data.subStepNumber][data.selectedElementNumber];

      editor.find('.kelmu-editor-pane').remove();

      var lineEditor = $('<div></div>').addClass('kelmu-line-editor').addClass('kelmu-editor-pane');
      lineEditor.appendTo(editor);

      lineEditor.append($('<h4>Line</h4>').css('margin', '15px 0px'));

      idCounter += 1;

      // Set the current values
      addComponent('Width:', lineEditor, 'kelmu-line-width', elemData.width, 'text', true);
      addComponent('Color:', lineEditor, 'kelmu-line-color', elemData.line, 'text');
      addComponent('With sound:', lineEditor, 'kelmu-line-sound-option', elemData.soundOption, 'text');

      // Save the modified properties
      var saveLine = function() {
        elemData.width = lineEditor.find('.kelmu-line-width').val() || window.kelmu.defaults.line.width;
        elemData.line = lineEditor.find('.kelmu-line-color').val() || window.kelmu.defaults.line.line;
        elemData.soundOption = lineEditor.find('.kelmu-line-sound-option').val() || window.kelmu.defaults.line.soundOption;
        window.kelmu.data[id].actions.update();
        updateView(true, true);
        notifyModifications();
      };

      lineEditor.find('input').keyup(saveLine);

      var buttonContainer = $('<div></div>').appendTo(lineEditor);

      createRemoveButton().appendTo(buttonContainer);

      // Save the modified properties
      $('<button></button>').text('Make default').addClass('btn').appendTo(buttonContainer).click(function(e) {
        e.preventDefault();
        window.kelmu.defaults.line.width = lineEditor.find('.kelmu-line-width').val() || lineDefaults.width;
        window.kelmu.defaults.line.line = lineEditor.find('.kelmu-line-color').val() || lineDefaults.line;
        window.kelmu.defaults.line.soundOption = lineEditor.find('.kelmu-line-sound-option').val() || lineDefaults.soundOption;
      });

    }
399005
private void setMasterTempo(double newTempo) {
        double oldTempo = Double.longBitsToDouble(masterTempo.getAndSet(Double.doubleToLongBits(newTempo)));
        if ((getTempoMaster() != null) && (Math.abs(newTempo - oldTempo) > getTempoEpsilon())) {
            // This is a change in tempo, so report it to any registered listeners, and update our metronome if we are synced.
            if (isSynced()) {
                metronome.setTempo(newTempo);
                notifyBeatSenderOfChange();
            }
            deliverTempoChangedAnnouncement(newTempo);
        }
    }
218287
def class_instrument_method(klass, method_to_instrument, event_name, payload={})
      class << klass; self; end.class_eval do
        Instrumentality.begin(self, method_to_instrument, event_name, payload)
      end
    end
1332182
def set_vibration(self, left_motor, right_motor, duration):
        """"""
        if left_motor and right_motor:
            return self._spin_up(self.double_rumble, duration/1000)
        if left_motor:
            return self._spin_up(self.left_rumble, duration/1000)
        if right_motor:
            return self._spin_up(self.right_rumble, duration/1000)
        return -1
277069
private static void showHelp()
	{
		Log.info("java -jar ./javamod [-rx] [-b{8,16,24}] [-s{+,-}] [-i{+,-}] [-w{+,-}] [-n{+,-}] [-m{+,-}] [-l{+,-}] [-h{+,-}] [-j{+,-}] [-v0.0-1.0]");
		Log.info("                    [-eWAVFILE] MODFILE\n");
		Log.info("-rx        : use Samplerate x (8000/11025/22050/44100/96000...");
		Log.info("                               anything allowed, your soundhardware supports)");
		Log.info("-b8/16/24  : #Bits per sample");
		Log.info("-s+/-      : Stereo/Mono");
		Log.info("-i0/1/2/3  : interpolation: 0:none; 1:linear; 2:cubic spline; 3:fir interpolation");
		Log.info("-tms       : ms of buffer size (30 is minimum)");
		Log.info("-w+/-      : do/don't wide stereo mix");
		Log.info("-n+/-      : do/don't noise reduction");
		Log.info("-m+/-      : do/don't mega bass");
		Log.info("-l0/1/2    : set infinit loop handling: 0:original; 1:fade out; 2:ignore");
		Log.info("-h+/-      : do/don't shuffle playlists after loading");
		Log.info("-j+/-      : do/don't repeat playlist");
		Log.info("-v0.0-1.0  : set volume");
		Log.info("-eWAVEFILE : export to wave file");
	}
1342160
private void startMusic(float pitch, float volume, boolean loop) {
		if (currentMusic != null) {
			currentMusic.stop();
			currentMusic.fireMusicSwapped(this);
		}
		
		currentMusic = this;
		if (volume < 0.0f)
			volume = 0.0f;
		if (volume > 1.0f)
			volume = 1.0f;

		sound.playAsMusic(pitch, volume, loop);
		playing = true;
		setVolume(volume);
		if (requiredPosition != -1) {
			setPosition(requiredPosition);
		}
	}
679750
protected void doPanningSlideEffekt(ChannelMemory aktMemo)
	{
		aktMemo.doSurround = false;
		aktMemo.panning += aktMemo.panningSlideValue;
	}
14954
function() {
    this.jsonInit({
      "message0": Blockly.Msg.SOUND_SETEFFECTO,
      "args0": [
        {
          "type": "field_dropdown",
          "name": "EFFECT",
          "options": [
            [Blockly.Msg.SOUND_EFFECTS_PITCH, 'PITCH'],
            [Blockly.Msg.SOUND_EFFECTS_PAN, 'PAN']
          ]
        },
        {
          "type": "input_value",
          "name": "VALUE"
        }
      ],
      "category": Blockly.Categories.sound,
      "extensions": ["colours_sounds", "shape_statement"]
    });
  }
705732
function (dt) {

        if (me.input.isKeyPressed("left")) {
            // update the entity velocity
            this.body.vel.x -= this.body.accel.x * me.timer.tick;
        } else if (me.input.isKeyPressed("right")) {
            // update the entity velocity
            this.body.vel.x += this.body.accel.x * me.timer.tick;
        } else {
            this.body.vel.x = 0;
        }
        if (me.input.isKeyPressed("up")) {
            // update the entity velocity
            this.body.vel.y -= this.body.accel.y * me.timer.tick;
        } else if (me.input.isKeyPressed("down")) {
            // update the entity velocity
            this.body.vel.y += this.body.accel.y * me.timer.tick;
        } else {
            this.body.vel.y = 0;
        }

        // apply physics to the body (this moves the entity)
        this.body.update(dt);

        // handle collisions against other shapes
        me.collision.check(this);

        // check if we moved (an "idle" animation would definitely be cleaner)
        if (this.body.vel.x !== 0 || this.body.vel.y !== 0) {
            this._super(me.Entity, "update", [dt]);
            return true;
        }
    }
1366585
def _stop_vibration_win(self):
        """"""
        xinput_set_state = self.manager.xinput.XInputSetState
        xinput_set_state.argtypes = [
            ctypes.c_uint, ctypes.POINTER(XinputVibration)]
        xinput_set_state.restype = ctypes.c_uint
        stop_vibration = ctypes.byref(XinputVibration(0, 0))
        xinput_set_state(self.__device_number, stop_vibration)
659676
@Override
	public void propagate(int evtmask) throws ContradictionException {
		if (waitFirstSol && model.getSolver().getSolutionCount() == 0) {
			return;//the UB does not allow to prune
		}
		// initialisation
		mandatoryArcsList.clear();
		for (int i = 0; i < n; i++) {
			Dmin[i] = D[i].getLB();
			Dmax[i] = D[i].getUB();
		}
		for (int i = 0; i < n; i++) {
			ISet nei = gV.getMandNeighOf(i);
			for (int j : nei) {
				if (i < j) {
					mandatoryArcsList.add(i * n + j);
				}
			}
		}
		updateCosts();
		lagrangianRelaxation();
	}
648766
private static void addModal_(RootPaneContainer rootPane,
								Component component, ModalListener listener,
								Integer modalDepth) {
	synchronized (modals) {
	  if (isModal(component) == false) {
		getModal(rootPane).addModal(component, listener, modalDepth);
	  }
	}
  }