@param new_val[Boolean] should this appear on the main SelfSvc page?

 @return [void]
345792
def self_service_feature_on_main_page=(new_val)
      return nil if @self_service_feature_on_main_page == new_val
      return nil unless @self_service_data_config[:can_feature_in_categories]
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @self_service_feature_on_main_page = new_val
      @need_to_update = true
    end
463894
def display_fields=(new_val)
      raise JSS::InvalidDataError, 'display_fields must be an Array.' unless new_val.is_a? Array
      return if new_val.sort == @display_fields.sort
      @display_fields = new_val
      @need_to_update = true
    end
625944
function (val) {
            var state = this.state,
                zoom = this.parseZoomValue(val),
                zoomState = state.zoomState,
                currentZoom = zoomState.zoom,
                zoomMode,
                shouldNotCenter;

            // update the zoom mode if we landed on a named mode
            zoomMode = this.calculateZoomMode(val, zoom);

            //respect zoom constraints
            zoom = util.clamp(zoom, state.minZoom, state.maxZoom);

            scope.broadcast('beforezoom', util.extend({
                page: state.currentPage,
                visiblePages: util.extend([], state.visiblePages),
                fullyVisiblePages: util.extend([], state.fullyVisiblePages)
            }, zoomState));

            // update the zoom state
            zoomState.prevZoom = currentZoom;
            zoomState.zoom = zoom;
            zoomState.zoomMode = zoomMode;

            // apply the zoom to the actual DOM element(s)
            this.applyZoom(zoom);

            // can the document be zoomed in/out further?
            zoomState.canZoomIn = this.calculateNextZoomLevel(Crocodoc.ZOOM_IN) !== false;
            zoomState.canZoomOut = this.calculateNextZoomLevel(Crocodoc.ZOOM_OUT) !== false;

            // update page states, because they will have changed after zooming
            this.updatePageStates();

            // layout mode specific stuff
            this.updateLayout();

            // update scroll position for the new zoom
            // @NOTE: updateScrollPosition() must be called AFTER updateLayout(),
            // because the scrollable space may change in updateLayout
            // @NOTE: shouldNotCenter is true when using a named zoom level
            // so that resizing the browser zooms to the current page offset
            // rather than to the center like when zooming in/out
            shouldNotCenter = val === Crocodoc.ZOOM_AUTO ||
                              val === Crocodoc.ZOOM_FIT_WIDTH ||
                              val === Crocodoc.ZOOM_FIT_HEIGHT;
            this.updateScrollPosition(shouldNotCenter);

            // update again, because updateLayout could have changed page positions
            this.updatePageStates();

            // make sure the visible pages are accurate (also update css classes)
            this.updateVisiblePages(true);

            // broadcast zoom event with new zoom state
            scope.broadcast('zoom', util.extend({
                page: state.currentPage,
                visiblePages: util.extend([], state.visiblePages),
                fullyVisiblePages: util.extend([], state.fullyVisiblePages),
                isDraggable: this.isDraggable()
            }, zoomState));
        }
251196
protected Boolean checkBoolean(Object val, Boolean def) {
        return (val == null) ? def : (Boolean) val;
    }
1200278
function(newval){
		if(this.playeronly){ return;}
		if(typeof newval==='string'){
			newval = {edit:1, play:3}[newval.substr(0,4)];
			if(newval===void 0){ return;}
		}
		this.editmode = (newval===this.MODE_EDITOR);
		this.playmode = !this.editmode;

		if(!!this.klass){
			this.cursor.adjust_modechange();
			this.key.keyreset();
			this.mouse.modechange();
			this.board.errclear();
			this.redraw();
		}

		this.emit('config', 'mode', newval);
		this.emit('mode');
	}
1025563
def name=(new_val)
      return nil if new_val == @name
      new_val = nil if new_val == ''
      raise JSS::MissingDataError, "Name can't be empty" unless new_val
      raise JSS::AlreadyExistsError, "A #{RSRC_OBJECT_KEY} already exists with the name '#{args[:name]}'" if JSS.send(LIST_METHOD).values.include?

      ### if the filename is the same, keep it the same
      @filename = new_val if @filename == @name
      @name = new_val

      ### if our REST resource is based on the name, update that too
      @rest_rsrc = "#{RSRC_BASE}/name/#{CGI.escape @name}" if @rest_rsrc.include? '/name/'
      @need_to_update = true
    end
1090995
def checksum_type=(new_val)
      return if new_val == @checksum_type
      raise JSS::InvalidDataError, "Checksum type must be one of: #{CHECKSUM_HASH_TYPES.keys.join ', '} " unless CHECKSUM_HASH_TYPES.key? new_val

      @checksum_type = new_val
      @need_to_update = true
    end
539632
def insertar_inicio(val)
			if @inicio.nil?
				@inicio = Struct::Nodo.new(nil, val, nil)
				@final = @inicio
			else
				copia = @inicio
				@inicio = Struct::Nodo.new(nil, val, copia)
				copia[:ant] = @inicio
			end
		end
1256121
def print_callback(val):
    
    success = False
    try:
        # for reasons I cannot fathom, regular printing, even directly
        # to io.stdout does not work.
        # I have to intrude rather deep into IPython to make it behave
        if have_ipython:
            if InteractiveShell.initialized():
                IPython.display.publish_display_data({'text/plain':val,'text/html':'<pre>' + val + '</pre>'})
                success = True
    except:
        pass

    if not success:
        print(val)
        sys.stdout.flush()
1031609
def offline=(new_val)
      raise JSS::InvalidDataError, 'New value must be boolean true or false' unless JSS::TRUE_FALSE.include? new_val
      @offline = new_val
      @need_to_update = true
    end
876693
def prevent_backup_of_app_data=(new_val)
      return nil if new_val == @prevent_backup_of_app_data
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @prevent_backup_of_app_data = new_val
      @need_to_update = true
    end
605314
def rec_new(self, val):
        
        if val not in self.things:
            for child in val.children():
                self.rec_new(child)
            self.new(val)
        return val
83503
function (newVals) {
            // when clicking on an item in the dropdown list, close the dropdown and save the selected item
            var report = this.controller.checkValue(this.controller.getDataModel().value);
            var arg = {
                stopValueProp : !this._instantBind
            };
            this._reactToControllerReport(report, arg);
            if (this._instantBind && this._dropdownPopup) {
                this._dropdownPopup.updatePosition();
            }
        }
1117306
public void setNewVertexValue(VV newValue) {
		if (setNewVertexValueCalled) {
			throw new IllegalStateException("setNewVertexValue should only be called at most once per updateVertex");
		}
		setNewVertexValueCalled = true;
		if (isOptDegrees()) {
			outValWithDegrees.f1.f0 = newValue;
			outWithDegrees.collect(outValWithDegrees);
		} else {
			outVal.setValue(newValue);
			out.collect(outVal);
		}
	}
587937
def make_available_after_install=(new_val)
      return nil if new_val == @make_available_after_install
      raise JSS::InvalidDataError, 'New value must be true or false' unless new_val.jss_boolean?
      @make_available_after_install = new_val
      @need_to_update = true
    end
1054704
public void push (final T newVal)
  {
    final int index = (int) (m_aCurrentIndex.incrementAndGet () % m_nMaxSize);
    m_aCircularArray[index].set (newVal);
  }
831349
def new_closure(vals):
    
    args = ','.join('x%i' % i for i in range(len(vals)))
    f = eval("lambda %s:lambda:(%s)" % (args, args))
    if sys.version_info[0] >= 3:
        return f(*vals).__closure__
    return f(*vals).func_closure