Get an event and create an alias to the push function.
@param string $name eventName
@param boolean $hidden ?
@return wnEvent
763684
function (name,hidden)
		{
			var eventName = 'event-'+name;
			if (_events[eventName] != undefined) 
				return _events[eventName];
			else
			{
				if (!_eventsConfig[eventName] || !this.c)
					return false;
				var config = _eventsConfig[eventName] || {},
					_class = config.class;
				config.id = eventName;
				config.autoInit = false;
				var evt = this.createClass(_class,config);
				if (evt)
				{
					evt.setParent(this);
					evt.init();
					if (hidden != false)
					{
						_events[eventName] = evt;
						this.e[name]=evt.emit;
					} else
					{
						Object.defineProperty(_events[eventName],{ value: evt, enumerable: false });
					}
					return evt;
				}
				return false;
			}
		}
277824
public function get($name, $default = null)
    {
        if (array_key_exists($name, $this->eventData)) {
            return $this->eventData[$name];
        }

        return $default;
    }
10046
public function getJs($name)
    {
        switch ($this->getType()) {
            case EventType::DEFAULT_ONCE:
                return $this->getEventJs($name, true);
            case EventType::DOM:
                return $this->getDomEventJs($name);
            case EventType::DOM_ONCE:
                return $this->getDomEventJs($name, true);
            case EventType::DEFAULT_EVENT:
            default:
                return $this->getEventJs($name);
        }
    }
572706
public function register(string $name, $callback) : Event
    {
        if (is_null($name)) {
            throw new \RuntimeException(sprintf('Event name cannot be empty in %s', __FUNCTION__));
        }

        if (is_null($callback)) {
            throw new \RuntimeException(sprintf('Empty parameter passed as callback in %s function', __FUNCTION__));
        }

        if (!isset($this->events[$name])) {
            $this->events[$name] = [];
        }

        if (!in_array($callback, $this->events[$name])) {
            $this->events[$name][] = $callback;
        }

        return $this;
    }
1225398
public function get($name)
    {
        $this->eventDispatcher->dispatch(Events::PRE_GET, new SettingActionEvent($name, [], null));

        /** @var Setting $setting */
        $setting = $this->repo->findOneBy(['name.name' => $name]);

        $this->eventDispatcher->dispatch(Events::PRE_GET, new SettingActionEvent($name, [], $setting));

        return $setting;
    }
661899
public static function trigger(string $name, ?array $args = null)
  {
    if (!isset(self::$events[$name])) return false;

    foreach (self::$events[$name] as $event => $callback) {
      if (is_callable($callback)) {
        return call_user_func_array($callback, isset($args) ? $args : []);
      }
      else if (is_array($callback)) {
        (new Events)->triggerGroup($callback, $args);
      }
      else if (is_string($callback)) {
        $call = new $callback;
        return call_user_func_array([$call, 'persist'], $args ?? []);
      }
    }
  }
1370749
public static function hidden(string $name, string $value = '', array $attributes = null) : string
    {
        // Set the input type
        $attributes['type'] = 'hidden';

        return Form::input($name, $value, $attributes);
    }
199521
public function getNewActionEvent(string $name = null, $target = null, $params = null): ActionEvent
    {
        if ($name === null) {
            $name = 'action_event';
        }

        return new DefaultActionEvent($name, $target, $params);
    }
162182
public function dispatchEvent($name, $event = array())
    {
        $result = array();
        
        //Make sure we have an event object
        if (! $event instanceof AnEvent) {
            $event = new AnEvent($event);
        }
        
        $event->setName($name)->setDispatcher($this);
             
        //Nofity the listeners
        if (isset($this->_listeners[$name])) {
            foreach ($this->_listeners[$name] as $listener) {
                $listener->$name($event);
                
                if (! $event->canPropagate()) {
                    break;
                }
            }
        }
        
        return $this;
    }
968419
public static function getNew($id, $name = '')
    {
        $container = self::getContainer($name);

        return $container->getNew($id);
    }
996491
protected static function trigger($name)
    {
        if (isset(static::$_hooks[$name])) {
            $events = [];
            
            foreach (static::$_hooks[$name] as $hookEvent) {
                if ($hookEvent->isHandled) {
                    continue;
                }
                
                if (is_array($hookEvent->handler)) {
                    $hookEvent->output = call_user_func_array($hookEvent->handler, [$hookEvent]);
                } elseif (is_callable($hookEvent->handler)) {
                    $hookEvent->output = call_user_func($hookEvent->handler, $hookEvent);
                } else {
                    throw new Exception("The provided hook event handler is not valid.");
                }
                
                $hookEvent->isHandled = true;
                
                if ($hookEvent->isValid) {
                    $events[] = $hookEvent;
                }
            }

            return $events;
        }

        return [];
    }
1098104
public function getStatus($name = '') {
        if ($name != '') {
            if (isset($this->_events[$name])) {
                return $this->_events[$name]->getStatus();
            }
            else {
                return false;
            }
        }
        else {
            return false;
        }
    }
110801
protected function normalizeFileEvent($event, $name)
    {
        if ('new' === $event) {
            return IN_CREATE;
        }

        $event = $this->normalizeEvent($event);
        if (isset($this->files[$name])) {
            return $this->isCreated($event) ? IN_MODIFY : $event;
        }
        if (!$this->isDeleted($event)) {
            $this->createFileResource($name);

            return IN_CREATE;
        }

        return null;
    }
755061
public function getPusher($name)
    {
        if (!$this->hasPusher($name)) {
            throw new \InvalidArgumentException(sprintf('A pusher named "%s" has not been registered.', $name));
        }

        return $this->pushers[$name];
    }
528557
function buildEvent (id, title, display, hidden = {}) {
  const eventObj = {
    id,
    title,
    display,
    hidden,
    status: 'active',
    timestamp: new Date(Date.now()).toISOString()
  };
  return eventObj;
}
1176310
public static function form_hidden($name, $value = '')
    {
        if (is_string($name)) {
            return '<input type="hidden" id="'. $name .'" name="'. $name .'" value="'. $value .'" />'."\n";
        } elseif (is_array($name)) {
            $hidden = '';
            foreach ($name as $k => $v) {
                $hidden .= '<input type="hidden" id="'. $k .'" name="'. $k .'" value="'. $v .'" />'."\n";
            }
            return $hidden;
        } else {
            return '';
        }
    }
630005
public function setHidden($hidden = true)
    {
        foreach ($this->results as $name) {
            $this->columns->offsetGet($name)->setHidden($hidden);
        }

        return $this;
    }