Register built-in effects
510711
private function registerEffects()
    {
        // Both for GD and Imagick
        ImagerService::registerEffect('grayscale', GreyscaleEffect::class);
        ImagerService::registerEffect('greyscale', GreyscaleEffect::class);
        ImagerService::registerEffect('negative', NegativeEffect::class);
        ImagerService::registerEffect('blur', BlurEffect::class);
        ImagerService::registerEffect('sharpen', SharpenEffect::class);
        ImagerService::registerEffect('gamma', GammaEffect::class);
        ImagerService::registerEffect('colorize', ColorizeEffect::class);

        // Imagick only
        ImagerService::registerEffect('colorblend', ColorBlendEffect::class);
        ImagerService::registerEffect('sepia', SepiaEffect::class);
        ImagerService::registerEffect('tint', TintEffect::class);
        ImagerService::registerEffect('contrast', ContrastEffect::class);
        ImagerService::registerEffect('modulate', ModulateEffect::class);
        ImagerService::registerEffect('normalize', NormalizeEffect::class);
        ImagerService::registerEffect('contraststretch', ContrastStretchEffect::class);
        ImagerService::registerEffect('posterize', PosterizeEffect::class);
        ImagerService::registerEffect('unsharpmask', UnsharpMaskEffect::class);
        ImagerService::registerEffect('clut', ClutEffect::class);
        ImagerService::registerEffect('levels', LevelsEffect::class);
        ImagerService::registerEffect('quantize', QuantizeEffect::class);
    }
1009300
protected function registerFacadesAliases(): void
    {
        $loader = AliasLoader::getInstance();

        foreach ((array) $this->facades as $facade => $aliases) {
            foreach ((array) $aliases as $alias) {
                $loader->alias($alias, $facade);
            }
        }
    }
1132
def register_actions(self, shortcut_manager):
        
        shortcut_manager.add_callback_for_action("undo", self.undo)
        shortcut_manager.add_callback_for_action("redo", self.redo)
171230
def register_plugins(self):
        """"""
        registered = set()
        for plugin_fqdn in chain(self.APP_PLUGINS, self.config["PLUGINS"]):
            if plugin_fqdn not in registered:
                self.register_plugin(plugin_fqdn)
                registered.add(plugin_fqdn)
914909
private function registerBindings()
    {
        $this->app->bind('society.isInstalled', function ($app) {
            return
                file_exists(base_path('.env')) &&
                file_exists(storage_path('app/installed')) &&
                Schema::hasTable('migrations');
        });
    }
1144339
function registerListeners() {
  const exit = function exit(signal) {
    console.log(chalk.bgBlack.yellow(`Received ${signal} => Exiting`))
    process.exit()
  }
  const SIGABRT = 'SIGABRT'
  const SIGHUP = 'SIGHUP'
  const SIGINT = 'SIGINT'
  const SIGQUIT = 'SIGQUIT'
  const SIGTERM = 'SIGTERM'

  process.on(SIGABRT, () => exit(SIGABRT))
  process.on(SIGHUP, () => exit(SIGHUP))
  process.on(SIGINT, () => exit(SIGINT))
  process.on(SIGQUIT, () => exit(SIGQUIT))
  process.on(SIGTERM, () => exit(SIGTERM))
}
318992
def register_hooks(func, hooks, obj):
    
    for name, args, kwargs in hooks:
        hook = getattr(obj, name)
        force_call = kwargs.pop("_force_call", False)
        if force_call or len(args) > 0 or len(kwargs) > 0:
            hook = hook(*args, **kwargs)
        hook(func)
887719
def register_builtin_transform(transform, builtin_name):
    

    def _transform_wrapper(node, context=None):
        result = transform(node, context=context)
        if result:
            if not result.parent:
                # Let the transformation function determine
                # the parent for its result. Otherwise,
                # we set it to be the node we transformed from.
                result.parent = node

            if result.lineno is None:
                result.lineno = node.lineno
            if result.col_offset is None:
                result.col_offset = node.col_offset
        return iter([result])

    MANAGER.register_transform(
        nodes.Call,
        inference_tip(_transform_wrapper),
        partial(_builtin_filter_predicate, builtin_name=builtin_name),
    )
