Exports a frame of the specified SWF to SVG.

        @param swf   The SWF.
        @param frame Which frame to export, by 0-based index (int)
166080
def export(self, swf, frame, **export_opts):
        
        self.wanted_frame = frame
        return super(FrameSVGExporterMixin, self).export(swf, *export_opts)
153156
public void jumpToFrame(int targetFrameNumber) {
    if (mAnimationBackend == null || mFrameScheduler == null) {
      return;
    }
    // In order to jump to a given frame, we have to compute the correct start time
    mLastFrameAnimationTimeMs = mFrameScheduler.getTargetRenderTimeMs(targetFrameNumber);
    mStartTimeMs = now() - mLastFrameAnimationTimeMs;
    mExpectedRenderTimeMs = mStartTimeMs;
    invalidateSelf();
  }
889199
void write(Writer out)
         throws IOException
    {
        out.write("<frame scrolling=\""+scrolling+"\""+resize+border);
        
        if(src!=null)
            out.write(" src=\""+src+"\"");
        if(name!=null)
            out.write(" name=\""+name+"\"");
        out.write(">");
    }
1177831
function(index, style)
	{
		style = YAHOO.lang.JSON.stringify(style);
		if(this._swf && this._swf.setSeriesStylesByIndex) this._swf.setSeriesStylesByIndex(index, style);
	}
701980
public void addFrame(Image frame, int duration) {
		if (duration == 0) {
			Log.error("Invalid duration: "+duration);
			throw new RuntimeException("Invalid duration: "+duration);
		}

	    if (frames.isEmpty()) {
			nextChange = (int) (duration / speed);
		} 
	    
		frames.add(new Frame(frame, duration));
		currentFrame = 0;
	}
792534
function render(Frame $frame) {
    $style = $frame->get_style();
    
    if ( trim($frame->get_node()->nodeValue) === "" && $style->empty_cells === "hide" ) {
      return;
    }

    $this->_set_opacity( $frame->get_opacity( $style->opacity ) );
    list($x, $y, $w, $h) = $frame->get_border_box();
    
    // Draw our background, border and content
    if ( ($bg = $style->background_color) !== "transparent" ) {
      $this->_canvas->filled_rectangle($x, $y, $w, $h, $bg);
    }

    if ( ($url = $style->background_image) && $url !== "none" ) {
      $this->_background_image($url, $x, $y, $w, $h, $style);
    }
    
    $table = Table_Frame_Decorator::find_parent_table($frame);

    if ( $table->get_style()->border_collapse !== "collapse" ) {
      $this->_render_border($frame);
      $this->_render_outline($frame);
      return;
    }

    // The collapsed case is slightly complicated...
    // @todo Add support for outlines here

    $cellmap  = $table->get_cellmap();
    $cells    = $cellmap->get_spanned_cells($frame);
    $num_rows = $cellmap->get_num_rows();
    $num_cols = $cellmap->get_num_cols();

    // Determine the top row spanned by this cell
    $i = $cells["rows"][0];
    $top_row = $cellmap->get_row($i);

    // Determine if this cell borders on the bottom of the table.  If so,
    // then we draw its bottom border.  Otherwise the next row down will
    // draw its top border instead.
    if (in_array( $num_rows - 1, $cells["rows"])) {
      $draw_bottom = true;
      $bottom_row = $cellmap->get_row($num_rows - 1);
    } else
      $draw_bottom = false;


    // Draw the horizontal borders
    foreach ( $cells["columns"] as $j ) {
      $bp = $cellmap->get_border_properties($i, $j);

      $y = $top_row["y"] - $bp["top"]["width"] / 2;

      $col = $cellmap->get_column($j);
      $x = $col["x"] - $bp["left"]["width"] / 2;
      $w = $col["used-width"] + ($bp["left"]["width"] + $bp["right"]["width"] ) / 2;

      if ( $bp["top"]["style"] !== "none" && $bp["top"]["width"] > 0 ) {
        $widths = array($bp["top"]["width"],
                        $bp["right"]["width"],
                        $bp["bottom"]["width"],
                        $bp["left"]["width"]);
        $method = "_border_". $bp["top"]["style"];
        $this->$method($x, $y, $w, $bp["top"]["color"], $widths, "top", "square");
      }

      if ( $draw_bottom ) {
        $bp = $cellmap->get_border_properties($num_rows - 1, $j);
        if ( $bp["bottom"]["style"] === "none" || $bp["bottom"]["width"] <= 0 )
          continue;

        $y = $bottom_row["y"] + $bottom_row["height"] + $bp["bottom"]["width"] / 2;

        $widths = array($bp["top"]["width"],
                        $bp["right"]["width"],
                        $bp["bottom"]["width"],
                        $bp["left"]["width"]);
        $method = "_border_". $bp["bottom"]["style"];
        $this->$method($x, $y, $w, $bp["bottom"]["color"], $widths, "bottom", "square");

      }
    }

    $j = $cells["columns"][0];

    $left_col = $cellmap->get_column($j);

    if (in_array($num_cols - 1, $cells["columns"])) {
      $draw_right = true;
      $right_col = $cellmap->get_column($num_cols - 1);
    } else
      $draw_right = false;

    // Draw the vertical borders
    foreach ( $cells["rows"] as $i ) {
      $bp = $cellmap->get_border_properties($i, $j);

      $x = $left_col["x"] - $bp["left"]["width"] / 2;

      $row = $cellmap->get_row($i);

      $y = $row["y"] - $bp["top"]["width"] / 2;
      $h = $row["height"] + ($bp["top"]["width"] + $bp["bottom"]["width"])/ 2;

      if ( $bp["left"]["style"] !== "none" && $bp["left"]["width"] > 0 ) {

        $widths = array($bp["top"]["width"],
                        $bp["right"]["width"],
                        $bp["bottom"]["width"],
                        $bp["left"]["width"]);

        $method = "_border_" . $bp["left"]["style"];
        $this->$method($x, $y, $h, $bp["left"]["color"], $widths, "left", "square");
      }

      if ( $draw_right ) {
        $bp = $cellmap->get_border_properties($i, $num_cols - 1);
        if ( $bp["right"]["style"] === "none" || $bp["right"]["width"] <= 0 )
          continue;

        $x = $right_col["x"] + $right_col["used-width"] + $bp["right"]["width"] / 2;

        $widths = array($bp["top"]["width"],
                        $bp["right"]["width"],
                        $bp["bottom"]["width"],
                        $bp["left"]["width"]);

        $method = "_border_" . $bp["right"]["style"];
        $this->$method($x, $y, $h, $bp["right"]["color"], $widths, "right", "square");

      }
    }

  }
