Removes the specified panel.

        :param name_or_klass: Name or class of the panel to remove.
        :return: The removed panel
177541
def remove(self, name_or_klass):
        
        logger.debug('removing panel %s' % name_or_klass)
        panel = self.get(name_or_klass)
        panel.on_uninstall()
        panel.hide()
        panel.setParent(None)
        return self._panels[panel.position].pop(panel.name, None)
1026324
def remove(self, cls, originalMemberNameList, memberName, classNamingConvention):
        
        if memberName not in originalMemberNameList:
            delattr(cls, memberName)
526808
def remove(o)
      if o == nil
        raise Error, "Cannot remove '#{o.class}' from window!"
      end

      if i = @objects.index(o)
        @objects.delete_at(i)
        true
      else
        false
      end
    end
1232796
def delete_event_ticket_class(self, id, ticket_class_id, **data):
        
        
        return self.delete("/events/{0}/ticket_classes/{0}/".format(id,ticket_class_id), data=data)
104753
def remove_envelope(self, component=None, **kwargs):
        
        kwargs.setdefault('kind', 'envelope')
        return self.remove_component(component, **kwargs)
596111
def removeLayer(self, name):
        
        name = normalizers.normalizeLayerName(name)
        if name not in self.layerOrder:
            raise ValueError("No layer with the name '%s' exists." % name)
        self._removeLayer(name)
176506
def remove_collector(collector_class)
      return collector_class.each { |c| remove_collector(c) } if collector_class.is_a? Array

      raise ArgumentError, "`collector_class' must be a class" unless collector_class.is_a? Class
      raise ArgumentError, "No collector found with class \“#{collector_class}\"" unless @collectors[collector_class]

      @collectors.delete(collector_class)

      sort_collectors!
    end
368066
def RemoveClass(self, class_name):
    
    if class_name not in self._class_mapping:
      raise problems.NonexistentMapping(class_name)
    del self._class_mapping[class_name]
46200
function removeClass(elm, name) {
        if (name) {
            var cls = className(elm),
                names;

            if (langx.isString(name)) {
                names = name.split(/\s+/g);
            } else {
                names = name;
            }

            names.forEach(function(klass) {
                var re = classRE(klass);
                if (cls.match(re)) {
                    cls = cls.replace(re, " ");
                }
            });

            className(elm, cls.trim());
        } else {
            className(elm, "");
        }

        return this;
    }
275730
def remove(self, cls, originalMemberNameList, memberName, classNamingConvention):
        
        accessorDict = self._accessorDict(memberName, classNamingConvention)
        for accessorName, _ in accessorDict.items():
            if accessorName not in originalMemberNameList and hasattr(cls, accessorName):
                delattr(cls, accessorName)
173966
def remove_class(cls, *args):
        
        for cls2 in args:
            try:
                del cls.classes[cls2.__name__]
            except KeyError:
                pass
720350
def unmangle_name(name, classname):
        
        if name.startswith(classname) and name[-2:] != '__':
            return name[len(classname) - 2:]
        return name
842132
def deregister
      return true unless registered?
      klass = self.klass
      @session.namespace_const.instance_eval{ remove_const klass }
      true
    end
1366689
def _unregister_lookup(cls, lookup, lookup_name=None):
        
        if lookup_name is None:
            lookup_name = lookup.lookup_name
        del cls.class_lookups[lookup_name]
708253
def remove_child(self, child):
        
        self.children.remove(child)
        child.parent = None

        if self.view and self.view.is_loaded:
            self.view.dispatch({
                'name': 'remove',
                'selector': '#' + child.id
            })
1091880
def remove(self, member):
        
        if not self.client.srem(self.name, member):
            raise KeyError(member)
534487
def klass
      klass_name = options.fetch(:class, name).to_s.camelize
      Object.const_get(klass_name)
    rescue NameError
      raise InvalidClassError, "class #{klass_name.inspect} does not exist"
    end