call inner component connect
555554
def connect(self, protocol=None, mode=None, disposition=None):
        """"""
        self.component.connect(protocol, mode, disposition)
1014578
function inner_onclick(e) {
            var value = this.value;
            var close_parent = true;

            if (that.current_submenu) {
                that.current_submenu.close(e);
            }

            //global callback
            if (options.callback) {
                var r = options.callback.call(
                    this,
                    value,
                    options,
                    e,
                    that,
                    options.node
                );
                if (r === true) {
                    close_parent = false;
                }
            }

            //special cases
            if (value) {
                if (
                    value.callback &&
                    !options.ignore_item_callbacks &&
                    value.disabled !== true
                ) {
                    //item callback
                    var r = value.callback.call(
                        this,
                        value,
                        options,
                        e,
                        that,
                        options.extra
                    );
                    if (r === true) {
                        close_parent = false;
                    }
                }
                if (value.submenu) {
                    if (!value.submenu.options) {
                        throw "ContextMenu submenu needs options";
                    }
                    var submenu = new that.constructor(value.submenu.options, {
                        callback: value.submenu.callback,
                        event: e,
                        parentMenu: that,
                        ignore_item_callbacks:
                            value.submenu.ignore_item_callbacks,
                        title: value.submenu.title,
                        extra: value.submenu.extra,
                        autoopen: options.autoopen
                    });
                    close_parent = false;
                }
            }

            if (close_parent && !that.lock) {
                that.close();
            }
        }
941505
@Override
	protected void onInitializeComponents()
	{
		lpNoProxy = new JLayeredPane();
		lpNoProxy.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null));

		lpHostOrIpaddress = new JLayeredPane();
		lpHostOrIpaddress.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null));

		rdbtnManualProxyConfiguration = new JRadioButton("Manual proxy configuration");
		rdbtnManualProxyConfiguration.setBounds(6, 7, 313, 23);
		lpHostOrIpaddress.add(rdbtnManualProxyConfiguration);

		lblHostOrIpaddress = new JLabel("Host or IP-address:");
		lblHostOrIpaddress.setBounds(26, 37, 109, 14);
		lpHostOrIpaddress.add(lblHostOrIpaddress);

		txtHostOrIpaddress = new JTextField();
		txtHostOrIpaddress.setBounds(145, 37, 213, 20);
		lpHostOrIpaddress.add(txtHostOrIpaddress);
		txtHostOrIpaddress.setColumns(10);

		lblPort = new JLabel("Port:");
		lblPort.setBounds(368, 40, 46, 14);
		lpHostOrIpaddress.add(lblPort);

		txtPort = new JTextField();
		txtPort.setBounds(408, 37, 67, 20);
		lpHostOrIpaddress.add(txtPort);
		txtPort.setColumns(10);

		rdbtnNoProxy = new JRadioButton("Direct connection to internet (no proxy)");
		rdbtnNoProxy.setBounds(6, 7, 305, 23);

		lpNoProxy.add(rdbtnNoProxy);

		lpUseSystemSettings = new JLayeredPane();
		lpUseSystemSettings.setBorder(new EtchedBorder(EtchedBorder.RAISED, null, null));

		rdbtnUseSystemSettings = new JRadioButton("Use proxy settings from system");
		rdbtnUseSystemSettings.setBounds(6, 7, 305, 23);
		lpUseSystemSettings.add(rdbtnUseSystemSettings);

		// Group the radio buttons.
		btngrpProxySettings = new ButtonGroup();
		btngrpProxySettings.add(rdbtnNoProxy);
		btngrpProxySettings.add(rdbtnManualProxyConfiguration);

		chckbxSocksProxy = new JCheckBox("SOCKS-Proxy?");
		chckbxSocksProxy.setToolTipText("Is it a SOCKS-Proxy?");
		chckbxSocksProxy.setBounds(26, 63, 97, 23);
		lpHostOrIpaddress.add(chckbxSocksProxy);
		btngrpProxySettings.add(rdbtnUseSystemSettings);
	}