14954
function() {
    this.jsonInit({
      "message0": Blockly.Msg.SOUND_SETEFFECTO,
      "args0": [
        {
          "type": "field_dropdown",
          "name": "EFFECT",
          "options": [
            [Blockly.Msg.SOUND_EFFECTS_PITCH, 'PITCH'],
            [Blockly.Msg.SOUND_EFFECTS_PAN, 'PAN']
          ]
        },
        {
          "type": "input_value",
          "name": "VALUE"
        }
      ],
      "category": Blockly.Categories.sound,
      "extensions": ["colours_sounds", "shape_statement"]
    });
  }
153982
function loadEffects(unit, effects = {}) {
  Object.entries(effects).forEach(([effectName, effectCreator]) => {
    const effect = effectCreator(unit);
    unit.addEffect(effectName, effect);
  });
}
159303
def register_view(self, view):
        """"""
        super(GraphicalEditorController, self).register_view(view)

        self.view.connect('meta_data_changed', self._meta_data_changed)
        self.focus_changed_handler_id = self.view.editor.connect('focus-changed', self._move_focused_item_into_viewport)
        self.view.editor.connect("drag-data-received", self.on_drag_data_received)
        self.drag_motion_handler_id = self.view.editor.connect("drag-motion", self.on_drag_motion)

        self.setup_canvas()
754485
protected function registerSignals()
    {
        foreach (self::$signals as $no => $name) {
            if (($name === 'SIGKILL') || ($name == 'SIGSTOP')) {
                continue;
            }

            if (!\pcntl_signal($no, [$this, 'sighandler'], true)) {
                $this->log('Cannot assign ' . $name . ' signal');
            }
        }
    }
1354304
def _Register(self, conditions, callback):
    """"""
    for condition in conditions:
      registered = self._registry.setdefault(condition, [])
      if callback and callback not in registered:
        registered.append(callback)
433304
def setup_addon_register(self, harpoon):
        """"""
        # Create the addon getter and register the crosshairs namespace
        self.addon_getter = AddonGetter()
        self.addon_getter.add_namespace("harpoon.crosshairs", Result.FieldSpec(), Addon.FieldSpec())

        # Initiate the addons from our configuration
        register = Register(self.addon_getter, self)

        if "addons" in harpoon:
            addons = harpoon["addons"]
            if type(addons) in (MergedOptions, dict) or getattr(addons, "is_dict", False):
                spec = sb.dictof(sb.string_spec(), sb.listof(sb.string_spec()))
                meta = Meta(harpoon, []).at("addons")
                for namespace, adns in spec.normalise(meta, addons).items():
                    register.add_pairs(*[(namespace, adn) for adn in adns])

        # Import our addons
        register.recursive_import_known()

        # Resolve our addons
        register.recursive_resolve_imported()

        return register
442262
function register( name, exports, options ) {
    var f       = 'register()'
      , _global = options.global
    ;
    
    de&&ug( f, name, exports, options );
    
    modules[ name ] && fatal( f + ' allready loaded: ' + name );
    
    modules[ name ] = exports || {};
    
    if ( exports && _global ) {
      name = typeof _global == 'string' ? _global : name;
      
      if ( options.no_conflict ) {
        var previous = global[ name ];
        
        exports.no_conflict = function() {
          global[ name ] = previous;
          
          return exports;
        };
      }
      
      global[ name ] = exports;
    }
  }
1355029
def register_plugin(self):
        """"""
        self.main.add_dockwidget(self)

        self.focus_changed.connect(self.main.plugin_focus_changed)
        self.edit_goto.connect(self.main.editor.load)
        self.edit_goto[str, int, str, bool].connect(
                         lambda fname, lineno, word, processevents:
                         self.main.editor.load(fname, lineno, word,
                                               processevents=processevents))
        self.main.editor.breakpoints_saved.connect(self.set_spyder_breakpoints)
        self.main.editor.run_in_current_ipyclient.connect(self.run_script)
        self.main.editor.run_cell_in_ipyclient.connect(self.run_cell)
        self.main.workingdirectory.set_current_console_wd.connect(
                                     self.set_current_client_working_directory)

        self.tabwidget.currentChanged.connect(self.update_working_directory)

        self._remove_old_stderr_files()
1079776
def _register_make(cls):
    ''''''
    assert cls.nxm_headers is not None
    assert cls.nxm_headers is not []
    for nxm_header in cls.nxm_headers:
        assert nxm_header not in _MF_FIELDS
        _MF_FIELDS[nxm_header] = cls.make
    return cls