Adds the pageComponent to the components list while registering listeners and firing appropriate events. (not yet
setting the component as the active one)

@param pageComponent
the pageComponent to add.
182920
protected void addPageComponent(PageComponent pageComponent) {
        pageComponents.add(pageComponent);
        doAddPageComponent(pageComponent);
        pageComponent.addPropertyChangeListener(pageComponentUpdater);

        fireOpened(pageComponent);
    }
628947
protected void addTargetListeners (Component comp)
    {
        comp.addMouseListener(_targetListener);
        comp.addMouseMotionListener(_targetListener);
        if (comp instanceof Container) { // hm, always true for JComp..
            Container cont = (Container) comp;
            cont.addContainerListener(_childListener);
            for (int ii=0, nn=cont.getComponentCount(); ii < nn; ii++) {
                addTargetListeners(cont.getComponent(ii));
            }
        }
    }
853370
public void setBinding(javax.faces.component.UIComponent _binding) {
		getStateHelper().put(PropertyKeys.binding, _binding);
	}
1280798
protected <T extends IComponent> void addComponent(Class<T> componentType, T component) {
        components.put(componentType, component);
    }
1238413
public synchronized void registerComponent(Class<?> _clazz) {
        if (_clazz == null) {
            return;
        }

        if (isIncluded(_clazz.getName()) || _clazz.getName().equals(this.getClass().getName())) {
            String classVersion = getVersionWithReflection(_clazz);
            if (classVersion != null) {
                componentVersions.put(_clazz.getName(), classVersion);
            }
        }
    }
506255
public Panel addComponent(Component component, LayoutData layoutData) {
        if(component != null) {
            component.setLayoutData(layoutData);
            addComponent(component);
        }
        return this;
    }
1344215
public void remove(UIComponent component)
	{
		if (component.getParent() != this)
			return;

		content.components.remove(component);
		component.setParent(null);
		component.unregister(this);
		onContentUpdate();
	}
792708
private static function init()
    {
        if (!self::$data_initialized) {
            self::$data_initialized = true;

            $page_components_collection = new PageComponentEntityRepository();
            $page_components_collection->setWherePageId(PAGE_ID);
            $page_components_collection->addWhereFieldIsLike('component', 'select_plugin');
            if (Settings::isCacheEnabled()) {
                $page_components_collection->enableUsingCache();
            }

            self::$data = $page_components_collection->getPairs('data', 'component');
        }
    }
1149421
public void addPages() {
		page = new CreateComponentStartPage(selection);
		addPage(page);
		integrationComponentPage = new CreateIntegrationComponentPage(selection);
		addPage(integrationComponentPage);
		
		serviceDescriptionComponentPage = new CreateServiceDescriptionComponentPage(selection);
		addPage(serviceDescriptionComponentPage);
		
		page3 = new StatusPage(selection);
		addPage(page3);
	}
464644
public synchronized void addComponent(ComponentEvent event)
    {
        try
        {
            if(log.isDebugEnabled())log.debug("Component added "+event);
            Object o=event.getComponent();
            
            ModelMBean mbean=ModelMBeanImpl.mbeanFor(o);
            if (mbean==null)
                log.warn("No MBean for "+o);
            else
            {
                ObjectName oName=null;
                if (mbean instanceof ModelMBeanImpl)
                {
                    ((ModelMBeanImpl)mbean).setBaseObjectName(getObjectName().toString());
                    oName=
                        getMBeanServer().registerMBean(mbean,null).getObjectName();
                }
                else
                {
                    oName=uniqueObjectName(getMBeanServer(),
                                           o,
                                           getObjectName().toString());
                    oName=getMBeanServer().registerMBean(mbean,oName)
                        .getObjectName();
                }
                Holder holder = new Holder(oName,mbean);
                _mbeanMap.put(o,holder);
            }
        }
        catch(Exception e)
        {
            log.warn(LogSupport.EXCEPTION,e);
        }
    }
720671
function() {
      var t = this;
      t.saveChanges();

      // Open the new component dialog if no components exist
      if (t.model.get('components').length === 0) {
        t.pageView.newComponent();
      }
    }
316782
public void add(Component component, boolean addRelationships) {
        if (component != null) {
            if (!component.getContainer().equals(getContainer())) {
                throw new IllegalArgumentException("Only components belonging to " + container.getName() + " can be added to this view.");
            }

            addElement(component, addRelationships);
        }
    }
234420
public void init(PageContext pageContext) {

        ServletContext servCtx = pageContext.getServletContext();
        ServletConfig servConfig = pageContext.getServletConfig();

        init(servCtx, servConfig);
    }
1349031
@Override
  public void add(int index, Object element) {    
    element = mapIfNumber(element);
    addComponent(index, element, ComponentEquality.EQUAL);
  }
91530
protected void onAfterRender(final Component component) {
		final Response response = component.getResponse();
		response.write(onWriteAfterRender());
	}
248090
private void addComponent(final WComponent component) {
		collapsibleList.add(component);
		MemoryUtil.checkSize(collapsibleList.size(), this.getClass().getSimpleName());
	}
955072
private int addComponent0(boolean increaseWriterIndex, int cIndex, ByteBuf buffer) {
        assert buffer != null;
        boolean wasAdded = false;
        try {
            checkComponentIndex(cIndex);

            // No need to consolidate - just add a component to the list.
            Component c = newComponent(buffer, 0);
            int readableBytes = c.length();

            addComp(cIndex, c);
            wasAdded = true;
            if (readableBytes > 0 && cIndex < componentCount - 1) {
                updateComponentOffsets(cIndex);
            } else if (cIndex > 0) {
                c.reposition(components[cIndex - 1].endOffset);
            }
            if (increaseWriterIndex) {
                writerIndex += readableBytes;
            }
            return cIndex;
        } finally {
            if (!wasAdded) {
                buffer.release();
            }
        }
    }