Removes the specified panel.

        :param name_or_klass: Name or class of the panel to remove.
        :return: The removed panel
961812
def remove(self, name_or_klass):
        
        _logger().log(5, 'removing panel %r', 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)
1348132
def close_panel(self):
        
        self.hide()
        self.lineEditReplace.clear()
        self.lineEditSearch.clear()
98175
public synchronized void removeClass(CSSClass clss) {
    CSSClass existing = store.get(clss.getName());
    if (existing == clss) {
      store.remove(existing.getName());
    }
  }
104753
def remove_envelope(self, component=None, **kwargs):
        
        kwargs.setdefault('kind', 'envelope')
        return self.remove_component(component, **kwargs)
1350611
public void remove(Class<?> clazz) {
		ClassMetadata metadata = get(clazz);
		metadataByClass.remove(clazz);
		metadataByKind.remove(metadata.getKind());
	}
184644
def delete_object(self, object_name):
        
        self._client.remove_object(self._instance, self.name, object_name)
419944
def remove(cls, name):
        

        api = Client.instance().api

        api.collection(name).delete()
436149
def remove_aliases(self_or_cls, aliases):
        
        for k,v in self_or_cls.aliases.items():
            if v in aliases:
                self_or_cls.aliases.pop(k)
1026324
def remove(self, cls, originalMemberNameList, memberName, classNamingConvention):
        
        if memberName not in originalMemberNameList:
            delattr(cls, memberName)
856371
def profile_remove(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.execute_action('profile:remove', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
    })
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]
1300125
function() {
		for (var j = 0; j < this.panels_.length; j++) {
			u.removeClass(this.panels_[j],this._CssClasses.ACTIVE_CLASS)
		}
	}
695800
def unregister_class(alias):
    
    try:
        x = CLASS_CACHE[alias]
    except KeyError:
        raise UnknownClassAlias('Unknown alias %r' % (alias,))

    if not x.anonymous:
        del CLASS_CACHE[x.alias]

    del CLASS_CACHE[x.klass]

    return x
482263
def remove_all(klass, ids, options = {})
      Entry.enqueue(self, klass, ids, true, options[:priority] || self.class.default_priority)
    end
876301
def remove_from_cluster(self, name, *args):
        
        cluster = self.get_cluster(name=name)
        attrs_ = cluster['cluster']
        for a in args:
            del attrs_[a]
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
820920
def drop_class(name, options={})
      raise ArgumentError, 'class name is blank' if blank?(name)

      # :mode=>:strict forbids to drop a class that is a super class for other one
      opt_pattern = { :mode => :nil }
      verify_options(options, opt_pattern)
      if :strict == options[:mode]
        response = get_database
        children = response['classes'].select { |i| i['superClass'] == name }
        unless children.empty?
          raise OrientdbError, "class is super-class, cannot be deleted, name=#{name}"
        end
      end

      command "DROP CLASS #{name}"
    end