{@inheritDoc}
@see \Seeren\View\AbstractView::attach()
2772
public function attach(ObserverInterface $observer): SubjectInterface
   {
       if ($observer instanceof PDFTemplate) {
           parent::attach($observer);
       }
       return $this;
   }
458642
public function AttachObserver($observer)
	{
		parent::AttachObserver($observer);
		foreach ($this->DataAdapters as $adapter) {
			$adapter->AttachObserver($observer);
		}
	}
177287
public function setAttachments($attachments)
    {
        $this->removeAttachments();

        if (is_array($attachments)) {
            foreach ($attachments as $attachment) {
                $this->addAttachment($attachment);
            }
        }

        return $this;
    }
1139159
function setAttachment(string $attachment, string $filename = '') {
        $this->attachment = $attachment;
        $this->filename = $filename;
        return $this;
    }
919191
public function includeFunc( View $view)
	{
		if( $this->isFunc() )
		{
			Helper::includeFile( $this->getFuncFilePath(), ["view" => $view], false, true );
		}
		return $this;
	}
742892
public function attach(\Zend\EventManager\EventManagerInterface $oEvents, $iPriority = 1) {
        $this->listeners[] = $oEvents->attach(\Zend\View\ViewEvent::EVENT_RENDERER, array($this, 'selectRenderer'), $iPriority);
        $this->listeners[] = $oEvents->attach(\Zend\View\ViewEvent::EVENT_RESPONSE, array($this, 'injectResponse'), $iPriority);
    }
650107
public function addAttachment($attachment)
    {
        if ($attachment instanceof \SplFileObject && $attachment->isFile() && $attachment->isReadable()) {
            $file['filename'] = method_exists($attachment, 'getAttachmentFilename') ?
                $attachment->getAttachmentFilename() :
                $attachment->getBasename();

            $file['is_embedded'] = method_exists($attachment, 'getIsEmbedded') ? $attachment->getIsEmbedded() : false;
            $file['id'] = method_exists($attachment, 'getId') ? $attachment->getId() : null;

            if (method_exists($attachment, 'getMimeType')) {
                $file['mime_type'] = $attachment->getMimeType();
            } else {
                $resource = finfo_open(FILEINFO_MIME_TYPE);
                $file['mime_type'] = finfo_file($resource, $attachment->getRealPath());
            }

            $file['contents'] = '';
            while (!$attachment->eof()) {
                $file['contents'] .= $attachment->fgets();
            }
            $file['contents'] = base64_encode($file['contents']);

            $this->attachments[] = $file;
        } elseif (is_array($attachment)) {
            $this->attachments[] = $attachment;
        }

        return $this;
    }
486263
public function attach($field, $path)
    {
        $element = $this->resolver->resolveForAttachment($field);

        $element->setFileDetector(new LocalFileDetector)->sendKeys($path);

        return $this;
    }
25362
public function attachTrackerView($view)
    {
        if ( ! $this->trackerViews->contains($view->getKey()))
        {
            return $this->trackerViews()->attach($view);
        }
    }
211559
protected function attachRows($event)
    {
        if (\is_array($event->component->rows)) {
            foreach ($event->component->rows as $row) {
                if (isset($row->modelParent, $row->modelChild)) {
                    $add_params = ['model_parent' => $row->modelParent, 'model_child' => $row->modelChild];

                    if ($event->request->has($row->name)) {
                        if (\is_array($event->request->get($row->name))) {
                            foreach ($event->request->get($row->name) as $value) {
                                $params[$value] = $add_params;
                            }
                            if (isset($params)) {
                                $event->model->getLink($row->modelChild)->sync($params);
                            }
                        } elseif (! \is_object($event->request->get($row->name))) {
                            $params[$event->request->get($row->name)] = $add_params;
                            $event->model->getLink($row->modelChild)->sync($params);
                        }
                    }
                }
            }
        }
    }
883667
public function attach($file)
    {
        if (empty($file)) {
            throw new MailerException('a file is required to use attach!');
        } elseif (!file_exists($file)) {
            throw new MailerException("$file does not exist!");
        }

        $this->_mailer->addAttachment($file);

        return $this;
    }
913503
protected function attach($newStream)
    {
        if (is_resource($newStream) === false) {
            throw new InvalidArgumentException(__METHOD__ . ' argument must be a valid PHP resource');
        }

        if ($this->isAttached() === true) {
            $this->detach();
        }

        $this->stream = $newStream;
    }
1033833
public function attach($returnType, $definition = null)
    {
        if (!$returnType instanceof TypeInterface) {
            $wrong = \is_object($returnType) ? 'instance of '.\get_class($returnType) : \gettype($returnType);

            throw new InvalidArgumentException(
                sprintf('Expecting an instance of %s, got %s', TypeInterface::class, $wrong)
            );
        }

        parent::attach($returnType, $definition);

        return $this;
    }
466191
public function addAttachment($attachment): Letter
    {
        if (!is_file($attachment)) {
            throw new InvalidArgumentException('"%s" can not be found or is not a file');
        }

        $this->attachments[] = $attachment;

        return $this;
    }
74788
function setAttach( $value, $params=FALSE) {
    $attach           = array();
    $attach['value']  = $value ;
    $attach['params'] = $this->_setParams( $params );
    $this->attach[]   = $attach;
  }
953871
public function attach($hook, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null)
    {
        $module_id = null;

        if (strpos($hook, '|') !== false) {
            list($hook, $module_id) = explode('|', $hook, 2);
        }

        $method = $this->getMethod($hook);

        if (isset($module_id)) {
            $class = $this->module->getClass($module_id);
            return $this->call($class, $method, $a, $b, $c, $d, $e);
        }

        if (empty($this->hooks[$method])) {
            return false;
        }

        foreach (array_keys($this->hooks[$method]) as $class) {
            $this->call($class, $method, $a, $b, $c, $d, $e);
        }

        return true;
    }
394462
function AddAttachment($path, $name = "", $encoding = "base64", $type = "application/octet-stream") {
      if(!@is_file($path))
      {
         $this->error_handler(sprintf("Could not find %s file on filesystem", $path));
         return false;
      }

      $filename = basename($path);
      if($name == "")
         $name = $filename;

      // Append to $attachment array
      $cur = count($this->attachment);
      $this->attachment[$cur][0] = $path;
      $this->attachment[$cur][1] = $filename;
      $this->attachment[$cur][2] = $name;
      $this->attachment[$cur][3] = $encoding;
      $this->attachment[$cur][4] = $type;
      $this->attachment[$cur][5] = false; // isStringAttachment

      return true;
   }