Building the frame sources for the given images

@param $frames
@param $durations

@return $this
@throws \Exception
766771
private function buildFrameSources($frames, $durations)
    {
        $i = 0;
        foreach ($frames as $frame) {
            $resourceImage = $frame;
            if (is_resource($frame)) { // in-memory image resource (hopefully)
                $resourceImg = $frame;
                ob_start();
                imagegif($frame);
                $this->sources[] = ob_get_contents();
                ob_end_clean();
                if (substr($this->sources[ $i ], 0, 6) != 'GIF87a' && substr($this->sources[ $i ], 0, 6) != 'GIF89a') {
                    throw new \Exception($i.' '.$this->errors[ 'ERR01' ]);
                }

            } elseif (is_string($frame)) { // file path, URL or binary data

                if (@is_readable($frame)) { // file path
                    $bin = file_get_contents($frame);
                } else {
                    if (filter_var($frame, FILTER_VALIDATE_URL)) {
                        if (ini_get('allow_url_fopen')) {
                            $bin = @file_get_contents($frame);
                        } else {
                            throw new \Exception($i.' '.$this->errors[ 'ERR04' ]);
                        }
                    } else {
                        $bin = $frame;
                    }
                }

                if (! ($bin && ($resourceImage = imagecreatefromstring($bin)))) {
                    throw new \Exception($i.' '.sprintf($this->errors[ 'ERR05' ], substr($frame, 0, 200)));
                }
                ob_start();
                imagegif($resourceImage);
                $this->sources[] = ob_get_contents();
                ob_end_clean();

            } else { // Fail
                throw new \Exception($this->errors[ 'ERR02' ]);
            }
            if ($i == 0) {
                $this->transparent_color = imagecolortransparent($resourceImage);
            }

            for ($j = (13 + 3 * (2 << (ord($this->sources[ $i ]{10}) & 0x07))), $k = true; $k; $j++) {

                switch ($this->sources[ $i ]{$j}) {

                    case '!':
                        if ((substr($this->sources[ $i ], ($j + 3), 8)) == 'NETSCAPE') {

                            throw new \Exception($this->errors[ 'ERR03' ].' ('.($i + 1).' source).');
                        }

                        break;

                    case ';':
                        $k = false;
                        break;
                }
            }
            unset($resourceImg);
            ++$i;
        }//foreach

        $this->gifAddHeader();
        for ($i = 0; $i < count($this->sources); $i++) {
            // Use the last delay, if none has been specified for the current frame
            if (is_array($durations)) {
                $d                          = (empty($durations[ $i ]) ? $this->config[ 'duration' ] : $durations[ $i ]);
                $this->config[ 'duration' ] = $d;
            } else {
                $d = $durations;
            }
            $this->addFrame($i, $d);
        }
        $this->gif .= ';';

        return $this;
    }
155636
public function from($sources)
    {
        if (!$sources) {
            throw new SqlException("A `FROM` clause requires a non empty table.");
        }
        $sources = is_array($sources) ? $sources : func_get_args();
        $this->_parts['from'] += array_merge($this->_parts['from'], $sources);
        return $this;
    }
172465
public function from($tables)
    {
        if (is_array($tables)) {
            $this->from = $tables;
        } else {
            $this->from = array($tables);
        }
        return $this;
    }
800307
public function from($tables)
  {
    if ( is_null($this->from) ){
      $this->from = new Element('FROM', $tables);
    }
    else {
      $this->from->append($tables);
    }

    return $this;
  }
830339
protected function initSourceImageResource() 
    { 
    	$ext = $this->getExtension();
    	
    	switch($ext) {
		case 'gif':
			$this->sourceImageResource = ImageCreateFromGif($this->sourceImagePath);
			break;
    	
		case 'jpg':
			$this->sourceImageResource = ImageCreateFromJpeg($this->sourceImagePath);
			break;
    	
		case 'png':
			$this->sourceImageResource = ImageCreateFromPng($this->sourceImagePath);
			break;
    	
		default:
			throw new \RuntimeException("An error occurred trying to create the image, extension '" . $ext. "' is not supported");
			break;
    	}
    	
    	return $this;
    }
1225696
public function setBreacrumbLinks($links) {
        if(is_array($links) && !empty($links)) {
            $this->links = $links;
        }
        return $this;
    }
1184735
public function addSources(array $sources)
    {
        foreach ($sources as $s) {
            if (!file_exists($s)) {
                throw new \Exception(sprintf('Unable to compress %s because the destination doesn\'t exist.', $s));
            }
            $this->sources[] = $s;
        }
    }
194519
protected function initSources(array $sources)
    {
        foreach ($sources as $source) {
            $this->sources[] = new EntitySource($this, $source);
        }
    }
