Get the ActiveWindow name based on its class short name.

@return string
1442
public function getName()
    {
        if ($this->_name === null) {
            $this->_name = ((new \ReflectionClass($this))->getShortName());
        }
        
        return $this->_name;
    }
1339501
public function getClassName()
    {
        $adapter = $this->getAdapter();

        if ($adapter) {
            return $adapter;
        }

        return ucfirst($this->dsn->scheme);
    }
1317063
public function getName()
    {
        if (!$this->_name) {
            $class = Type::short($this);
            $this->_name = Helper::rtrimWord(Type::snake_case($class, '-'), '-type');
        }

        return $this->_name;

    }
1313841
public function getSellerWindowsIndexedByStartTime()
    {
        $windows = array();

        foreach ($this->getSellerWindows() as $window)
        {
            $windows[$window->getStartTime()->format('Y-m-d H:i:s')] = $window;
        }

        return $windows;
    }
815005
public function getRcmPluginName()
    {
        if (empty($this->rcmPluginName)) {
            /**
             * Automatically detect the plugin name for controllers that extend
             * this class by looking at the first part of the child's namespace
             */
            $classParts = explode('\\', get_class($this));
            $this->rcmPluginName = $classParts[0];
        }

        return $this->rcmPluginName;
    }
626382
public function resolveClassname()
    {
        $resolver = $this->smd->getNameResolver();
        if ( $resolver && is_callable($resolver) ) {
            return call_user_func_array($resolver, [$this]);
        }
        return $this->getDottedClassname();
    }
782437
public function getCurrentWindowHandle()
    {
        $command = $this->driver->factoryCommand('window_handle', WebDriver_Command::METHOD_GET);
        $result = $this->driver->curl($command);
        return $result['value'];
    }
349195
public function getViewClassNameForViewBuilder()
    {
        list($plugin, $theme) = namespaceSplit(get_class($this));
        $plugin = preg_replace('/\\\/', '/', $plugin);
        return $plugin . '.' . $theme;
    }
1107443
protected function getClassNamePrefix()
    {
        $prefix = $this->input->getOption('prefix');

        if (empty($prefix)) {
            $prefix = $this->classNamePrefix;
        }

        return $prefix;
    }
301586
protected function deriveWidgetName()
	{
        $widget = get_class($this);

		if (strstr($widget, '\\')) {
			$widget = substr($widget, strpos($widget, '\\') + 1);
			$widget = substr($widget, 0, strrpos($widget, '\\'));
		}
		
		if (strstr($widget, '\\')) {
			$widget = substr($widget,strpos($widget, '\\')+1);
		}

		return $widget;
	}
1324746
public function getName()
    {
        if (!$this->name) {
            if ($this->config['name']) {
                return $this->name = $this->config['name'];
            }

            $ref = new \ReflectionClass(static::class);

            $name = substr($ref->getShortName(), 0, -10);

            return $this->name = strtolower($name);
        }

        return $this->name;
    }
855930
protected function getChildName()
    {
        if ($this->childname === null) {
            $classname = get_class($this);
            $pos = max(strrpos($classname, '_Array'), strrpos($classname, '\ArrayObject'));
            $this->childname = substr($classname, 0, $pos);
        }
        return $this->childname;
    }
440407
public function getShortName()
    {
        // If installed in the root directory we need to infer from composer
        if ($this->path === $this->basePath && $this->composerData) {
            // Sometimes we customise installer name
            if (isset($this->composerData['extra']['installer-name'])) {
                return $this->composerData['extra']['installer-name'];
            }

            // Strip from full composer name
            $composerName = $this->getComposerName();
            if ($composerName) {
                list(, $name) = explode('/', $composerName);
                return $name;
            }
        }

        // Base name of directory
        return basename($this->path);
    }
702871
public function getTaskName()
    {
        return $this->realThing === null || !$this->realThing instanceof Task
            ? parent::getTaskName()
            : $this->realThing->getTaskName();
    }
176348
protected function getClass()
    {
        // Retrieve path to Resources and shortname's class
        $class = new \ReflectionClass(get_class($this));

        // Return a simple array
        return [
            'name'      => $class->getShortName(),
            'path'      => $class->getFileName(),
            'resources' => dirname(dirname($class->getFileName())).S.'Resources',
        ];
    }
923614
public function singular_name()
    {
        $name = $this->config()->get('singular_name');
        if ($name) {
            return $name;
        }
        return ucwords(trim(strtolower(preg_replace(
            '/_?([A-Z])/',
            ' $1',
            ClassInfo::shortName($this)
        ))));
    }
975115
public function getClassName()
    {
        if ($this->isMethod() || $this->isInvokedObject()) {
            $callable = $this->explodeCallable();
            if ($this->isInstanceMethod() || $this->isInvokedObject()) {
                return get_class($callable[0]);
            }
            return $callable[0];
        }
        return '';
    }