This event fires on tab show after a tab has been shown.
Use event.target and event.relatedTarget to target the active tab and the previous active tab (if available) respectively.
@param string $jsCode
@return $this
349493
public function onShown($index, $jsCode) {
		$tab=$this->getTab($index);
		if (isset($tab))
			return $tab->onShown($jsCode);
	}
1297275
protected function compile_once(\Ajax\JsUtils $js = NULL, &$view = NULL) {
		if(!$this->_compiled && isset($this->_editableContent)){
			$this->wrap("",$this->_editableContent);
		}
		parent::compile_once($js,$view);
		
	}
1151501
public function click(WebDriverElement $element = null)
    {
        $this->action->addAction(
            new WebDriverClickAction($this->mouse, $element)
        );

        return $this;
    }
910923
public function run(JsUtils $js){
		parent::run($js);
		$this->_params["popup"]="#".$this->identifier;
		$js->semantic()->popup("#".$this->_container->getIdentifier(),$this->_params);
	}
711640
public void onNewTab(final AjaxRequestTarget target, final T tab)
	{
		getTabs().add(tab);
		setSelectedTab(getTabs().size() - 1);
		target.add(this);
	}
451556
public function listen($event, $listener){
        if (!$this->emitter){
            return $this;
        }
        $this->emitter->listen($event, $listener);
        return $this;
    }
293368
protected function updateScriptEvents()
    {
        if (!$this->control || !ScriptLabel::isEventLabel($this->labelName)) {
            return $this;
        }
        if ($this->control instanceof Scriptable) {
            $this->control->setScriptEvents(true);
        }
        return $this;
    }
946349
public static <S extends HasAttachHandlers> void fire(S source, CollapsibleState collapsibleState,
                                                          Element eventTarget) {
        if (TYPE != null) {
            JQMCollapsibleEvent event = new JQMCollapsibleEvent(collapsibleState, eventTarget);
            source.fireEvent(event);
        }
    }
401467
public function tabs($tabs, $jstabs = true, $callback = 'ccm_activateTabBar')
    {
        $tcn = rand(0, getrandmax());

        $html = '<ul class="nav-tabs nav" id="ccm-tabs-' . $tcn . '">';
        foreach ($tabs as $t) {
            $dt = $t[0];
            $href = '#';
            if (!$jstabs) {
                $dt = '';
                $href = $t[0];
            }
            $html .= '<li class="' . ((isset($t[2]) && true == $t[2]) ? 'active' : '') . '"><a href="' . $href . '" data-tab="' . $dt . '">' . $t[1] . '</a></li>';
        }
        $html .= '</ul>';
        if ($jstabs) {
            $html .= '<script type="text/javascript">$(function() { ' . $callback . '($(\'#ccm-tabs-' . $tcn . '\'));});</script>';
        }

        return $html;
    }
1210112
public static function script($jscode, $url=null) {
        if ($jscode) {
            $attributes = array('type'=>'text/javascript');
            return self::tag('script', "\n//<![CDATA[\n$jscode\n//]]>\n", $attributes) . "\n";

        } else if ($url) {
            $attributes = array('type'=>'text/javascript', 'src'=>$url);
            return self::tag('script', '', $attributes) . "\n";

        } else {
            return '';
        }
    }
634033
public function fire($event)
    {
        $this->dispatch("$event.before");
        $this->dispatch($event);
        $this->dispatch("$event.after");

        return $this;
    }
365437
public function waitForCondition($jsCondition, $timeout = 60)
	{
		$i = 0;
		do
		{
			sleep(1);
		} while (
			!($result = $this->execute(array('script' => 'return ' . $jsCondition, 'args' => array())))
			&& $i++ < $timeout
		);
		return $result;
	}
379696
public function tap(WebDriverElement $element)
    {
        $this->executor->execute(
            DriverCommand::TOUCH_SINGLE_TAP,
            ['element' => $element->getID()]
        );

        return $this;
    }
878673
public function run(JsUtils $js) {
		if(isset($this->_bsComponent)===false)
			$this->_bsComponent=$js->semantic()->modal("#".$this->identifier,$this->_params,$this->_paramParts);
		$this->addEventsOnRun($js);
		return $this->_bsComponent;
	}
1256960
public function run(JsUtils $js) {
		parent::run($js);
		if ($this->content instanceof HtmlDoubleElement) {
			$this->content->run($js);
		} else if (\is_array($this->content)) {
			foreach ( $this->content as $itemContent ) {
				if ($itemContent instanceof HtmlDoubleElement) {
					$itemContent->run($js);
				}
			}
		}
	}
118418
public function run(JsUtils $js) {
		parent::run($js);
		$this->_bsComponent=$js->bootstrap()->generic("#".$this->identifier);
		$this->addEventsOnRun($js);
		return $this->_bsComponent;
	}