326493
public function withImage($images)
    {
        collect($images)->each(function ($image) {
            $this->images[] = new TwitterImage($image);
        });

        return $this;
    }
970800
public function setChildren($children)
    {
        if (is_array($children)) {
            $c = [];
            foreach ($children as $name => $child) {
                list($package, $link, $children) = $child;
                $c[] = new self($name, $this->type, $package, $link, $children);
            }

            $this->children = $c;
        }

        return $this;
    }
554061
public function build(): BeginFrameRequest
	{
		$instance = new BeginFrameRequest();
		$instance->frameTimeTicks = $this->frameTimeTicks;
		$instance->interval = $this->interval;
		$instance->noDisplayUpdates = $this->noDisplayUpdates;
		$instance->screenshot = $this->screenshot;
		return $instance;
	}
463556
public function from(...$tables)
    {
        foreach ($tables as $table)
        {
            if (is_string($table))
            {
                $this->storageFrom[$table] = $table;
                continue;
            }

            $key  = key($table);
            $item = current($table); // RawQuery

            $this->storageFrom[$key] = $item;
        }

        return $this;
    }
1179583
public function setAttachments(array $attachments): self
    {
        $this->clearAttachments();

        foreach ($attachments as $attachment) {
            $this->attach($attachment);
        }

        return $this;
    }
531794
public function run(array $sources, array $destinations)
    {
        $fileSystem = new Filesystem();
        
        // must have the same sources and destinations number
        if (count($sources) !== count($destinations) && count($destinations) !== 1) {
            throw new Exception('Sources and destinations count mismatch');
        }
        
        // if only one destination is specified for multiple sources, it should be a directory. We should create it if
        // it is not exists
        if (count($destinations) === 1 && !is_dir($destinations[0]) && count($sources) > 1) {
            $fileSystem->mkdir($destinations[0]);
        }
        $copiedFiles = [];
        
        // copy generated files to its destination
        foreach ($sources as $index => $source) {
            
            if (array_key_exists($index, $destinations)) {
                $destination = $destinations[$index];
            } else {
                $destination = $destinations[0];
            }
            
            if (is_dir($destination)) {
                $destination = $this->removeLastSlash($destination);
                
                if ($source instanceof \Symfony\Component\Finder\SplFileInfo && $source->getRelativePath()) {
                    $destination .= '/'.$source->getRelativePath();
                }
                $destination .= '/'.$source->getFilename();
            }
            $this->addNotification('copying "'.$source.'" to "'.$destination.'"');
            
            $fileSystem->copy($source->getRealPath(), $destination);
            $copiedFiles[] = $destination;
        }
        
        return $copiedFiles;
    }
577864
public function setExpires($expires)
    {
        if ($expires !== null && !$expires instanceof \DateTime) {
            $expires = new \DateTime('@' . $expires);
        }
        $this->expires = $expires;

        return $this;
    }
427714
public function plus(Duration $duration) : Duration
    {
        if ($duration->isZero()) {
            return $this;
        }

        $seconds = $this->seconds + $duration->seconds;
        $nanos = $this->nanos + $duration->nanos;

        if ($nanos >= LocalTime::NANOS_PER_SECOND) {
            $nanos -= LocalTime::NANOS_PER_SECOND;
            $seconds++;
        }

        return new Duration($seconds, $nanos);
    }
