_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q8400 | CopyConvolutionFilter2D | train | func CopyConvolutionFilter2D(target uint32, internalformat uint32, x int32, y int32, width int32, height int32) {
C.glowCopyConvolutionFilter2D(gpCopyConvolutionFilter2D, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLint)(x), (C.GLint)(y), (C.GLsizei)(width), (C.GLsizei)(height))
} | go | {
"resource": ""
} |
q8401 | DebugMessageCallback | train | func DebugMessageCallback(callback DebugProc, userParam unsafe.Pointer) {
userDebugCallback = callback
C.glowDebugMessageCallback(gpDebugMessageCallback, (C.GLDEBUGPROC)(unsafe.Pointer(&callback)), userParam)
} | go | {
"resource": ""
} |
q8402 | DrawArraysInstanced | train | func DrawArraysInstanced(mode uint32, first int32, count int32, instancecount int32) {
C.glowDrawArraysInstanced(gpDrawArraysInstanced, (C.GLenum)(mode), (C.GLint)(first), (C.GLsizei)(count), (C.GLsizei)(instancecount))
} | go | {
"resource": ""
} |
q8403 | DrawElementsInstanced | train | func DrawElementsInstanced(mode uint32, count int32, xtype uint32, indices unsafe.Pointer, instancecount int32) {
C.glowDrawElementsInstanced(gpDrawElementsInstanced, (C.GLenum)(mode), (C.GLsizei)(count), (C.GLenum)(xtype), indices, (C.GLsizei)(instancecount))
} | go | {
"resource": ""
} |
q8404 | FramebufferTexture | train | func FramebufferTexture(target uint32, attachment uint32, texture uint32, level int32) {
C.glowFramebufferTexture(gpFramebufferTexture, (C.GLenum)(target), (C.GLenum)(attachment), (C.GLuint)(texture), (C.GLint)(level))
} | go | {
"resource": ""
} |
q8405 | GetBufferParameteri64v | train | func GetBufferParameteri64v(target uint32, pname uint32, params *int64) {
C.glowGetBufferParameteri64v(gpGetBufferParameteri64v, (C.GLenum)(target), (C.GLenum)(pname), (*C.GLint64)(unsafe.Pointer(params)))
} | go | {
"resource": ""
} |
q8406 | GetColorTable | train | func GetColorTable(target uint32, format uint32, xtype uint32, table unsafe.Pointer) {
C.glowGetColorTable(gpGetColorTable, (C.GLenum)(target), (C.GLenum)(format), (C.GLenum)(xtype), table)
} | go | {
"resource": ""
} |
q8407 | GetConvolutionFilter | train | func GetConvolutionFilter(target uint32, format uint32, xtype uint32, image unsafe.Pointer) {
C.glowGetConvolutionFilter(gpGetConvolutionFilter, (C.GLenum)(target), (C.GLenum)(format), (C.GLenum)(xtype), image)
} | go | {
"resource": ""
} |
q8408 | GetFragDataLocation | train | func GetFragDataLocation(program uint32, name *uint8) int32 {
ret := C.glowGetFragDataLocation(gpGetFragDataLocation, (C.GLuint)(program), (*C.GLchar)(unsafe.Pointer(name)))
return (int32)(ret)
} | go | {
"resource": ""
} |
q8409 | GetHistogram | train | func GetHistogram(target uint32, reset bool, format uint32, xtype uint32, values unsafe.Pointer) {
C.glowGetHistogram(gpGetHistogram, (C.GLenum)(target), (C.GLboolean)(boolToInt(reset)), (C.GLenum)(format), (C.GLenum)(xtype), values)
} | go | {
"resource": ""
} |
q8410 | GetMinmax | train | func GetMinmax(target uint32, reset bool, format uint32, xtype uint32, values unsafe.Pointer) {
C.glowGetMinmax(gpGetMinmax, (C.GLenum)(target), (C.GLboolean)(boolToInt(reset)), (C.GLenum)(format), (C.GLenum)(xtype), values)
} | go | {
"resource": ""
} |
q8411 | GetSeparableFilter | train | func GetSeparableFilter(target uint32, format uint32, xtype uint32, row unsafe.Pointer, column unsafe.Pointer, span unsafe.Pointer) {
C.glowGetSeparableFilter(gpGetSeparableFilter, (C.GLenum)(target), (C.GLenum)(format), (C.GLenum)(xtype), row, column, span)
} | go | {
"resource": ""
} |
q8412 | GetTransformFeedbackVarying | train | func GetTransformFeedbackVarying(program uint32, index uint32, bufSize int32, length *int32, size *int32, xtype *uint32, name *uint8) {
C.glowGetTransformFeedbackVarying(gpGetTransformFeedbackVarying, (C.GLuint)(program), (C.GLuint)(index), (C.GLsizei)(bufSize), (*C.GLsizei)(unsafe.Pointer(length)), (*C.GLsizei)(unsafe.Pointer(size)), (*C.GLenum)(unsafe.Pointer(xtype)), (*C.GLchar)(unsafe.Pointer(name)))
} | go | {
"resource": ""
} |
q8413 | Histogram | train | func Histogram(target uint32, width int32, internalformat uint32, sink bool) {
C.glowHistogram(gpHistogram, (C.GLenum)(target), (C.GLsizei)(width), (C.GLenum)(internalformat), (C.GLboolean)(boolToInt(sink)))
} | go | {
"resource": ""
} |
q8414 | Minmax | train | func Minmax(target uint32, internalformat uint32, sink bool) {
C.glowMinmax(gpMinmax, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLboolean)(boolToInt(sink)))
} | go | {
"resource": ""
} |
q8415 | SeparableFilter2D | train | func SeparableFilter2D(target uint32, internalformat uint32, width int32, height int32, format uint32, xtype uint32, row unsafe.Pointer, column unsafe.Pointer) {
C.glowSeparableFilter2D(gpSeparableFilter2D, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLsizei)(width), (C.GLsizei)(height), (C.GLenum)(format), (C.GLenum)(xtype), row, column)
} | go | {
"resource": ""
} |
q8416 | TexBuffer | train | func TexBuffer(target uint32, internalformat uint32, buffer uint32) {
C.glowTexBuffer(gpTexBuffer, (C.GLenum)(target), (C.GLenum)(internalformat), (C.GLuint)(buffer))
} | go | {
"resource": ""
} |
q8417 | TransformFeedbackVaryings | train | func TransformFeedbackVaryings(program uint32, count int32, varyings **uint8, bufferMode uint32) {
C.glowTransformFeedbackVaryings(gpTransformFeedbackVaryings, (C.GLuint)(program), (C.GLsizei)(count), (**C.GLchar)(unsafe.Pointer(varyings)), (C.GLenum)(bufferMode))
} | go | {
"resource": ""
} |
q8418 | VertexAttribDivisor | train | func VertexAttribDivisor(index uint32, divisor uint32) {
C.glowVertexAttribDivisor(gpVertexAttribDivisor, (C.GLuint)(index), (C.GLuint)(divisor))
} | go | {
"resource": ""
} |
q8419 | GetnCompressedTexImage | train | func GetnCompressedTexImage(target uint32, lod int32, bufSize int32, pixels unsafe.Pointer) {
C.glowGetnCompressedTexImage(gpGetnCompressedTexImage, (C.GLenum)(target), (C.GLint)(lod), (C.GLsizei)(bufSize), pixels)
} | go | {
"resource": ""
} |
q8420 | GetnTexImage | train | func GetnTexImage(target uint32, level int32, format uint32, xtype uint32, bufSize int32, pixels unsafe.Pointer) {
C.glowGetnTexImage(gpGetnTexImage, (C.GLenum)(target), (C.GLint)(level), (C.GLenum)(format), (C.GLenum)(xtype), (C.GLsizei)(bufSize), pixels)
} | go | {
"resource": ""
} |
q8421 | NewWebsocketDialer | train | func NewWebsocketDialer(handler http.Handler) *websocket.Dialer {
return &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
hc := newHandlerConn()
hc.runHandler(handler)
return hc, nil
},
}
} | go | {
"resource": ""
} |
q8422 | NewFastWebsocketDialer | train | func NewFastWebsocketDialer(handler fasthttp.RequestHandler) *websocket.Dialer {
return &websocket.Dialer{
NetDial: func(network, addr string) (net.Conn, error) {
hc := newHandlerConn()
hc.runFastHandler(handler)
return hc, nil
},
}
} | go | {
"resource": ""
} |
q8423 | Hijack | train | func (r *hijackRecorder) Hijack() (net.Conn, *bufio.ReadWriter, error) {
rw := bufio.NewReadWriter(bufio.NewReader(r.conn), bufio.NewWriter(r.conn))
return r.conn, rw, nil
} | go | {
"resource": ""
} |
q8424 | WriteHeader | train | func (r *hijackRecorder) WriteHeader(code int) {
resp := http.Response{StatusCode: code, Header: r.Header()}
_ = resp.Write(r.conn)
} | go | {
"resource": ""
} |
q8425 | Raw | train | func (m *WebsocketMessage) Raw() (typ int, content []byte, closeCode int) {
return m.typ, m.content, m.closeCode
} | go | {
"resource": ""
} |
q8426 | NewRequest | train | func (DefaultRequestFactory) NewRequest(
method, urlStr string, body io.Reader) (*http.Request, error) {
return http.NewRequest(method, urlStr, body)
} | go | {
"resource": ""
} |
q8427 | Request | train | func (e *Expect) Request(method, path string, pathargs ...interface{}) *Request {
req := NewRequest(e.config, method, path, pathargs...)
for _, builder := range e.builders {
builder(req)
}
for _, matcher := range e.matchers {
req.WithMatcher(matcher)
}
return req
} | go | {
"resource": ""
} |
q8428 | NoContent | train | func (r *Response) NoContent() *Response {
if r.chain.failed() {
return r
}
contentType := r.resp.Header.Get("Content-Type")
r.checkEqual("\"Content-Type\" header", "", contentType)
r.checkEqual("body", "", string(r.content))
return r
} | go | {
"resource": ""
} |
q8429 | ContentType | train | func (r *Response) ContentType(mediaType string, charset ...string) *Response {
r.checkContentType(mediaType, charset...)
return r
} | go | {
"resource": ""
} |
q8430 | ContentEncoding | train | func (r *Response) ContentEncoding(encoding ...string) *Response {
if r.chain.failed() {
return r
}
r.checkEqual("\"Content-Encoding\" header", encoding, r.resp.Header["Content-Encoding"])
return r
} | go | {
"resource": ""
} |
q8431 | TransferEncoding | train | func (r *Response) TransferEncoding(encoding ...string) *Response {
if r.chain.failed() {
return r
}
r.checkEqual("\"Transfer-Encoding\" header", encoding, r.resp.TransferEncoding)
return r
} | go | {
"resource": ""
} |
q8432 | NewWebsocket | train | func NewWebsocket(config Config, conn *websocket.Conn) *Websocket {
return makeWebsocket(config, makeChain(config.Reporter), conn)
} | go | {
"resource": ""
} |
q8433 | WithReadTimeout | train | func (c *Websocket) WithReadTimeout(timeout time.Duration) *Websocket {
c.readTimeout = timeout
return c
} | go | {
"resource": ""
} |
q8434 | WithWriteTimeout | train | func (c *Websocket) WithWriteTimeout(timeout time.Duration) *Websocket {
c.writeTimeout = timeout
return c
} | go | {
"resource": ""
} |
q8435 | Subprotocol | train | func (c *Websocket) Subprotocol() *String {
s := &String{chain: c.chain}
if c.conn != nil {
s.value = c.conn.Subprotocol()
}
return s
} | go | {
"resource": ""
} |
q8436 | Response | train | func (p DebugPrinter) Response(resp *http.Response, duration time.Duration) {
if resp == nil {
return
}
dump, err := httputil.DumpResponse(resp, p.body)
if err != nil {
panic(err)
}
text := strings.Replace(string(dump), "\r\n", "\n", -1)
lines := strings.SplitN(text, "\n", 2)
p.logger.Logf("%s %s\n%s", lines[0], duration, lines[1])
} | go | {
"resource": ""
} |
q8437 | WebsocketRead | train | func (p DebugPrinter) WebsocketRead(typ int, content []byte, closeCode int) {
b := &bytes.Buffer{}
fmt.Fprintf(b, "<- Received: %s", wsMessageTypeName(typ))
if typ == websocket.CloseMessage {
fmt.Fprintf(b, " (%d)", closeCode)
}
fmt.Fprint(b, "\n")
if len(content) > 0 {
if typ == websocket.BinaryMessage {
fmt.Fprintf(b, "%v\n", content)
} else {
fmt.Fprintf(b, "%s\n", content)
}
}
fmt.Fprintf(b, "\n")
p.logger.Logf(b.String())
} | go | {
"resource": ""
} |
q8438 | NotSet | train | func (d *Duration) NotSet() *Duration {
if d.value != nil {
d.chain.fail("expected duration is not set, but it is")
}
return d
} | go | {
"resource": ""
} |
q8439 | WsHttpHandler | train | func WsHttpHandler(w http.ResponseWriter, r *http.Request) {
upgrader := &websocket.Upgrader{}
c, err := upgrader.Upgrade(w, r, nil)
if err != nil {
panic(err)
}
defer c.Close()
for {
mt, message, err := c.ReadMessage()
if err != nil {
break
}
err = c.WriteMessage(mt, message)
if err != nil {
break
}
}
} | go | {
"resource": ""
} |
q8440 | WsFastHandler | train | func WsFastHandler(ctx *fasthttp.RequestCtx) {
upgrader := fastwebsocket.New(func(c *fastwebsocket.Conn) {
defer c.Close()
for {
mt, message, err := c.ReadMessage()
if err != nil {
break
}
err = c.WriteMessage(mt, message)
if err != nil {
break
}
}
})
err := upgrader.Upgrade(ctx)
if err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q8441 | Open | train | func Open(file string) (*Reader, error) {
reader, err := maxminddb.Open(file)
if err != nil {
return nil, err
}
dbType, err := getDBType(reader)
return &Reader{reader, dbType}, err
} | go | {
"resource": ""
} |
q8442 | DesignUnitsToPdf | train | func DesignUnitsToPdf(val int, unitsPerEm uint) int {
return core.Round(float64(float64(val) * 1000.00 / float64(unitsPerEm)))
} | go | {
"resource": ""
} |
q8443 | SetImagePath | train | func (i *ImageObj) SetImagePath(path string) error {
file, err := os.Open(path)
if err != nil {
return err
}
defer file.Close()
err = i.SetImage(file)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8444 | SetImage | train | func (i *ImageObj) SetImage(r io.Reader) error {
data, err := ioutil.ReadAll(r)
if err != nil {
return err
}
i.rawImgReader = bytes.NewReader(data)
return nil
} | go | {
"resource": ""
} |
q8445 | KernValueByLeft | train | func (s *SubsetFontObj) KernValueByLeft(left uint) (bool, *core.KernValue) {
if !s.ttfFontOption.UseKerning {
return false, nil
}
k := s.ttfp.Kern()
if k == nil {
return false, nil
}
if kval, ok := k.Kerning[left]; ok {
return true, &kval
}
return false, nil
} | go | {
"resource": ""
} |
q8446 | SetTTFByPath | train | func (s *SubsetFontObj) SetTTFByPath(ttfpath string) error {
useKerning := s.ttfFontOption.UseKerning
s.ttfp.SetUseKerning(useKerning)
err := s.ttfp.Parse(ttfpath)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8447 | SetTTFByReader | train | func (s *SubsetFontObj) SetTTFByReader(rd io.Reader) error {
useKerning := s.ttfFontOption.UseKerning
s.ttfp.SetUseKerning(useKerning)
err := s.ttfp.ParseByReader(rd)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8448 | AddChars | train | func (s *SubsetFontObj) AddChars(txt string) error {
for _, runeValue := range txt {
if s.CharacterToGlyphIndex.KeyExists(runeValue) {
continue
}
glyphIndex, err := s.CharCodeToGlyphIndex(runeValue)
if err != nil {
return err
}
s.CharacterToGlyphIndex.Set(runeValue, glyphIndex) // [runeValue] = glyphIndex
}
return nil
} | go | {
"resource": ""
} |
q8449 | CharIndex | train | func (s *SubsetFontObj) CharIndex(r rune) (uint, error) {
/*
if index, ok := s.CharacterToGlyphIndex[r]; ok {
return index, nil
}
return 0, ErrCharNotFound
*/
glyIndex, ok := s.CharacterToGlyphIndex.Val(r)
if ok {
return glyIndex, nil
}
return 0, ErrCharNotFound
} | go | {
"resource": ""
} |
q8450 | CharCodeToGlyphIndex | train | func (s *SubsetFontObj) CharCodeToGlyphIndex(r rune) (uint, error) {
value := uint64(r)
if value <= 0xFFFF {
gIndex, err := s.charCodeToGlyphIndexFormat4(r)
if err != nil {
return 0, err
}
return gIndex, nil
} else {
gIndex, err := s.charCodeToGlyphIndexFormat12(r)
if err != nil {
return 0, err
}
return gIndex, nil
}
} | go | {
"resource": ""
} |
q8451 | GlyphIndexToPdfWidth | train | func (s *SubsetFontObj) GlyphIndexToPdfWidth(glyphIndex uint) uint {
numberOfHMetrics := s.ttfp.NumberOfHMetrics()
unitsPerEm := s.ttfp.UnitsPerEm()
if glyphIndex >= numberOfHMetrics {
glyphIndex = numberOfHMetrics - 1
}
width := s.ttfp.Widths()[glyphIndex]
if unitsPerEm == 1000 {
return width
}
return width * 1000 / unitsPerEm
} | go | {
"resource": ""
} |
q8452 | AddCompositeGlyphs | train | func (p *PdfDictionaryObj) AddCompositeGlyphs(glyphArray *[]int, glyph int) {
start := p.GetOffset(int(glyph))
if start == p.GetOffset(int(glyph)+1) {
return
}
offset := start
ttfp := p.PtrToSubsetFontObj.GetTTFParser()
fontData := ttfp.FontData()
numContours, step := ReadShortFromByte(fontData, offset)
offset += step
if numContours >= 0 {
return
}
offset += 8
for {
flags, step1 := ReadUShortFromByte(fontData, offset)
offset += step1
cGlyph, step2 := ReadUShortFromByte(fontData, offset)
offset += step2
//check cGlyph is contain in glyphArray?
glyphContainsKey := false
for _, g := range *glyphArray {
if g == int(cGlyph) {
glyphContainsKey = true
break
}
}
if !glyphContainsKey {
*glyphArray = append(*glyphArray, int(cGlyph))
}
if (flags & MORE_COMPONENTS) == 0 {
return
}
offsetAppend := 4
if (flags & ARG_1_AND_2_ARE_WORDS) == 0 {
offsetAppend = 2
}
if (flags & WE_HAVE_A_SCALE) != 0 {
offsetAppend += 2
} else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) != 0 {
offsetAppend += 4
}
if (flags & WE_HAVE_A_TWO_BY_TWO) != 0 {
offsetAppend += 8
}
offset += offsetAppend
}
} | go | {
"resource": ""
} |
q8453 | GetOffset | train | func (p *PdfDictionaryObj) GetOffset(glyph int) int {
ttfp := p.PtrToSubsetFontObj.GetTTFParser()
glyf := ttfp.GetTables()["glyf"]
offset := int(glyf.Offset + ttfp.LocaTable[glyph])
return offset
} | go | {
"resource": ""
} |
q8454 | CheckSum | train | func CheckSum(data []byte) uint {
var byte3, byte2, byte1, byte0 uint64
byte3 = 0
byte2 = 0
byte1 = 0
byte0 = 0
length := len(data)
i := 0
for i < length {
byte3 += uint64(data[i])
i++
byte2 += uint64(data[i])
i++
byte1 += uint64(data[i])
i++
byte0 += uint64(data[i])
i++
}
//var result uint32
result := uint32(byte3<<24) + uint32(byte2<<16) + uint32(byte1<<8) + uint32(byte0)
return uint(result)
} | go | {
"resource": ""
} |
q8455 | SetMargins | train | func (gp *GoPdf) SetMargins(left, top, right, bottom float64) {
gp.UnitsToPointsVar(&left, &top, &right, &bottom)
gp.margins = Margins{left, top, right, bottom}
} | go | {
"resource": ""
} |
q8456 | SetMarginLeft | train | func (gp *GoPdf) SetMarginLeft(margin float64) {
gp.margins.Left = gp.UnitsToPoints(margin)
} | go | {
"resource": ""
} |
q8457 | SetMarginTop | train | func (gp *GoPdf) SetMarginTop(margin float64) {
gp.margins.Top = gp.UnitsToPoints(margin)
} | go | {
"resource": ""
} |
q8458 | SetMarginRight | train | func (gp *GoPdf) SetMarginRight(margin float64) {
gp.margins.Right = gp.UnitsToPoints(margin)
} | go | {
"resource": ""
} |
q8459 | SetMarginBottom | train | func (gp *GoPdf) SetMarginBottom(margin float64) {
gp.margins.Bottom = gp.UnitsToPoints(margin)
} | go | {
"resource": ""
} |
q8460 | Margins | train | func (gp *GoPdf) Margins() (float64, float64, float64, float64) {
return gp.PointsToUnits(gp.margins.Left),
gp.PointsToUnits(gp.margins.Top),
gp.PointsToUnits(gp.margins.Right),
gp.PointsToUnits(gp.margins.Bottom)
} | go | {
"resource": ""
} |
q8461 | ValueByRight | train | func (k KernValue) ValueByRight(right uint) (bool, int16) {
if val, ok := k[uint(right)]; ok {
return true, val
}
return false, 0
} | go | {
"resource": ""
} |
q8462 | WriteUInt32 | train | func WriteUInt32(w io.Writer, v uint) error {
a := byte(v >> 24)
b := byte(v >> 16)
c := byte(v >> 8)
d := byte(v)
_, err := w.Write([]byte{a, b, c, d})
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8463 | WriteUInt16 | train | func WriteUInt16(w io.Writer, v uint) error {
a := byte(v >> 8)
b := byte(v)
_, err := w.Write([]byte{a, b})
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8464 | WriteTag | train | func WriteTag(w io.Writer, tag string) error {
b := []byte(tag)
_, err := w.Write(b)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8465 | NewMapOfCharacterToGlyphIndex | train | func NewMapOfCharacterToGlyphIndex() *MapOfCharacterToGlyphIndex {
var m MapOfCharacterToGlyphIndex
m.keyIndexs = make(map[rune]int)
return &m
} | go | {
"resource": ""
} |
q8466 | KeyExists | train | func (m *MapOfCharacterToGlyphIndex) KeyExists(k rune) bool {
/*for _, key := range m.Keys {
if k == key {
return true
}
}*/
if _, ok := m.keyIndexs[k]; ok {
return true
}
return false
} | go | {
"resource": ""
} |
q8467 | Set | train | func (m *MapOfCharacterToGlyphIndex) Set(k rune, v uint) {
m.keyIndexs[k] = len(m.Keys)
m.Keys = append(m.Keys, k)
m.Vals = append(m.Vals, v)
} | go | {
"resource": ""
} |
q8468 | Index | train | func (m *MapOfCharacterToGlyphIndex) Index(k rune) (int, bool) {
/*for i, key := range m.Keys {
if k == key {
return i, true
}
}*/
if index, ok := m.keyIndexs[k]; ok {
return index, true
}
return -1, false
} | go | {
"resource": ""
} |
q8469 | Val | train | func (m *MapOfCharacterToGlyphIndex) Val(k rune) (uint, bool) {
i, ok := m.Index(k)
if !ok {
return 0, false
}
return m.Vals[i], true
} | go | {
"resource": ""
} |
q8470 | AppendStreamText | train | func (c *ContentObj) AppendStreamText(text string) error {
//support only CURRENT_FONT_TYPE_SUBSET
textColor := c.getRoot().curr.textColor()
grayFill := c.getRoot().curr.grayFill
fontCountIndex := c.getRoot().curr.Font_FontCount + 1
fontSize := c.getRoot().curr.Font_Size
fontStyle := c.getRoot().curr.Font_Style
x := c.getRoot().curr.X
y := c.getRoot().curr.Y
setXCount := c.getRoot().curr.setXCount
fontSubset := c.getRoot().curr.Font_ISubset
cache := cacheContentText{
fontSubset: fontSubset,
rectangle: nil,
textColor: textColor,
grayFill: grayFill,
fontCountIndex: fontCountIndex,
fontSize: fontSize,
fontStyle: fontStyle,
setXCount: setXCount,
x: x,
y: y,
pageheight: c.getRoot().curr.pageSize.H,
contentType: ContentTypeText,
lineWidth: c.getRoot().curr.lineWidth,
}
var err error
c.getRoot().curr.X, c.getRoot().curr.Y, err = c.listCache.appendContentText(cache, text)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8471 | AppendStreamLine | train | func (c *ContentObj) AppendStreamLine(x1 float64, y1 float64, x2 float64, y2 float64) {
//h := c.getRoot().config.PageSize.H
//c.stream.WriteString(fmt.Sprintf("%0.2f %0.2f m %0.2f %0.2f l s\n", x1, h-y1, x2, h-y2))
var cache cacheContentLine
cache.pageHeight = c.getRoot().curr.pageSize.H
cache.x1 = x1
cache.y1 = y1
cache.x2 = x2
cache.y2 = y2
c.listCache.append(&cache)
} | go | {
"resource": ""
} |
q8472 | AppendStreamOval | train | func (c *ContentObj) AppendStreamOval(x1 float64, y1 float64, x2 float64, y2 float64) {
var cache cacheContentOval
cache.pageHeight = c.getRoot().curr.pageSize.H
cache.x1 = x1
cache.y1 = y1
cache.x2 = x2
cache.y2 = y2
c.listCache.append(&cache)
} | go | {
"resource": ""
} |
q8473 | AppendStreamSetGrayFill | train | func (c *ContentObj) AppendStreamSetGrayFill(w float64) {
w = fixRange10(w)
var cache cacheContentGray
cache.grayType = grayTypeFill
cache.scale = w
c.listCache.append(&cache)
} | go | {
"resource": ""
} |
q8474 | AppendStreamSetGrayStroke | train | func (c *ContentObj) AppendStreamSetGrayStroke(w float64) {
w = fixRange10(w)
var cache cacheContentGray
cache.grayType = grayTypeStroke
cache.scale = w
c.listCache.append(&cache)
} | go | {
"resource": ""
} |
q8475 | AppendStreamSetColorStroke | train | func (c *ContentObj) AppendStreamSetColorStroke(r uint8, g uint8, b uint8) {
var cache cacheContentColor
cache.colorType = colorTypeStroke
cache.r = r
cache.g = g
cache.b = b
c.listCache.append(&cache)
} | go | {
"resource": ""
} |
q8476 | AppendStreamSetColorFill | train | func (c *ContentObj) AppendStreamSetColorFill(r uint8, g uint8, b uint8) {
var cache cacheContentColor
cache.colorType = colorTypeFill
cache.r = r
cache.g = g
cache.b = b
c.listCache.append(&cache)
} | go | {
"resource": ""
} |
q8477 | AppendStreamImage | train | func (c *ContentObj) AppendStreamImage(index int, x float64, y float64, rect *Rect) {
//fmt.Printf("index = %d",index)
h := c.getRoot().curr.pageSize.H
var cache cacheContentImage
cache.h = h
cache.x = x
cache.y = y
cache.rect = *rect
cache.index = index
c.listCache.append(&cache)
//c.stream.WriteString(fmt.Sprintf("q %0.2f 0 0 %0.2f %0.2f %0.2f cm /I%d Do Q\n", rect.W, rect.H, x, h-(y+rect.H), index+1))
} | go | {
"resource": ""
} |
q8478 | UnitsToPoints | train | func UnitsToPoints(t int, u float64) float64 {
switch t {
case Unit_PT:
return u * conversion_Unit_PT
case Unit_MM:
return u * conversion_Unit_MM
case Unit_CM:
return u * conversion_Unit_CM
case Unit_IN:
return u * conversion_Unit_IN
default:
return u
}
} | go | {
"resource": ""
} |
q8479 | UnitsToPointsVar | train | func UnitsToPointsVar(t int, u ...*float64) {
for x := 0; x < len(u); x++ {
*u[x] = UnitsToPoints(t, *u[x])
}
} | go | {
"resource": ""
} |
q8480 | PointsToUnitsVar | train | func PointsToUnitsVar(t int, u ...*float64) {
for x := 0; x < len(u); x++ {
*u[x] = PointsToUnits(t, *u[x])
}
} | go | {
"resource": ""
} |
q8481 | IsContainsFamilyAndStyle | train | func (re *RelateFonts) IsContainsFamilyAndStyle(family string, style int) bool {
i := 0
max := len(*re)
for i < max {
if (*re)[i].Family == family && (*re)[i].Style == style {
return true
}
i++
}
return false
} | go | {
"resource": ""
} |
q8482 | SetProtection | train | func (p *PDFProtection) SetProtection(permissions int, userPass []byte, ownerPass []byte) error {
return p.setProtection(permissions, userPass, ownerPass)
} | go | {
"resource": ""
} |
q8483 | StrHelperGetStringWidth | train | func StrHelperGetStringWidth(str string, fontSize int, ifont IFont) float64 {
w := 0
bs := []byte(str)
i := 0
max := len(bs)
for i < max {
w += ifont.GetCw()[bs[i]]
i++
}
return float64(w) * (float64(fontSize) / 1000.0)
} | go | {
"resource": ""
} |
q8484 | ReadShortFromByte | train | func ReadShortFromByte(data []byte, offset int) (int64, int) {
buff := data[offset : offset+2]
num := big.NewInt(0)
num.SetBytes(buff)
u := num.Uint64()
var v int64
if u >= 0x8000 {
v = int64(u) - 65536
} else {
v = int64(u)
}
return v, 2
} | go | {
"resource": ""
} |
q8485 | ReadUShortFromByte | train | func ReadUShortFromByte(data []byte, offset int) (uint64, int) {
buff := data[offset : offset+2]
num := big.NewInt(0)
num.SetBytes(buff)
return num.Uint64(), 2
} | go | {
"resource": ""
} |
q8486 | Setup | train | func (c *CacheContent) Setup(rectangle *Rect,
textColor Rgb,
grayFill float64,
fontCountIndex int, //Curr.Font_FontCount+1
fontSize int,
fontStyle int,
setXCount int, //จำนวนครั้งที่ใช้ setX
x, y float64,
fontSubset *SubsetFontObj,
pageheight float64,
contentType int,
cellOpt CellOption,
lineWidth float64,
) {
c.cacheContentText = cacheContentText{
fontSubset: fontSubset,
rectangle: rectangle,
textColor: textColor,
grayFill: grayFill,
fontCountIndex: fontCountIndex,
fontSize: fontSize,
fontStyle: fontStyle,
setXCount: setXCount,
x: x,
y: y,
pageheight: pageheight,
contentType: ContentTypeCell,
cellOpt: cellOpt,
lineWidth: lineWidth,
}
} | go | {
"resource": ""
} |
q8487 | ParseByReader | train | func (t *TTFParser) ParseByReader(rd io.Reader) error {
return t.parse(rd)
} | go | {
"resource": ""
} |
q8488 | Seek | train | func (t *TTFParser) Seek(fd *bytes.Reader, tag string) error {
table, ok := t.tables[tag]
if !ok {
return ErrTableNotFound
}
val := table.Offset
_, err := fd.Seek(int64(val), 0)
if err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q8489 | ReadUShort | train | func (t *TTFParser) ReadUShort(fd *bytes.Reader) (uint, error) {
buff, err := t.Read(fd, 2)
if err != nil {
return 0, err
}
n := binary.BigEndian.Uint16(buff)
return uint(n), nil
} | go | {
"resource": ""
} |
q8490 | ReadShort | train | func (t *TTFParser) ReadShort(fd *bytes.Reader) (int, error) {
u, err := t.ReadUShort(fd)
if err != nil {
return 0, err
}
//fmt.Printf("%#v\n", buff)
var v int
if u >= 0x8000 {
v = int(u) - 65536
} else {
v = int(u)
}
return v, nil
} | go | {
"resource": ""
} |
q8491 | ReadShortInt16 | train | func (t *TTFParser) ReadShortInt16(fd *bytes.Reader) (int16, error) {
n, err := t.ReadShort(fd)
if err != nil {
return 0, err
}
return int16(n), nil
} | go | {
"resource": ""
} |
q8492 | ReadULong | train | func (t *TTFParser) ReadULong(fd *bytes.Reader) (uint, error) {
buff, err := t.Read(fd, 4)
//fmt.Printf("%#v\n", buff)
if err != nil {
return 0, err
}
n := binary.BigEndian.Uint32(buff)
return uint(n), nil
} | go | {
"resource": ""
} |
q8493 | SetGrayFill | train | func (gp *GoPdf) SetGrayFill(grayScale float64) {
gp.curr.grayFill = grayScale
gp.getContent().AppendStreamSetGrayFill(grayScale)
} | go | {
"resource": ""
} |
q8494 | SetGrayStroke | train | func (gp *GoPdf) SetGrayStroke(grayScale float64) {
gp.curr.grayStroke = grayScale
gp.getContent().AppendStreamSetGrayStroke(grayScale)
} | go | {
"resource": ""
} |
q8495 | AddTTFFontByReader | train | func (gp *GoPdf) AddTTFFontByReader(family string, rd io.Reader) error {
return gp.AddTTFFontByReaderWithOption(family, rd, defaultTtfFontOption())
} | go | {
"resource": ""
} |
q8496 | AddTTFFontByReaderWithOption | train | func (gp *GoPdf) AddTTFFontByReaderWithOption(family string, rd io.Reader, option TtfOption) error {
subsetFont := new(SubsetFontObj)
subsetFont.init(func() *GoPdf {
return gp
})
subsetFont.SetTtfFontOption(option)
subsetFont.SetFamily(family)
err := subsetFont.SetTTFByReader(rd)
if err != nil {
return err
}
unicodemap := new(UnicodeMap)
unicodemap.init(func() *GoPdf {
return gp
})
unicodemap.setProtection(gp.protection())
unicodemap.SetPtrToSubsetFontObj(subsetFont)
unicodeindex := gp.addObj(unicodemap)
pdfdic := new(PdfDictionaryObj)
pdfdic.init(func() *GoPdf {
return gp
})
pdfdic.setProtection(gp.protection())
pdfdic.SetPtrToSubsetFontObj(subsetFont)
pdfdicindex := gp.addObj(pdfdic)
subfontdesc := new(SubfontDescriptorObj)
subfontdesc.init(func() *GoPdf {
return gp
})
subfontdesc.SetPtrToSubsetFontObj(subsetFont)
subfontdesc.SetIndexObjPdfDictionary(pdfdicindex)
subfontdescindex := gp.addObj(subfontdesc)
cidfont := new(CIDFontObj)
cidfont.init(func() *GoPdf {
return gp
})
cidfont.SetPtrToSubsetFontObj(subsetFont)
cidfont.SetIndexObjSubfontDescriptor(subfontdescindex)
cidindex := gp.addObj(cidfont)
subsetFont.SetIndexObjCIDFont(cidindex)
subsetFont.SetIndexObjUnicodeMap(unicodeindex)
index := gp.addObj(subsetFont) //add หลังสุด
if gp.indexOfProcSet != -1 {
procset := gp.pdfObjs[gp.indexOfProcSet].(*ProcSetObj)
if !procset.Realtes.IsContainsFamilyAndStyle(family, option.Style&^Underline) {
procset.Realtes = append(procset.Realtes, RelateFont{Family: family, IndexOfObj: index, CountOfFont: gp.curr.CountOfFont, Style: option.Style &^ Underline})
subsetFont.CountOfFont = gp.curr.CountOfFont
gp.curr.CountOfFont++
}
}
return nil
} | go | {
"resource": ""
} |
q8497 | KernOverride | train | func (gp *GoPdf) KernOverride(family string, fn FuncKernOverride) error {
i := 0
max := len(gp.pdfObjs)
for i < max {
if gp.pdfObjs[i].getType() == subsetFont {
obj := gp.pdfObjs[i]
sub, ok := obj.(*SubsetFontObj)
if ok {
if sub.GetFamily() == family {
sub.funcKernOverride = fn
return nil
}
}
}
i++
}
return errors.New("font family not found")
} | go | {
"resource": ""
} |
q8498 | SetStrokeColor | train | func (gp *GoPdf) SetStrokeColor(r uint8, g uint8, b uint8) {
gp.getContent().AppendStreamSetColorStroke(r, g, b)
} | go | {
"resource": ""
} |
q8499 | SetFillColor | train | func (gp *GoPdf) SetFillColor(r uint8, g uint8, b uint8) {
gp.getContent().AppendStreamSetColorFill(r, g, b)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.