87212
@SuppressWarnings("unused") // called through reflection by RequestServer
  public FramesV3 column(int version, FramesV3 s) { // TODO: should return a Vec schema
    Frame frame = getFromDKV("key", s.frame_id.key());

    Vec vec = frame.vec(s.column);
    if (null == vec)
      throw new H2OColumnNotFoundArgumentException("column", s.frame_id.toString(), s.column);

    Vec[] vecs = { vec };
    String[] names = { s.column };
    Frame new_frame = new Frame(names, vecs);
    s.frames = new FrameV3[1];
    s.frames[0] = new FrameV3(new_frame);
    ((FrameV3)s.frames[0]).clearBinsField();
    return s;
  }
724045
public function frame($element, $frame)
    {
        if ((false === is_array($frame)) || (1 !== count($frame)) || (false === is_object($frame[0]))) {
            throw new JsonLdException(
                JsonLdException::UNSPECIFIED,
                'The frame is invalid. It must be a single object.',
                $frame
            );
        }

        $frame = $frame[0];

        $options = new JsonObject();
        $options->{'@embed'} = true;
        $options->{'@embedChildren'} = true;   // TODO Change this as soon as the tests haven been updated

        foreach (self::$framingKeywords as $keyword) {
            if (property_exists($frame, $keyword)) {
                $options->{$keyword} = $frame->{$keyword};
                unset($frame->{$keyword});
            } elseif (false === property_exists($options, $keyword)) {
                $options->{$keyword} = false;
            }
        }

        $procOptions = new JsonObject();
        $procOptions->base = (string) $this->baseIri;  // TODO Check which base IRI to use
        $procOptions->compactArrays = $this->compactArrays;
        $procOptions->optimize = $this->optimize;
        $procOptions->useNativeTypes = $this->useNativeTypes;
        $procOptions->useRdfType = $this->useRdfType;
        $procOptions->produceGeneralizedRdf = $this->generalizedRdf;
        $procOptions->documentFactory = $this->documentFactory;
        $procOptions->documentLoader = $this->documentLoader;

        $processor = new Processor($procOptions);

        $graph = JsonLD::MERGED_GRAPH;
        if (property_exists($frame, '@graph')) {
            $graph = JsonLD::DEFAULT_GRAPH;
        }

        $nodeMap = new JsonObject();
        $nodeMap->{'-' . $graph} = new JsonObject();
        $processor->generateNodeMap($nodeMap, $element, $graph);

        // Sort the node map to ensure a deterministic output
        // TODO Move this to a separate function as basically the same is done in flatten()?
        $nodeMap = (array) $nodeMap;
        foreach ($nodeMap as &$nodes) {
            $nodes = (array) $nodes;
            ksort($nodes);
            $nodes = (object) $nodes;
        }
        $nodeMap = (object) $nodeMap;

        unset($processor);

        $result = array();

        foreach ($nodeMap->{'-' . $graph} as $node) {
            $this->nodeMatchesFrame($node, $frame, $options, $nodeMap, $graph, $result);
        }

        return $result;
    }