1223156
function add_frame(Frame $frame) {
    
    $style = $frame->get_style();
    $display = $style->display;

    $collapse = $this->_table->get_style()->border_collapse == "collapse";

    // Recursively add the frames within tables, table-row-groups and table-rows
    if ( $display === "table-row" ||
         $display === "table" ||
         $display === "inline-table" ||
         in_array($display, Table_Frame_Decorator::$ROW_GROUPS) ) {

      $start_row = $this->__row;
      foreach ( $frame->get_children() as $child )
        $this->add_frame( $child );

      if ( $display === "table-row" )
        $this->add_row();

      $num_rows = $this->__row - $start_row - 1;
      $key = $frame->get_id();

      // Row groups always span across the entire table
      $this->_frames[$key]["columns"] = range(0,max(0,$this->_num_cols-1));
      $this->_frames[$key]["rows"] = range($start_row, max(0, $this->__row - 1));
      $this->_frames[$key]["frame"] = $frame;

      if ( $display !== "table-row" && $collapse ) {

        $bp = $style->get_border_properties();

        // Resolve the borders
        for ( $i = 0; $i < $num_rows+1; $i++) {
          $this->_resolve_border($start_row + $i, 0, "vertical", $bp["left"]);
          $this->_resolve_border($start_row + $i, $this->_num_cols, "vertical", $bp["right"]);
        }

        for ( $j = 0; $j < $this->_num_cols; $j++) {
          $this->_resolve_border($start_row, $j, "horizontal", $bp["top"]);
          $this->_resolve_border($this->__row, $j, "horizontal", $bp["bottom"]);
        }
      }


      return;
    }
    
    $node = $frame->get_node();
    
    // Determine where this cell is going
    $colspan = $node->getAttribute("colspan");
    $rowspan = $node->getAttribute("rowspan");

    if ( !$colspan ) {
      $colspan = 1;
      $node->setAttribute("colspan",1);
    }

    if ( !$rowspan ) {
      $rowspan = 1;
      $node->setAttribute("rowspan",1);
    }
    $key = $frame->get_id();

    $bp = $style->get_border_properties();


    // Add the frame to the cellmap
    $max_left = $max_right = 0;

    // Find the next available column (fix by Ciro Mondueri)
    $ac = $this->__col;
    while ( isset($this->_cells[$this->__row][$ac]) )
       $ac++;
    $this->__col = $ac;

    // Rows:
    for ( $i = 0; $i < $rowspan; $i++ ) {
      $row = $this->__row + $i;

      $this->_frames[$key]["rows"][] = $row;

      for ( $j = 0; $j < $colspan; $j++)
        $this->_cells[$row][$this->__col + $j] = $frame;

      if ( $collapse ) {
        // Resolve vertical borders
        $max_left = max($max_left, $this->_resolve_border($row, $this->__col, "vertical", $bp["left"]));
        $max_right = max($max_right, $this->_resolve_border($row, $this->__col + $colspan, "vertical", $bp["right"]));
      }
    }

    $max_top = $max_bottom = 0;

    // Columns:
    for ( $j = 0; $j < $colspan; $j++ ) {
      $col = $this->__col + $j;
      $this->_frames[$key]["columns"][] = $col;

      if ( $collapse ) {
        // Resolve horizontal borders
        $max_top = max($max_top, $this->_resolve_border($this->__row, $col, "horizontal", $bp["top"]));
        $max_bottom = max($max_bottom, $this->_resolve_border($this->__row + $rowspan, $col, "horizontal", $bp["bottom"]));
      }
    }

    $this->_frames[$key]["frame"] = $frame;

    // Handle seperated border model
    if ( !$collapse ) {
      list($h, $v) = $this->_table->get_style()->border_spacing;

      // Border spacing is effectively a margin between cells
      $v = $style->length_in_pt($v) / 2;
      $h = $style->length_in_pt($h) / 2;
      $style->margin = "$v $h";

      // The additional 1/2 width gets added to the table proper

    } else {

      // Drop the frame's actual border
      $style->border_left_width = $max_left / 2;
      $style->border_right_width = $max_right / 2;
      $style->border_top_width = $max_top / 2;
      $style->border_bottom_width = $max_bottom / 2;
      $style->margin = "none";
    }

    // Resolve the frame's width
    list($frame_min, $frame_max) = $frame->get_min_max_width();

    $width = $style->width;

    if ( is_percent($width) ) {
      $var = "percent";
      $val = (float)rtrim($width, "% ") / $colspan;

    } else if ( $width !== "auto" ) {
      $var = "absolute";
      $val = $style->length_in_pt($frame_min) / $colspan;
    }

    if (!$this->_columns_locked) {
      $min = 0;
      $max = 0;
      for ( $cs = 0; $cs < $colspan; $cs++ ) {
  
        // Resolve the frame's width(s) with other cells
        $col =& $this->get_column( $this->__col + $cs );
  
        // Note: $var is either 'percent' or 'absolute'.  We compare the
        // requested percentage or absolute values with the existing widths
        // and adjust accordingly.
        if ( isset($var) && $val > $col[$var] ) {
          $col[$var] = $val;
          $col["auto"] = false;
        }
  
        $min += $col["min-width"];
        $max += $col["max-width"];
      }
  
  
      if ( $frame_min > $min ) {
        // The frame needs more space.  Expand each sub-column
        $inc = ($frame_min - $min) / $colspan;
        for ($c = 0; $c < $colspan; $c++) {
          $col =& $this->get_column($this->__col + $c);
          $col["min-width"] += $inc;
        }
      }
  
      if ( $frame_max > $max ) {
        $inc = ($frame_max - $max) / $colspan;
        for ($c = 0; $c < $colspan; $c++) {
          $col =& $this->get_column($this->__col + $c);
          $col["max-width"] += $inc;
        }
      }
    }

    $this->__col += $colspan;
    if ( $this->__col > $this->_num_cols )
      $this->_num_cols = $this->__col;

  }