By means of class reflection, gets a list of all the classnames of the stock widgets
@return string[]
547477
private static function getStockWidgets ()
    {
        $reflectionClass = new \ReflectionClass(get_class());
        $classNames      = array();
        foreach ($reflectionClass->getConstants() as $name => $value)
            if (preg_match('/^STOCK_WP/', $name))
                $classNames[] = $value;
        return $classNames;
    }
422408
def get_all_widget_classes():
    
    from leonardo.module.web.models import Widget
    _widgets = getattr(settings,
                       'WIDGETS', Widget.__subclasses__())
    widgets = []
    if isinstance(_widgets, dict):
        for group, widget_cls in six.iteritems(_widgets):
            widgets.extend(widget_cls)
    elif isinstance(_widgets, list):
        widgets = _widgets
    return load_widget_classes(widgets)
330920
public function getCaptionClassNames()
    {
        $classes = ['slide-caption'];
        
        if ($this->getParent()->hasMethod('getCaptionClassNames')) {
            $classes = array_merge($classes, $this->getParent()->getCaptionClassNames($this));
        }
        
        if ($this->TitleAfterCaption) {
            $classes[] = 'title-after';
        }
        
        $this->extend('updateCaptionClassNames', $classes);
        
        return $classes;
    }
48542
public function getWidgetContainerConfigs()
    {
        $configs = array();

        $widgetContainerConfigs = $this->getAllWidgetContainerConfigClassNames();
        foreach ($widgetContainerConfigs as $widgetClass) {
            $configs[] = StaticContainer::get($widgetClass);
        }

        return $configs;
    }
973981
protected function availableClasses(): array
    {
        $classes = [];

        foreach ($this->availableReflections() as $reflection) {
            $classes = array_merge($classes, $reflection->getClasses());
        }

        return $classes;
    }
836484
public function classes() {

		$classes = array(
			'toggle-checkbox',
		);

		if ( ! empty( $this->struct['on_icon'] ) ) {
			$this->icons['on'] = $this->struct['on_icon'];
		}

		if ( ! empty( $this->struct['off_icon'] ) ) {
			$this->icons['off'] = $this->struct['off_icon'];
		}

		return $classes;
	}
690998
public function getListItemClassNames()
    {
        // Initialise:
        
        $classes = ['item'];
        
        // Merge Ancestor Class Names:
        
        $classes = array_merge(
            $classes,
            ViewTools::singleton()->getAncestorClassNames(
                $this->owner,
                $this->owner->baseClass()
            )
        );
        
        // Merge Meta Class Names:
        
        if ($this->owner->hasMethod('getMetaClassNames')) {
            $classes = array_merge($classes, $this->owner->getMetaClassNames());
        }
        
        // Update Class Names via Renderer:
        
        if ($this->owner->getRenderer()->hasMethod('updateListItemClassNames')) {
            $this->owner->getRenderer()->updateListItemClassNames($classes);
        }
        
        // Answer Classes:
        
        return $classes;
    }
145675
public function getBusinessClassesForWidget(Widget $widget)
    {
        $widgetName = $this->widgetHelper->getWidgetName($widget);
        $widgetMetadatas = $this->fetch(BusinessEntity::CACHE_WIDGETS);
        if (isset($widgetMetadatas[$widgetName]) && array_key_exists('businessEntities', $widgetMetadatas[$widgetName])) {
            /* @var BusinessEntity[] $businessEntities */
            $businessEntities = $widgetMetadatas[$widgetName]['businessEntities'];

            if (array_key_exists('receiverProperties', $widgetMetadatas[$widgetName])) {
                foreach ($businessEntities as $businessEntity) {
                    $businessEntity->setDisableForReceiverProperties($widgetMetadatas[$widgetName]['receiverProperties']);
                }
            }

            return $businessEntities;
        }

        return [];
    }
867863
public function getColumnClassNames()
    {
        $classes = array_merge(
            $this->styles('column'),
            Column::singleton()->getSpanClassNames($this->dbObject('ColumnSpan'))
        );
        
        $this->extend('updateColumnClassNames', $classes);
        
        return $classes;
    }
1102530
private function getReportWidgets(): array
    {
        $event = new Event((string)EventName::MODEL_DASHBOARDS_GET_REPORTS(), $this);
        EventManager::instance()->dispatch($event);

        if (empty($event->result)) {
            return [];
        }

        $result = [];
        foreach ($event->result as $reports) {
            foreach ($reports as $report) {
                if (! isset($result[$report['widget_type']])) {
                    $result[$report['widget_type']] = ['type' => $report['widget_type'], 'data' => []];
                }
                $result[$report['widget_type']]['data'][$report['id']] = $report;
            }
        }

        return array_values($result);
    }
1313894
private function getAppWidgets(): array
    {
        $table = TableRegistry::get('Search.AppWidgets');

        $query = $table->find('all')
            ->select(['id', 'name', 'content']);

        if ($query->isEmpty()) {
            return [];
        }

        $data = [];
        // normalize app widget data
        foreach ($query->all() as $entity) {
            $data[] = [
                'id' => $entity->get('id'),
                'model' => $entity->get('content')['model'],
                'name' => $entity->get('name'),
                'path' => $entity->get('content')['path']
            ];
        }

        return [
            ['type' => 'app', 'data' => $data]
        ];
    }
1041904
protected function getCSSClassNames()
    {
        $classes = array();
        $classes[] = 'swat-frame';
        $classes[] = 'swat-disclosure-control-opened';
        $classes[] = 'swat-frame-disclosure-control-opened';
        $classes[] = 'swat-frame-disclosure';
        $classes = array_merge($classes, parent::getCSSClassNames());
        return $classes;
    }
293963
public function getClasses()
    {
        $classes = explode(' ', $this->cssClass);
        $this->extend('updateClasses', $classes);
        $classes = implode(' ', $classes);

        return $classes;
    }
636531
public function getChildrenNames()
    {
        if (null === $this->inheritanceColumn
            || !$this->inheritanceColumn->isEnumeratedClasses()) {
            return null;
        }

        $names = [];
        foreach ($this->inheritanceColumn->getChildren() as $child) {
            $names[] = get_class($child);
        }

        return $names;
    }
68504
public function getClassAndMethodNamesForCalling(): array
    {
        $domain = $this->consoleInput->getDomainName();
        $action = $this->consoleInput->getActionName();

        $className = self::getFQDNClass($domain);

        return [$className, $domain, $action];
    }
272274
public function getClassNames()
    {
        $classes = array_merge(
            parent::getClassNames(),
            [
                $this->IconSizeClass,
                $this->CornerStyleClass
            ]
        );
        
        return $classes;
    }
442591
public static function getKernelClasses()
    {
        $classes = [];
        //
        $namespace = "Vinala\Kernel\Console\Commands";
        //
        foreach (get_declared_classes() as $value) {
            if (\Strings::contains($value, $namespace)) {
                $classes[] = $value;
            }
        }

        return $classes;
    }