クラス yii\base\WidgetEvent

                public function __call($name, $params)
{
    throw new UnknownMethodException('Calling unknown method: ' . get_class($this) . "::$name()");
}

            

                public function __construct($config = [])
{
    if (!empty($config)) {
        Yii::configure($this, $config);
    }
    $this->init();
}

            

                public function __get($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter();
    } elseif (method_exists($this, 'set' . $name)) {
        throw new InvalidCallException('Getting write-only property: ' . get_class($this) . '::' . $name);
    }
    throw new UnknownPropertyException('Getting unknown property: ' . get_class($this) . '::' . $name);
}

            

                public function __isset($name)
{
    $getter = 'get' . $name;
    if (method_exists($this, $getter)) {
        return $this->$getter() !== null;
    }
    return false;
}

            

                public function __set($name, $value)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter($value);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Setting read-only property: ' . get_class($this) . '::' . $name);
    } else {
        throw new UnknownPropertyException('Setting unknown property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function __unset($name)
{
    $setter = 'set' . $name;
    if (method_exists($this, $setter)) {
        $this->$setter(null);
    } elseif (method_exists($this, 'get' . $name)) {
        throw new InvalidCallException('Unsetting read-only property: ' . get_class($this) . '::' . $name);
    }
}

            

                public function canGetProperty($name, $checkVars = true)
{
    return method_exists($this, 'get' . $name) || $checkVars && property_exists($this, $name);
}

            

                public function canSetProperty($name, $checkVars = true)
{
    return method_exists($this, 'set' . $name) || $checkVars && property_exists($this, $name);
}

            

                public static function className()
{
    return get_called_class();
}

            

                public static function hasHandlers($class, $name)
{
    if (empty(self::$_eventWildcards) && empty(self::$_events[$name])) {
        return false;
    }
    if (is_object($class)) {
        $class = get_class($class);
    } else {
        $class = ltrim($class, '\\');
    }
    $classes = array_merge(
        [$class],
        class_parents($class, true),
        class_implements($class, true)
    );
    // regular events
    foreach ($classes as $className) {
        if (!empty(self::$_events[$name][$className])) {
            return true;
        }
    }
    // wildcard events
    foreach (self::$_eventWildcards as $nameWildcard => $classHandlers) {
        if (!StringHelper::matchWildcard($nameWildcard, $name, ['escape' => false])) {
            continue;
        }
        foreach ($classHandlers as $classWildcard => $handlers) {
            if (empty($handlers)) {
                continue;
            }
            foreach ($classes as $className) {
                if (StringHelper::matchWildcard($classWildcard, $className, ['escape' => false])) {
                    return true;
                }
            }
        }
    }
    return false;
}

            

                public function hasMethod($name)
{
    return method_exists($this, $name);
}

            

                public function hasProperty($name, $checkVars = true)
{
    return $this->canGetProperty($name, $checkVars) || $this->canSetProperty($name, false);
}

            

                public function init()
{
}

            

                public static function off($class, $name, $handler = null)
{
    $class = ltrim($class, '\\');
    if (empty(self::$_events[$name][$class]) && empty(self::$_eventWildcards[$name][$class])) {
        return false;
    }
    if ($handler === null) {
        unset(self::$_events[$name][$class]);
        unset(self::$_eventWildcards[$name][$class]);
        return true;
    }
    // plain event names
    if (isset(self::$_events[$name][$class])) {
        $removed = false;
        foreach (self::$_events[$name][$class] as $i => $event) {
            if ($event[0] === $handler) {
                unset(self::$_events[$name][$class][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            self::$_events[$name][$class] = array_values(self::$_events[$name][$class]);
            return true;
        }
    }
    // wildcard event names
    $removed = false;
    if (isset(self::$_eventWildcards[$name][$class])) {
        foreach (self::$_eventWildcards[$name][$class] as $i => $event) {
            if ($event[0] === $handler) {
                unset(self::$_eventWildcards[$name][$class][$i]);
                $removed = true;
            }
        }
        if ($removed) {
            self::$_eventWildcards[$name][$class] = array_values(self::$_eventWildcards[$name][$class]);
            // remove empty wildcards to save future redundant regex checks :
            if (empty(self::$_eventWildcards[$name][$class])) {
                unset(self::$_eventWildcards[$name][$class]);
                if (empty(self::$_eventWildcards[$name])) {
                    unset(self::$_eventWildcards[$name]);
                }
            }
        }
    }
    return $removed;
}

            

                public static function offAll()
{
    self::$_events = [];
    self::$_eventWildcards = [];
}

            

                public static function on($class, $name, $handler, $data = null, $append = true)
{
    $class = ltrim($class, '\\');
    if (strpos($class, '*') !== false || strpos($name, '*') !== false) {
        if ($append || empty(self::$_eventWildcards[$name][$class])) {
            self::$_eventWildcards[$name][$class][] = [$handler, $data];
        } else {
            array_unshift(self::$_eventWildcards[$name][$class], [$handler, $data]);
        }
        return;
    }
    if ($append || empty(self::$_events[$name][$class])) {
        self::$_events[$name][$class][] = [$handler, $data];
    } else {
        array_unshift(self::$_events[$name][$class], [$handler, $data]);
    }
}

            

                public static function trigger($class, $name, $event = null)
{
    $wildcardEventHandlers = [];
    foreach (self::$_eventWildcards as $nameWildcard => $classHandlers) {
        if (!StringHelper::matchWildcard($nameWildcard, $name)) {
            continue;
        }
        $wildcardEventHandlers = array_merge($wildcardEventHandlers, $classHandlers);
    }
    if (empty(self::$_events[$name]) && empty($wildcardEventHandlers)) {
        return;
    }
    if ($event === null) {
        $event = new static();
    }
    $event->handled = false;
    $event->name = $name;
    if (is_object($class)) {
        if ($event->sender === null) {
            $event->sender = $class;
        }
        $class = get_class($class);
    } else {
        $class = ltrim($class, '\\');
    }
    $classes = array_merge(
        [$class],
        class_parents($class, true),
        class_implements($class, true)
    );
    foreach ($classes as $class) {
        $eventHandlers = [];
        foreach ($wildcardEventHandlers as $classWildcard => $handlers) {
            if (StringHelper::matchWildcard($classWildcard, $class, ['escape' => false])) {
                $eventHandlers = array_merge($eventHandlers, $handlers);
                unset($wildcardEventHandlers[$classWildcard]);
            }
        }
        if (!empty(self::$_events[$name][$class])) {
            $eventHandlers = array_merge($eventHandlers, self::$_events[$name][$class]);
        }
        foreach ($eventHandlers as $handler) {
            $event->data = $handler[1];
            call_user_func($handler[0], $event);
            if ($event->handled) {
                return;
            }
        }
    }
}