Initialises a newly instantiated Target.

@private
@instance
@since   3.0.0
@param   {(Element|null)}    el
@param   {object}            mixer
@param   {object}            [data]
@return  {void}
543704
function(el, mixer, data) {
            var self = this,
                id   = '';

            self.callActions('beforeInit', arguments);

            self.mixer = mixer;

            if (!el) {
                // If no element is provided, render it

                el = self.render(data);
            }

            self.cacheDom(el);

            self.bindEvents();

            if (self.dom.el.style.display !== 'none') {
                self.isShown = true;
            }

            if (data && mixer.config.data.uidKey) {
                if (typeof (id = data[mixer.config.data.uidKey]) === 'undefined' || id.toString().length < 1) {
                    throw new TypeError(mixitup.messages.errorDatasetInvalidUidKey({
                        uidKey: mixer.config.data.uidKey
                    }));
                }

                self.id     = id;
                self.data   = data;

                mixer.cache[id] = self;
            }

            self.callActions('afterInit', arguments);
        }
1056557
public void processingInstruction(String target, String data)
        throws SAXException {
        trace("processingInstruction");
        ProcessingInstruction instruction =
            currentDocument.createProcessingInstruction(target, data);
        appendNode(instruction);
    }
1055629
private Mixer createNewMixer()
	{
		Mixer mixer = getCurrentContainer().createNewMixer();
		if (mixer!=null)
		{
			mixer.setAudioProcessor(audioProcessor);
			mixer.setVolume(currentVolume);
			mixer.setBalance(currentBalance);
			mixer.setSoundOutputStream(getSoundOutputStream());
			getSeekBarPanel().setCurrentMixer(mixer);
		}
		return mixer;
	}
126860
function initNew (args) {
    // get module
    var module = this.component.module
    // if module has new method run it
    if (module.new) {
        // call new method with original new args
        this.promise = module.new(args.args).then(res => {
            // if new returns undefined do not set
            if (!defined(res)) {
                return
            }
            // require data to be object
            this.assert(typeof res === 'object' && res, 110)
            // if data is set then use it
            if (defined(res.data)) {
                // require data to be object
                this.assert(typeof res.data === 'object' && res.data, 110)
                // set component data to data returned by new method
                this.data = res.data
            }
            // if id set set it data use it
            if (defined(res.id)) {
                this.id = res.id
            }
        })
    }
    // otherwise set resolved promise
    else {
        // use any args for data
        _.merge(this.data, args.args)
        // set init promise as resolved
        this.promise = Promise.resolve()
    }
}
902410
function(el) {
            var that = this;
            var d = Q.defer();

            if (this.view != null) el = el || this.view.$el;
            this.on("loaded", function() {
                if (this.content == null) return;
                if (this.view != null) this.view.clearComponents();
                this.generate(this.args).then(function(content) {
                    el.html(content);
                    if (that.view != null) that.view.renderComponents();
                    that.trigger("updated");
                    d.resolve(el);
                }, function(err) {
                    logging.exception(err, "Error with template:");
                    d.reject(err);
                });
                
            }, this);
            this.load();

            return d.promise;
        }
530344
public void init(){
        if(!initiated){
            try {
                AL.create();
                //init the listener
                FloatBuffer listenerOri = BufferUtils.createFloatBuffer(6).put(
                        new float[]{0.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f});
                FloatBuffer listenerVel = BufferUtils.createFloatBuffer(3).put(
                        new float[]{0.0f, 0.0f, 0.0f});
                FloatBuffer listenerPos = BufferUtils.createFloatBuffer(3).put(
                        new float[]{0.0f, 0.0f, 0.0f});
                listenerPos.flip();
                listenerVel.flip();
                listenerOri.flip();
                AL10.alListener(AL10.AL_POSITION, listenerPos);
                AL10.alListener(AL10.AL_VELOCITY, listenerVel);
                AL10.alListener(AL10.AL_ORIENTATION, listenerOri);
                //init streamer
                musicStreamer.init();
                //pregenerate sound sources
                int validSources = 0;
                for(int i = 0; i < MAX_SOURCES; i++){
                    SoundSourceEntry e = new SoundSourceEntry();
                    AL10.alGenSources(e.sourceId);
                    if (AL10.alGetError() == AL10.AL_NO_ERROR) {
                        sources.add(e);
                        validSources++;
                    }
                }
                logger.log(Level.INFO, "SoundEngine initiated with {0} sources", validSources);
                initiated = true;
            } catch (LWJGLException ex) {
                logger.log(Level.WARNING, "Initiating sound engine", ex);
            }
        }
    }
130241
public void init(Converter converter, Record recordTarget, int iKeyArea)
    {
        super.init(converter, Constants.BLANK, true);

        m_iKeyArea = iKeyArea;
        m_recordTarget = recordTarget;
        m_objTarget = Integer.toString(iKeyArea);
        
        m_strAltDesc = "Key " + m_objTarget;    // Default
        if (m_recordTarget != null)
        {
            BaseField mainField = m_recordTarget.getTable().getCurrentTable().getRecord().getKeyArea(m_iKeyArea).getField(DBConstants.MAIN_KEY_FIELD);
            m_strAltDesc = mainField.getFieldDesc();
        }
    }
530704
public void init(Reader reader, Record record, SaxHtmlHandler handler)
    {
        m_handler = null;
        m_handler = handler;
        super.init(reader, record);
    }