982727
public static function minifyCode(string $jsCode) : string
    {
        // Unifica marcações de nova linha.
        $inputCode = str_replace(["\r\n", "\r"], "\n", $jsCode);
        $outputCode = "";


        if (trim($inputCode) !== "") {
            // Caracteres que permite eliminar os espaços existentes ao seu redor
            $NonSpaceAround = [
                ":", ";", ",", "?", "<", ">",
                "{", "}", "(", ")", "=", "+", "-", "*",
                "/", "%", "&", "|", "!"
            ];



            // Para cada caracter existênte no código original...
            $codeLength = strlen($inputCode);
            $lastCodeIndex = $codeLength - 1;
            for ($i = 0; $i < $codeLength; $i++) {
                $CharType = "";


                // Resgata o caracter da posição atual E o próximo
                $c = $inputCode[$i];                                        // Caracter atual
                $nc = ($i < $lastCodeIndex) ? $inputCode[$i + 1] : "";      // Próximo caracter
                $lc = ($i > 0) ? $inputCode[$i - 1] : "";                   // Caracter anterior



                // Sendo um caracter sem representação gráfica...
                if ($c === "\n" || ord($c) < 32) {
                    $CharType = "NonVisible";
                } else {
                    // Conforme o caracter atual
                    switch ($c) {
                        // Verifica a abertura de blocos de comentário ou de um Regex
                        case "/":
                            $CharType = "IgnoreBlock";

                            // Se o próximo caracter for um espaço...
                            // infere que trata-se de uma barra de divisão
                            if ($nc === " ") {
                                $CharType = "";
                            } // Identifica início de uma linha de comentário
                            elseif ($nc === "/") {
                                // Resgata a posição do caracter imediatamente após do primeiro \n identificado
                                // após o início da linha de comentário.
                                $endBlock = strpos($inputCode, "\n", $i);
                                if ($endBlock !== false) {
                                    if ($endBlock < $lastCodeIndex) {
                                        $i = $endBlock;
                                    } else {
                                        $i = $lastCodeIndex;
                                    }
                                }
                            } // Ou o início de um bloco de comentário...
                            elseif ($nc === "*") {
                                // Resgata a posição do caracter */ encontrado a partir do início do bloco
                                // de comentário
                                $endBlock = strpos($inputCode, "*/", $i) + 1;
                                if ($endBlock !== false) {
                                    if ($endBlock < $lastCodeIndex) {
                                        $i = $endBlock;
                                    } else {
                                        $i = $lastCodeIndex;
                                    }
                                }
                            } // Senão, infere que é uma expressão regular.
                            else {
                                // @codeCoverageIgnoreStart
                                $endRegex = false;
                                $indexRegex = $i;


                                do {
                                    $endBlock = strpos($inputCode, "/", $indexRegex + 1);

                                    // Se não encontrar o final do regex, dispara exception
                                    if ($endBlock === false) {
                                        $msg = "The end of the regular expression was not found.";
                                        throw new \Exception($msg);
                                    } else {
                                        // Se o caracter anterior não for o caracter de "scape"
                                        // significa que a expressão regular terminou.
                                        if ($inputCode[$endBlock - 1] !== "\\") {
                                            $endRegex = true;
                                        } else {
                                            $indexRegex = $endBlock;
                                        }
                                    }
                                } while (!$endRegex);



                                if ($endBlock < $lastCodeIndex) {
                                    $outputCode .= substr($inputCode, $i, ($endBlock - $i + 1));
                                    $i = $endBlock;
                                } else {
                                    $i = $lastCodeIndex;
                                }
                                // @codeCoverageIgnoreEnd
                            }


                            break;

                        // Identifica a abertura de uma string envolvida por aspas simples ou duplas
                        case "'":
                        case "\"":
                            $CharType = "IgnoreBlock";
                            $quote = $c;
                        
                            // Se o próximo caracter for o fechamento da própria string
                            // sendo portanto uma string vazia...
                            if ($nc === $quote) {
                                $outputCode .= $quote . $quote;
                                $i++;
                            } else {
                                // Resgata a string que está envolvida pelas aspas
                                $quotedString = "";
                                for ($np = ($i + 1); $np < $codeLength; $np++) {
                                    $_c = $inputCode[$np];

                                    // Encontrando a próxima aspas...
                                    if ($_c === $quote) {
                                        // Identifica se a aspa está "escapada"
                                        $_scaped = ($inputCode[$np - 1] === "\\" && $inputCode[$np - 2] !== "\\");


                                        // Se a aspa não está "escapada", encerra o loop
                                        if ($_scaped === false) {
                                            break;
                                        }
                                    }

                                    $quotedString .= $_c;
                                }


                                $outputCode .= $quote . str_replace("\\\n", "", $quotedString) . $quote;
                                $i = $np;
                            }

                            break;
                    }
                }




                switch ($CharType) {
                    case "IgnoreBlock":
                        break;

                    case "NonVisible":
                        $outputCode .= "";
                        break;

                    default:
                        // Identifica se o espaço vazio deve ser mantido ou não...
                        if ($c === " ") {
                            // Se o próximo caracter é um espaço em branco... ignora este.
                            if ($nc === " ") {
                                $c = "";
                            } else {
                                if ($outputCode !== "") {
                                    $lvc = $outputCode[strlen($outputCode) - 1];
                                    if (in_array($lvc, $NonSpaceAround) === true || in_array($nc, $NonSpaceAround) === true) {
                                        $c = "";
                                    }
                                }
                            }
                        }

                        $outputCode .= $c;

                        break;
                }
            }
        }



        return trim($outputCode);
    }