Return the attached :class:`Pane`.

        Returns
        -------
        :class:`Pane`
556937
def attached_pane(self):
        
        for pane in self._panes:
            if 'pane_active' in pane:
                # for now pane_active is a unicode
                if pane.get('pane_active') == '1':
                    return Pane(window=self, **pane)
                else:
                    continue

        return []
1032020
def panels(self):
        
        return [panel for panel in self.findChildren(XViewPanel) if panel.viewWidget() == self]
559485
private JScrollPane getPaneScroll() {
		if (paneScroll == null) {
			paneScroll = new JScrollPane();
			paneScroll.setName("paneScroll");
			paneScroll.setViewportView(getTreeAlert());
		}
		return paneScroll;
	}
398489
def get_wrapping_class(node):
    

    klass = node.frame()
    while klass is not None and not isinstance(klass, ClassDef):
        if klass.parent is None:
            klass = None
        else:
            klass = klass.parent.frame()
    return klass
1316553
def get_window(self): 
        
        x = self
        while not x._parent == None and \
              not isinstance(x._parent, Window): 
                  x = x._parent
        return x._parent
1169956
def get_module_class(self):
        
        pkg, cname = self.parse_module_class()
        logger.debug(f'pkg: {pkg}, class: {cname}')
        pkg = pkg.split('.')
        mod = reduce(lambda m, n: getattr(m, n), pkg[1:], __import__(pkg[0]))
        logger.debug(f'mod: {mod}')
        if self.reload:
            importlib.reload(mod)
        cls = getattr(mod, cname)
        logger.debug(f'class: {cls}')
        return mod, cls
1148259
private Label getLabel(String pane) {
        Label lbl = root.findByName(pane, Label.class);
        return lbl == null ? createLabel(pane) : lbl;
    }
702046
def remove_pane(self, pane):
        
        assert isinstance(pane, Pane)

        for w in self.windows:
            w.remove_pane(pane)

            # No panes left in this window?
            if not w.has_panes:
                # Focus next.
                for app, active_w in self._active_window_for_cli.items():
                    if w == active_w:
                        with set_app(app):
                            self.focus_next_window()

                self.windows.remove(w)
96907
def get(self, name_or_klass):
        
        if not is_text_string(name_or_klass):
            name_or_klass = name_or_klass.__name__
        for zone in range(4):
            try:
                panel = self._panels[zone][name_or_klass]
            except KeyError:
                pass
            else:
                return panel
        raise KeyError(name_or_klass)
1057121
def driver(self):
        

        if not self._driver:
            raise AttributeError("`driver` is not bound on this agent implementation({}). "
                                 "Do you forget to call `super().on_bind_driver` when you override the method "
                                 "`on_bind_driver` in your sub class?"
                                 .format(repr(self)))
        return self._driver
997466
def get_frame():
    """"""
    ret = QFrame()
    ret.setLineWidth(1)
    ret.setMidLineWidth(0)
    ret.setFrameShadow(QFrame.Sunken)
    ret.setFrameShape(QFrame.Box)
    return ret
1125183
def getPyClass(self):
        '''
        '''
        # --> EXTENDED
        if self.hasExtPyClass():
            classInfo = self.extPyClasses[self.name]
            return ".".join(classInfo)
        # <-- 
        
        return 'Holder'
71965
def get_connection_cls(cls):
        
        if cls.__connection_cls is None:
            cls.__connection_cls, _ = cls.from_settings()
        return cls.__connection_cls
555927
def set_active_window_from_pane_id(self, pane_id):
        
        assert isinstance(pane_id, int)

        for w in self.windows:
            for p in w.panes:
                if p.pane_id == pane_id:
                    self.set_active_window(w)
1568
def get_source_class(self, _class):
        
        if not _class.get_name() in self.classes:
            return ""
        return self.classes[_class.get_name()]
13825
def context_class(self):
        
        if 'context_class' not in self._cached_values:
            context_cls_name = getattr(self.settings, 'CONTEXT_CLASS', '')
            if context_cls_name:
                context_class = import_object(context_cls_name)
            else:
                context_class = Context
            self._cached_values['context_class'] = context_class
        return self._cached_values['context_class']
348026
def get_layer(self, class_: Type[L], became: bool=True) -> L:
        

        try:
            return self._index[class_][0]
        except KeyError:
            if became:
                return self._transformed[class_][0]
            else:
                raise