1370455
public void setFrames (MultiFrameImage frames)
    {
        if (frames == null) {
            // log.warning("Someone set up us the null frames!", "sprite", this);
            return;
        }

        // if these are the same frames we already had, no need to do a bunch of pointless business
        if (frames == _frames) {
            return;
        }

        // set and init our frames
        _frames = frames;
        _frameIdx = 0;
        layout();
    }
782994
void process(ByteChannel sock, AutoBuffer ab) throws IOException {
        int requestType = ab.get1();
        switch (requestType) {
            case CREATE_FRAME:
                ExternalFrameWriterBackend.handleWriteToChunk(sock, ab);
                break;
            case DOWNLOAD_FRAME:
                ExternalFrameReaderBackend.handleReadingFromChunk(sock, ab);
                break;
        }
    }
192505
private ChannelFuture writeContinuationFrames(ChannelHandlerContext ctx, int streamId,
            ByteBuf headerBlock, int padding, SimpleChannelPromiseAggregator promiseAggregator) {
        Http2Flags flags = new Http2Flags().paddingPresent(padding > 0);
        int maxFragmentLength = maxFrameSize - padding;
        // TODO: same padding is applied to all frames, is this desired?
        if (maxFragmentLength <= 0) {
            return promiseAggregator.setFailure(new IllegalArgumentException(
                    "Padding [" + padding + "] is too large for max frame size [" + maxFrameSize + "]"));
        }

        if (headerBlock.isReadable()) {
            // The frame header (and padding) only changes on the last frame, so allocate it once and re-use
            int fragmentReadableBytes = min(headerBlock.readableBytes(), maxFragmentLength);
            int payloadLength = fragmentReadableBytes + padding;
            ByteBuf buf = ctx.alloc().buffer(CONTINUATION_FRAME_HEADER_LENGTH);
            writeFrameHeaderInternal(buf, payloadLength, CONTINUATION, flags, streamId);
            writePaddingLength(buf, padding);

            do {
                fragmentReadableBytes = min(headerBlock.readableBytes(), maxFragmentLength);
                ByteBuf fragment = headerBlock.readRetainedSlice(fragmentReadableBytes);

                payloadLength = fragmentReadableBytes + padding;
                if (headerBlock.isReadable()) {
                    ctx.write(buf.retain(), promiseAggregator.newPromise());
                } else {
                    // The frame header is different for the last frame, so re-allocate and release the old buffer
                    flags = flags.endOfHeaders(true);
                    buf.release();
                    buf = ctx.alloc().buffer(CONTINUATION_FRAME_HEADER_LENGTH);
                    writeFrameHeaderInternal(buf, payloadLength, CONTINUATION, flags, streamId);
                    writePaddingLength(buf, padding);
                    ctx.write(buf, promiseAggregator.newPromise());
                }

                ctx.write(fragment, promiseAggregator.newPromise());

                // Write out the padding, if any.
                if (paddingBytes(padding) > 0) {
                    ctx.write(ZERO_BUFFER.slice(0, paddingBytes(padding)), promiseAggregator.newPromise());
                }
            } while (headerBlock.isReadable());
        }
        return promiseAggregator;
    }
831979
function(frame) {
        if (script2) {
            script2.parentNode.removeChild(script2);
            script2 = null;
        }
        if (script) {
            clearTimeout(tref);
            script.parentNode.removeChild(script);
            script.onreadystatechange = script.onerror =
                script.onload = script.onclick = null;
            script = null;
            callback(frame);
            callback = null;
        }
    }