46369
def setup_button_connectors(self):
        """"""
        self.help_button.clicked.connect(self.show_help)
        self.run_button.clicked.connect(self.accept)
        self.about_button.clicked.connect(self.about)
        self.print_button.clicked.connect(self.show_print_dialog)
        self.hazard_layer_combo.currentIndexChanged.connect(
            self.index_changed_hazard_layer_combo)
        self.exposure_layer_combo.currentIndexChanged.connect(
            self.index_changed_exposure_layer_combo)
        self.aggregation_layer_combo.currentIndexChanged.connect(
            self.index_changed_aggregation_layer_combo)
464403
function loadComponent(component) {
        if (component.initialize) {
            component.initialize(app);
        }
        if (component.beforeDispatchCallback) {
            beforeDispatchCallbacks.push(component.beforeDispatchCallback);
        }
        S.defineProperties(app.request, component.requestMethods, true);
        S.defineProperties(app.response, component.responseMethods, true);
        S.defineProperties(Helper.prototype, component.helperMethods, true);
    }
733084
function postTransformComponentRoot (
  el,
  options
) {
  if (!el.parent) {
    // component root
    addAttr(el, '@isComponentRoot', 'true');
    addAttr(el, '@templateId', '_uid');
    addAttr(el, '@componentProps', '$props || {}');
  }
}
475870
def _make_connect(module, args, kwargs):
    
    # pylint: disable-msg=W0142
    return functools.partial(module.connect, *args, **kwargs)
836488
public void setAsContextMenuOf(AbstractClientConnector component) {

        if (component instanceof Table) {
            setAsTableContextMenu((Table)component);
        } else if (component instanceof Tree) {
            setAsTreeContextMenu((Tree)component);
        } else {
            super.extend(component);
        }
    }
1059623
@Activate
    protected void activate(ComponentContext componentContext, Map<String, Object> props) {
        this.componentContext = componentContext;

        // // Parse the configuration that we've been provided
        // Dictionary<?, ?> configProperties = componentContext.getProperties();
        // processConfigProperties(configProperties);

        // Hold a reference to the bundle context
        bundleContext = componentContext.getBundleContext();

        // Start listening to the framework events so we can publish them
        // as specified in section 113.6.3
        frameworkEventAdapter = new FrameworkEventAdapter(this);
        bundleContext.addFrameworkListener(frameworkEventAdapter);

        // Start listening to the bundle events so we can publish them
        // as specified in section 113.6.4
        bundleEventAdapter = new BundleEventAdapter(this);
        bundleContext.addBundleListener(bundleEventAdapter);

        // Start listening to the service events so we can publish them
        // as specified in section 113.6.5
        serviceEventAdapter = new ServiceEventAdapter(this);
        bundleContext.addServiceListener(serviceEventAdapter);
        processConfigProperties(props);
    }
1248567
private void callDoLayout(Container container)
    {
        container.doLayout();
        int n = container.getComponentCount();
        for (int i=0; i<n; i++)
        {
            Component component = container.getComponent(i);
            if (component instanceof Container)
            {
                Container subContainer = (Container)component;
                callDoLayout(subContainer);
            }
        }
    }