877355
function componentMixin(tag$$1) {
      var mixins = [], len = arguments.length - 1;
      while ( len-- > 0 ) mixins[ len ] = arguments[ len + 1 ];

      each(mixins, function (mix) {
        var instance;
        var obj;
        var props = [];

        // properties blacklisted and will not be bound to the tag instance
        var propsBlacklist = ['init', '__proto__'];

        mix = isString(mix) ? mixin(mix) : mix;

        // check if the mixin is a function
        if (isFunction$1(mix)) {
          // create the new mixin instance
          instance = new mix();
        } else { instance = mix; }

        var proto = Object.getPrototypeOf(instance);

        // build multilevel prototype inheritance chain property list
        do { props = props.concat(Object.getOwnPropertyNames(obj || instance)); }
        while (obj = Object.getPrototypeOf(obj || instance))

        // loop the keys in the function prototype or the all object keys
        each(props, function (key) {
          // bind methods to tag
          // allow mixins to override other properties/parent mixins
          if (!contains(propsBlacklist, key)) {
            // check for getters/setters
            var descriptor = getPropDescriptor(instance, key) || getPropDescriptor(proto, key);
            var hasGetterSetter = descriptor && (descriptor.get || descriptor.set);

            // apply method only if it does not already exist on the instance
            if (!tag$$1.hasOwnProperty(key) && hasGetterSetter) {
              Object.defineProperty(tag$$1, key, descriptor);
            } else {
              tag$$1[key] = isFunction$1(instance[key]) ?
                instance[key].bind(tag$$1) :
                instance[key];
            }
          }
        });

        // init method will be called automatically
        if (instance.init)
          { instance.init.bind(tag$$1)(tag$$1.opts); }
      });

      return tag$$1
    }
847252
function initComponents( editor ) {
		// Documented in dataprocessor.js.
		editor.dataProcessor = new CKEDITOR.htmlDataProcessor( editor );

		// Set activeFilter directly to avoid firing event.
		editor.filter = editor.activeFilter = new CKEDITOR.filter( editor );

		loadSkin( editor );
	}
615321
function(el, eventName, data)
    {
        var ev;

        if (document.createEvent) {
            ev = document.createEvent('HTMLEvents');
            ev.initEvent(eventName, true, false);
            ev = extend(ev, data);
            el.dispatchEvent(ev);
        } else if (document.createEventObject) {
            ev = document.createEventObject();
            ev = extend(ev, data);
            el.fireEvent('on' + eventName, ev);
        }
    }
603698
function mergeInner(base, mixin, mergeArrays) {
    if (base === null || typeof base !== 'object' || Array.isArray(base)) {
        throw new Error('base must be object');
    }
    if (mixin === null || typeof mixin !== 'object' || Array.isArray(mixin)) {
        throw new Error('mixin must be object');
    }
    Object.keys(mixin).forEach((name) => {
        mergeHelper(base, mixin, name, mergeArrays);
    });
}
1324243
public void initialize(ControlBean bean, Object target)
    {
        initServices(bean, target);
        initControls(bean, target);
        initEventProxies(bean, target);
    }
647799
function(element, options) {
      options || (options = { });

      this.callSuper('initialize', options);
      this._initElement(element);
      this._originalImage = this.getElement();
      this._initConfig(options);

      this.filters = [ ];

      if (options.filters) {
        this.filters = options.filters;
        this.applyFilters();
      }
    }
516332
public void init() {
    	try {
			AL.create();
			soundWorks = true;
		} catch (LWJGLException e) {
			System.err.println("Failed to initialise LWJGL OpenAL");
			soundWorks = false;
			return;
		}
		
		if (soundWorks) {
			IntBuffer sources = BufferUtils.createIntBuffer(1);
			AL10.alGenSources(sources);
			
			if (AL10.alGetError() != AL10.AL_NO_ERROR) {
				System.err.println("Failed to create sources");
				soundWorks = false;
			} else {
				source = sources.get(0);
			}
			
		}
    }
1163435
function init(entry) {  // {{{2
/**
 * Socket constructor
 *
 * @param entry {Object} Media player entry
 *
 * @method constructor
 */

  if ('playbackSocket' in entry) {
    throw O.log.error(this, 'DUPLICIT_PLAYBACK', entry.toString());
  }

  entry.playbackSocket = this;
  this.entry = entry;

  entry.shard.track(entry.dval.playback, this);
}
47812
public void initializeMixer()
	{
		// to be a bit faster, we do some precalculations
		calculateGlobalTuning();
		
		// get Mod specific values
		frequencyTableType = mod.getFrequencyTable();
		currentTempo = mod.getTempo();
		currentBPM = mod.getBPMSpeed();
		globalVolume = mod.getBaseVolume();
		globalVolumSlideValue = 0;
		useFastSlides = mod.doFastSlides();
		
		samplePerTicks = calculateSamplesPerTick();
		
		currentTick = currentArrangement = currentRow = patternDelayCount = patternTicksDelayCount = 0;
		currentArrangement = 0;
		currentPatternIndex = mod.getArrangement()[currentArrangement];
		currentPattern = mod.getPatternContainer().getPattern(currentPatternIndex);
		
		patternJumpPatternIndex = patternBreakRowIndex = patternBreakJumpPatternIndex = -1;
		
		modFinished = false;
		
		calculateVolRampLen();
		
		// Reset all rowes played to false
		mod.resetLoopRecognition();

		// Reset FadeOut
		doFadeOut = false;
		fadeOutFac = 8;
		fadeOutValue = 1<<fadeOutFac;
		fadeOutSub = 0x01;
		
		final int nChannels = mod.getNChannels();
		// Now initialize every used channel
		for (int c=0; c<maxChannels; c++)
		{
			channelMemory[c] = new ChannelMemory();
			
			if (c<nChannels)
			{
				final ChannelMemory aktMemo = channelMemory[c];
				aktMemo.panning = mod.getPanningValue(c);
				aktMemo.channelVolume = mod.getChannelVolume(c); 
				initializeMixer(c, aktMemo);
			}
		}
	}