679899
private void fireFrameType(final CEMI frame, final int type)
	{
		final FrameEvent e = new FrameEvent(this, frame);
		final Consumer<? super TransportListener> c;
		if (type == 0)
			c = l -> l.broadcast(e);
		else if (type == 1)
			c = l -> l.group(e);
		else if (type == 2)
			c = l -> l.dataIndividual(e);
		else if (type == 3)
			c = l -> l.dataConnected(e);
		else
			return;
		listeners.fire(c);
	}
1247997
public function appendMethodFrame(MethodFrame $frame, Buffer $buffer)
    {
        $buffer->appendUint16($frame->classId);
        $buffer->appendUint16($frame->methodId);

        if ($frame instanceof MethodConnectionStartFrame) {
            $buffer->appendUint8($frame->versionMajor);
            $buffer->appendUint8($frame->versionMinor);
            $this->appendTable($frame->serverProperties, $buffer);
            $buffer->appendUint32(strlen($frame->mechanisms)); $buffer->append($frame->mechanisms);
            $buffer->appendUint32(strlen($frame->locales)); $buffer->append($frame->locales);
        } elseif ($frame instanceof MethodConnectionStartOkFrame) {
            $this->appendTable($frame->clientProperties, $buffer);
            $buffer->appendUint8(strlen($frame->mechanism)); $buffer->append($frame->mechanism);
            $buffer->appendUint32(strlen($frame->response)); $buffer->append($frame->response);
            $buffer->appendUint8(strlen($frame->locale)); $buffer->append($frame->locale);
        } elseif ($frame instanceof MethodConnectionSecureFrame) {
            $buffer->appendUint32(strlen($frame->challenge)); $buffer->append($frame->challenge);
        } elseif ($frame instanceof MethodConnectionSecureOkFrame) {
            $buffer->appendUint32(strlen($frame->response)); $buffer->append($frame->response);
        } elseif ($frame instanceof MethodConnectionTuneFrame) {
            $buffer->appendInt16($frame->channelMax);
            $buffer->appendInt32($frame->frameMax);
            $buffer->appendInt16($frame->heartbeat);
        } elseif ($frame instanceof MethodConnectionTuneOkFrame) {
            $buffer->appendInt16($frame->channelMax);
            $buffer->appendInt32($frame->frameMax);
            $buffer->appendInt16($frame->heartbeat);
        } elseif ($frame instanceof MethodConnectionOpenFrame) {
            $buffer->appendUint8(strlen($frame->virtualHost)); $buffer->append($frame->virtualHost);
            $buffer->appendUint8(strlen($frame->capabilities)); $buffer->append($frame->capabilities);
            $this->appendBits([$frame->insist], $buffer);
        } elseif ($frame instanceof MethodConnectionOpenOkFrame) {
            $buffer->appendUint8(strlen($frame->knownHosts)); $buffer->append($frame->knownHosts);
        } elseif ($frame instanceof MethodConnectionCloseFrame) {
            $buffer->appendInt16($frame->replyCode);
            $buffer->appendUint8(strlen($frame->replyText)); $buffer->append($frame->replyText);
            $buffer->appendInt16($frame->closeClassId);
            $buffer->appendInt16($frame->closeMethodId);
        } elseif ($frame instanceof MethodConnectionCloseOkFrame) {
        } elseif ($frame instanceof MethodConnectionBlockedFrame) {
            $buffer->appendUint8(strlen($frame->reason)); $buffer->append($frame->reason);
        } elseif ($frame instanceof MethodConnectionUnblockedFrame) {
        } elseif ($frame instanceof MethodChannelOpenFrame) {
            $buffer->appendUint8(strlen($frame->outOfBand)); $buffer->append($frame->outOfBand);
        } elseif ($frame instanceof MethodChannelOpenOkFrame) {
            $buffer->appendUint32(strlen($frame->channelId)); $buffer->append($frame->channelId);
        } elseif ($frame instanceof MethodChannelFlowFrame) {
            $this->appendBits([$frame->active], $buffer);
        } elseif ($frame instanceof MethodChannelFlowOkFrame) {
            $this->appendBits([$frame->active], $buffer);
        } elseif ($frame instanceof MethodChannelCloseFrame) {
            $buffer->appendInt16($frame->replyCode);
            $buffer->appendUint8(strlen($frame->replyText)); $buffer->append($frame->replyText);
            $buffer->appendInt16($frame->closeClassId);
            $buffer->appendInt16($frame->closeMethodId);
        } elseif ($frame instanceof MethodChannelCloseOkFrame) {
        } elseif ($frame instanceof MethodAccessRequestFrame) {
            $buffer->appendUint8(strlen($frame->realm)); $buffer->append($frame->realm);
            $this->appendBits([$frame->exclusive, $frame->passive, $frame->active, $frame->write, $frame->read], $buffer);
        } elseif ($frame instanceof MethodAccessRequestOkFrame) {
            $buffer->appendInt16($frame->reserved1);
        } elseif ($frame instanceof MethodExchangeDeclareFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->exchangeType)); $buffer->append($frame->exchangeType);
            $this->appendBits([$frame->passive, $frame->durable, $frame->autoDelete, $frame->internal, $frame->nowait], $buffer);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodExchangeDeclareOkFrame) {
        } elseif ($frame instanceof MethodExchangeDeleteFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $this->appendBits([$frame->ifUnused, $frame->nowait], $buffer);
        } elseif ($frame instanceof MethodExchangeDeleteOkFrame) {
        } elseif ($frame instanceof MethodExchangeBindFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->destination)); $buffer->append($frame->destination);
            $buffer->appendUint8(strlen($frame->source)); $buffer->append($frame->source);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
            $this->appendBits([$frame->nowait], $buffer);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodExchangeBindOkFrame) {
        } elseif ($frame instanceof MethodExchangeUnbindFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->destination)); $buffer->append($frame->destination);
            $buffer->appendUint8(strlen($frame->source)); $buffer->append($frame->source);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
            $this->appendBits([$frame->nowait], $buffer);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodExchangeUnbindOkFrame) {
        } elseif ($frame instanceof MethodQueueDeclareFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $this->appendBits([$frame->passive, $frame->durable, $frame->exclusive, $frame->autoDelete, $frame->nowait], $buffer);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodQueueDeclareOkFrame) {
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $buffer->appendInt32($frame->messageCount);
            $buffer->appendInt32($frame->consumerCount);
        } elseif ($frame instanceof MethodQueueBindFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
            $this->appendBits([$frame->nowait], $buffer);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodQueueBindOkFrame) {
        } elseif ($frame instanceof MethodQueuePurgeFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $this->appendBits([$frame->nowait], $buffer);
        } elseif ($frame instanceof MethodQueuePurgeOkFrame) {
            $buffer->appendInt32($frame->messageCount);
        } elseif ($frame instanceof MethodQueueDeleteFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $this->appendBits([$frame->ifUnused, $frame->ifEmpty, $frame->nowait], $buffer);
        } elseif ($frame instanceof MethodQueueDeleteOkFrame) {
            $buffer->appendInt32($frame->messageCount);
        } elseif ($frame instanceof MethodQueueUnbindFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodQueueUnbindOkFrame) {
        } elseif ($frame instanceof MethodBasicQosFrame) {
            $buffer->appendInt32($frame->prefetchSize);
            $buffer->appendInt16($frame->prefetchCount);
            $this->appendBits([$frame->global], $buffer);
        } elseif ($frame instanceof MethodBasicQosOkFrame) {
        } elseif ($frame instanceof MethodBasicConsumeFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $buffer->appendUint8(strlen($frame->consumerTag)); $buffer->append($frame->consumerTag);
            $this->appendBits([$frame->noLocal, $frame->noAck, $frame->exclusive, $frame->nowait], $buffer);
            $this->appendTable($frame->arguments, $buffer);
        } elseif ($frame instanceof MethodBasicConsumeOkFrame) {
            $buffer->appendUint8(strlen($frame->consumerTag)); $buffer->append($frame->consumerTag);
        } elseif ($frame instanceof MethodBasicCancelFrame) {
            $buffer->appendUint8(strlen($frame->consumerTag)); $buffer->append($frame->consumerTag);
            $this->appendBits([$frame->nowait], $buffer);
        } elseif ($frame instanceof MethodBasicCancelOkFrame) {
            $buffer->appendUint8(strlen($frame->consumerTag)); $buffer->append($frame->consumerTag);
        } elseif ($frame instanceof MethodBasicPublishFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
            $this->appendBits([$frame->mandatory, $frame->immediate], $buffer);
        } elseif ($frame instanceof MethodBasicReturnFrame) {
            $buffer->appendInt16($frame->replyCode);
            $buffer->appendUint8(strlen($frame->replyText)); $buffer->append($frame->replyText);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
        } elseif ($frame instanceof MethodBasicDeliverFrame) {
            $buffer->appendUint8(strlen($frame->consumerTag)); $buffer->append($frame->consumerTag);
            $buffer->appendInt64($frame->deliveryTag);
            $this->appendBits([$frame->redelivered], $buffer);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
        } elseif ($frame instanceof MethodBasicGetFrame) {
            $buffer->appendInt16($frame->reserved1);
            $buffer->appendUint8(strlen($frame->queue)); $buffer->append($frame->queue);
            $this->appendBits([$frame->noAck], $buffer);
        } elseif ($frame instanceof MethodBasicGetOkFrame) {
            $buffer->appendInt64($frame->deliveryTag);
            $this->appendBits([$frame->redelivered], $buffer);
            $buffer->appendUint8(strlen($frame->exchange)); $buffer->append($frame->exchange);
            $buffer->appendUint8(strlen($frame->routingKey)); $buffer->append($frame->routingKey);
            $buffer->appendInt32($frame->messageCount);
        } elseif ($frame instanceof MethodBasicGetEmptyFrame) {
            $buffer->appendUint8(strlen($frame->clusterId)); $buffer->append($frame->clusterId);
        } elseif ($frame instanceof MethodBasicAckFrame) {
            $buffer->appendInt64($frame->deliveryTag);
            $this->appendBits([$frame->multiple], $buffer);
        } elseif ($frame instanceof MethodBasicRejectFrame) {
            $buffer->appendInt64($frame->deliveryTag);
            $this->appendBits([$frame->requeue], $buffer);
        } elseif ($frame instanceof MethodBasicRecoverAsyncFrame) {
            $this->appendBits([$frame->requeue], $buffer);
        } elseif ($frame instanceof MethodBasicRecoverFrame) {
            $this->appendBits([$frame->requeue], $buffer);
        } elseif ($frame instanceof MethodBasicRecoverOkFrame) {
        } elseif ($frame instanceof MethodBasicNackFrame) {
            $buffer->appendInt64($frame->deliveryTag);
            $this->appendBits([$frame->multiple, $frame->requeue], $buffer);
        } elseif ($frame instanceof MethodTxSelectFrame) {
        } elseif ($frame instanceof MethodTxSelectOkFrame) {
        } elseif ($frame instanceof MethodTxCommitFrame) {
        } elseif ($frame instanceof MethodTxCommitOkFrame) {
        } elseif ($frame instanceof MethodTxRollbackFrame) {
        } elseif ($frame instanceof MethodTxRollbackOkFrame) {
        } elseif ($frame instanceof MethodConfirmSelectFrame) {
            $this->appendBits([$frame->nowait], $buffer);
        } elseif ($frame instanceof MethodConfirmSelectOkFrame) {
        } else {
            throw new ProtocolException('Unhandled method frame ' . get_class($frame) . '.');
        }
    }