1223580
function(connect, callback) {
      callback = callback || function(){};
      var t = this,
          needsConnecting = false,
          logMethod = (connect ? 'connectMonitor' : 'disconnectMonitor'),
          originalParams = null,
          monitor = t.model.get('monitor'),
          isConnected = monitor.isConnected();

      // Determine if we need to connect/disconnect
      if (
          (connect && !isConnected && monitor.get('probeClass')) ||
          (!connect && isConnected)) {
        needsConnecting = true;
      }

      // If no need to connect, callback on next tick.  This makes the
      // call stack consistent regardless of the presence of monitors.
      if (!needsConnecting) {
        log.info(logMethod + '.alreadyConnected', t.logCtxt);
        setTimeout(function(){
          callback(null);
        },0);
        return;
      }

      // If connecting, override the init params with url params
      if (connect) {
        originalParams = monitor.get('initParams');
        monitor.set(
          {initParams: _.extend({}, originalParams, initOverrides)},
          {silent: true}
        );
      }
      else {
        // If disconnecting, remove all change listeners
        monitor.off('change');
      }

      // Connect or disconnect, calling the callback when done
      var connectFn = connect ? 'connect' : 'disconnect';
      log.info(logMethod, t.logCtxt);
      monitor[connectFn](function(error) {

        // Replace original initParams (so the page isn't dirty)
        // Acutal init params will become attributes of the monitor object
        if (originalParams) {
          monitor.set(
            {initParams: originalParams},
            {silent: true}
          );
        }

        // If disconnecting, clear the probe data
        if (!connect) {
          var probeElems = monitor.toProbeJSON();
          delete probeElems.id;
          monitor.set(probeElems, {unset:true});
        }

        // Callback passing error if set
        return callback(error);
      });
    }
28148
protected function callChildComponent($component, IContext $context)
    {
        /**
         * @var IRouter $router
         */
        $router = $component->getRouter();
        $router->setBaseUrl($context->getRouteResult()->getMatchedUrl());

        $componentRequest = $this->createComponentRequest($context->getRouteResult()->getUnmatchedUrl());

        try {
            return $component->execute($componentRequest);
        } catch (\Exception $e) {
            return $this->callErrorController($e, $context);
        }
    }
431312
protected JComponent getInnerComponent(JComponent component) {
		if (component instanceof JScrollPane) {
			return getInnerComponent((JComponent) ((JScrollPane) component).getViewport().getView());
		} if (component instanceof HasInnerComponent) {
            return getInnerComponent(((HasInnerComponent) component).getInnerComponent());
        }
		return component;
	}
766065
@Override
    public void in() throws Exception {
        if (data == null) {
//             throw new ComponentException("Not connected: " + toString());
            if (log.isLoggable(Level.WARNING)) {
                log.warning("@In not connected : " + toString() + ", using default value.");
            }
            return;
        }
        Object val = data.getValue();
        // fire only if there is a listener
        if (ens.shouldFire()) {
            DataflowEvent e = new DataflowEvent(ens.getController(), this, val);
//            DataflowEvent e = new DataflowEvent(ens.getController(), this, access.toObject());
            ens.fireIn(e);
            // the value might be altered
            val = e.getValue();
        }
        
        // type conversion
        
        if (val != null && field.getType() != val.getClass() && !field.getType().isAssignableFrom(val.getClass())) {
//            // default type conversion fails, we need to convert.
//            // this will use the Conversions SPI.
            val = Conversions.convert(val, field.getType());
        }

//        access.pass((Access) val);
        setFieldValue(val);
    }
1208605
void mapInField(Object from, String from_field, Object to, String to_in) {
        if (to == ca.getComponent()) {
            throw new ComponentException("wrong connect:" + from_field);
        }
        ComponentAccess ca_to = lookup(to);
        Access to_access = ca_to.input(to_in);
        checkFA(to_access, to, to_in);
        try {
            FieldContent.FA f = new FieldContent.FA(from, from_field);
            ca_to.setInput(to_in, new FieldObjectAccess(to_access, f, ens));
            if (log.isLoggable(Level.CONFIG)) {
                log.config(String.format("Field(%s) -> @In(%s)", f.toString(), to_access.toString()));
            }

        } catch (Exception E) {
            throw new ComponentException("No such field '" + from.getClass().getCanonicalName() + "." + from_field + "'");
        }
    }
846571
def do_connected(self, args):
        ''''''
        connected = self.label_store.connected_component(args.content_id)
        for label in connected:
            self.stdout.write('{0}\n'.format(label))
1064509
def connect(self, object, callback):
		""""""
		return subscription(self.map.setdefault(object, []), callback)