Set the visibility of the section.

@param boolean $visible true if it must be visible, false otherwise.
@throws \InvalidArgumentException If $visible is not a boolean.
320897
public function setVisible($visible)
    {
        if (is_bool($visible)) {
            $this->visible = $visible;
        } else {
            $msg = "Visible must be a boolean, '" . gettype($visible) . "' given.";
            throw new InvalidArgumentException($msg);
        }
    }
51736
public void setThresholdVisible(final boolean VISIBLE) {
        if (null == thresholdVisible) {
            _thresholdVisible = VISIBLE;
            fireUpdateEvent(VISIBILITY_EVENT);
        } else {
            thresholdVisible.set(VISIBLE);
        }
    }
431877
public void setSectionTextVisible(final boolean VISIBLE) {
        if (null == sectionTextVisible) {
            _sectionTextVisible = VISIBLE;
            fireTileEvent(REDRAW_EVENT);
        } else {
            sectionTextVisible.set(VISIBLE);
        }
    }
1224429
public function isSatisfiedBy(Entity $entity)
    {
        if (property_exists($entity, 'visible')) {
            return (bool)$entity->visible;
        }

        throw new InvalidArgumentException("Property 'visible' does not exist in class " . get_class($entity));
    }
993222
public function setVisibility($path, $visibility)
    {
        return (bool) $this->client->PutObjectAcl([
            'Bucket' => $this->getBucket(),
            'Key'    => $path,
            'ACL'    => $this->normalizeVisibility($visibility),
        ]);
    }
1123433
private function update_visible($visible = null) {
        global $DB;

        if (!empty($visible)) {
            $this->_visible = $visible;
        }
        else if (!isset($this->_visible)) {
            throw new repository_exception('updateemptyvisible', 'repository');
        }

        cache::make('core', 'repositories')->purge();
        return $DB->set_field('repository', 'visible', $this->_visible, array('type'=>$this->_typename));
    }
1361300
public void setSecondsVisible(boolean VISIBLE) {
        if (null == secondsVisible) {
            _secondsVisible = VISIBLE;
            fireTileEvent(REDRAW_EVENT);
        } else {
            secondsVisible.set(VISIBLE);
        }
    }
1125673
public function setVisibility($path, $visibility)
    {
        $command = $this->s3Client->getCommand(
            'putObjectAcl',
            [
                'Bucket' => $this->bucket,
                'Key'    => $this->applyPathPrefix($path),
                'ACL'    => $visibility === AdapterInterface::VISIBILITY_PUBLIC ? 'public-read' : 'private',
            ]
        );

        try {
            $this->s3Client->execute($command);
        } catch (S3Exception $exception) {
            return false;
        }

        return compact('path', 'visibility');
    }
656494
public void setOpenerVisible(boolean visible) {

        if (visible) {
            m_opener.getElement().getStyle().clearDisplay();
        } else {
            m_opener.getElement().getStyle().setDisplay(Display.NONE);
        }
    }
499620
public function setMutatorVisibility($visibility)
    {
        $visibility = strtolower($visibility);
        if (!in_array($visibility, self::$validVisibilities)) {
            $visibility = self::DEFAULT_VISIBILITY;
        }

        $this->mutatorVisibility = $visibility;
    }
1011207
public void setAverageVisible(final boolean VISIBLE) {
        if (null == averageVisible) {
            _averageVisible = VISIBLE;
            fireTileEvent(VISIBILITY_EVENT);
        } else {
            averageVisible.set(VISIBLE);
        }
    }
663842
public void setSecondsVisible(boolean VISIBLE) { 
        if (null == secondsVisible) {
            _secondsVisible = VISIBLE;
            fireUpdateEvent(VISIBILITY_EVENT);
        } else {
            secondsVisible.set(VISIBLE);
        }
    }
99238
public function limitMaximumSetVisibility(string $visibility): self
    {
        $this->generate_set = Generate::getMostLimitedVisibility($this->generate_set, $visibility);

        return $this;
    }
97759
public function setOption($option)
    {
        if (!isset(static::$availableOptions[$option])) {
            throw new \InvalidArgumentException(sprintf(
                'Invalid option specified: "%s". Expected one of (%s)',
                $option,
                implode(', ', array_keys(static::$availableOptions))
            ));
        }
        if (!in_array(static::$availableOptions[$option], $this->options, true)) {
            $this->options[] = static::$availableOptions[$option];
        }
    }
1156893
public function isVisibilityAllowed($visibility)
    {
        $visibilityAllowed = $this->getSettings()
            ? $this->getSettings()->getVisibility()
            : Settings::VISIBILITY_DEFAULT;

        return (bool) ($visibilityAllowed & $visibility);
    }
1010307
@Api
	public void setVisible(boolean visible) {
		if (visible != this.visible) {
			this.visible = visible;
			updateShowing(false);
			handlerManager.fireEvent(new LayerShownEvent(this));
		}
	}
1176841
public function setFieldVisibility($visibility)
    {
        if ($visibility !== static::FIELD_VISIBLE_PRIVATE && $visibility !== static::FIELD_VISIBLE_PROTECTED) {
            throw new \InvalidArgumentException('Invalid provided visibility (only private and protected are allowed): ' . $visibility);
        }

        $this->fieldVisibility = $visibility;
    }