699072
public void sendRequestToWc(FramePPHeaders frame) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "H2StreamProcessor.sendRequestToWc()");
        }

        if (null == frame) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "H2StreamProcessor.sendRequestToWc(): Frame is null");
            }
        } else {
            // Make the headers frame look like it just came in
            WsByteBuffer buf = frame.buildFrameForWrite();
            TCPReadRequestContext readi = h2HttpInboundLinkWrap.getConnectionContext().getReadInterface();
            readi.setBuffer(buf);

            // Call the synchronized method to handle the frame
            try {
                processNextFrame(frame, Constants.Direction.READ_IN);
            } catch (Http2Exception he) {
                // ProcessNextFrame() sends a reset/goaway if an error occurs, nothing left but to clean up
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "H2StreamProcessor.sendRequestToWc(): ProcessNextFrame() error, Exception: " + he);
                }

                // Free the buffer
                buf.release();
            }

        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "H2StreamProcessor.sendRequestToWc()");
        }

    }
675709
public static Component getRootJFrame(Component component)
	{
		while (null != component.getParent())
		{
			component = component.getParent();
			if (component instanceof JFrame)
			{
				break;
			}
		}
		return component;
	}
1108385
public boolean sendFrame(ZFrame frame, int flags)
    {
        final byte[] data = frame.getData();
        final Msg msg = new Msg(data);
        if (socketBase.send(msg, flags)) {
            return true;
        }
        mayRaise();
        return false;
    }