id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1 value |
|---|---|---|
c179500 | use this as y-h might be negative
margin := gc.pdf.GetCellMargin()
gc.pdf.MoveTo(x-left-margin, y+top)
gc.pdf.CellFormat(w, h, text, "", 0, "BL", false, 0, "")
return w
} | |
c179501 | x, y float64) (cursor float64) {
return gc.CreateStringPath(text, x, y)
} | |
c179502 | gc.StackGraphicContext.SetStrokeColor(c)
gc.pdf.SetDrawColor(rgb(c))
} | |
c179503 |
gc.pdf.SetFillColor(rgb(c))
gc.pdf.SetTextColor(rgb(c))
} | |
c179504 | {
gc.StackGraphicContext.SetLineDash(Dash, DashOffset)
gc.pdf.SetDashPattern(Dash, DashOffset)
} | |
c179505 | gc.StackGraphicContext.SetLineWidth(LineWidth)
gc.pdf.SetLineWidth(LineWidth)
} | |
c179506 | the output filename
return samples.Output("helloworld", ext), nil
} | |
c179507 |
// Set the fill text color to black
gc.SetFillColor(image.Black)
gc.SetFontSize(14)
// Display Hello World
gc.FillStringAt("Hello World", 8, 52)
} | |
c179508 | buffer
err = png.Encode(b, m)
if err != nil {
return err
}
err = b.Flush()
if err != nil {
return err
}
return nil
} | |
c179509 | b := bufio.NewReader(f)
img, err := png.Decode(b)
if err != nil {
return nil, err
}
return img, nil
} | |
c179510 | "pdf" || ext == "svg" {
root = "../"
}
return fmt.Sprintf("%sresource/%s/%s", root, folder, filename)
} | |
c179511 | "../"
}
return fmt.Sprintf("%soutput/samples/%s.%s", root, name, ext)
} | |
c179512 |
// Tiger postscript drawing
tiger := samples.Resource("image", "tiger.ps", ext)
// Draw tiger
Draw(gc, tiger)
gc.Restore()
// Return the output filename
return samples.Output("postscript", ext), nil
} | |
c179513 | }
defer src.Close()
bytes, err := ioutil.ReadAll(src)
reader := strings.NewReader(string(bytes))
// Initialize and interpret the postscript
interpreter := ps.NewInterpreter(gc)
interpreter.Execute(reader)
} | |
c179514 | Return the output filename
return samples.Output("geometry", ext), nil
} | |
c179515 | gc.QuadCurveTo(x+sx*35, y+sy*95, x+sx*40, y+sy*75)
gc.QuadCurveTo(x+sx*100, y+sy*75, x+sx*100, y+sy*37.5)
gc.QuadCurveTo(x+sx*100, y, x+sx*50, y)
gc.Stroke()
} | |
c179516 | gc.SetLineCap(draw2d.ButtCap)
gc.SetLineJoin(draw2d.RoundJoin)
gc.SetLineWidth(height / 50)
gc.MoveTo(x+sx*60.0, y)
gc.LineTo(x+sx*60.0, y)
gc.LineTo(x+sx*162, y+sy*205)
rLineTo(gc, sx*-102.4, 0)
gc.CubicCurveTo(x+sx*-17, y+sy*205, x+sx*-17, y+sy*103, x+sx*60.0, y+sy*103.0)
gc.Stroke()
gc.SetLineDash(nil, 0.0)
} | |
c179517 | y3)
gc.Stroke()
gc.SetStrokeColor(color.NRGBA{0xFF, 0x33, 0x33, 0x88})
gc.SetLineWidth(width / 20)
// draw segment of curve
gc.MoveTo(x0, y0)
gc.LineTo(x1, y1)
gc.LineTo(x2, y2)
gc.LineTo(x3, y3)
gc.Stroke()
} | |
c179518 |
rLineTo(gc, sx*-51.2, sy*-51.2)
gc.Close()
gc.SetLineWidth(width / 20.0)
gc.SetFillColor(color.NRGBA{0, 0, 0xFF, 0xFF})
gc.SetStrokeColor(image.Black)
gc.FillStroke()
} | |
c179519 | x, y+sy*140, x+sx*232, y+sy*198)
wheel1.Clear()
wheel1.ArcTo(x+sx*52, y+sy*198, sx*40, sy*40, 0, 2*math.Pi)
wheel2.Clear()
wheel2.ArcTo(x+sx*180, y+sy*198, sx*40, sy*40, 0, -2*math.Pi)
gc.SetFillRule(draw2d.FillRuleWinding)
gc.SetFillColor(color.NRGBA{0, 0, 0xE5, 0xFF})
gc.FillStroke(&wheel1, &wheel2)
} | |
c179520 | gc.ArcTo(0, 0, width/8, height/8, 0, math.Pi*2)
gc.Close()
gc.Stroke()
gc.Restore()
} | |
c179521 | // Keep rotations temporary
gc.Rotate(i * (math.Pi / 180.0)) // Rotate by degrees on stack from 'for'
gc.MoveTo(0, 0)
gc.LineTo(width/2, 0)
gc.Stroke()
gc.Restore()
}
gc.Restore()
} | |
c179522 | ArcNegative(gc, x, y, w, h)
x += dx
CubicCurve(gc, x, y, w, h)
x += dx
FillString(gc, x, y, w, h)
x += dx
FillStroke(gc, x, y, w, h)
x = x0
y += dy
FillStyle(gc, x, y, w, h)
x += dx
PathTransform(gc, x, y, w, h)
x += dx
Star(gc, x, y, w, h)
x += dx
gopher2.Draw(gc, x, y, w, h/2)
} | |
c179523 | path.Points[i+1], path.Points[i+2], path.Points[i+3],
0, // degRotate
path.Points[i+4]*deg, // degStart = startAngle
(path.Points[i+4]-path.Points[i+5])*deg) // degEnd = startAngle-angle
i += 6
case draw2d.CloseCmp:
pdf.LineTo(startX, startY)
pdf.ClosePath()
}
}
} | |
c179524 | joins := []draw2d.LineJoin{draw2d.BevelJoin, draw2d.MiterJoin, draw2d.RoundJoin}
for i := range caps {
Draw(gc, caps[i], joins[i], x, 50, x, 160, offset)
x += offset
}
// Return the output filename
return samples.Output("linecapjoin", ext), nil
} | |
c179525 | Draw thin helping line
gc.SetStrokeColor(color.NRGBA{0xFF, 0x33, 0x33, 0xFF})
gc.SetLineWidth(2.56)
gc.MoveTo(x0, y0)
gc.LineTo((x0+x1)/2+offset, (y0+y1)/2)
gc.LineTo(x1, y1)
gc.Stroke()
} | |
c179526 | midY := (q0Y + qY) / 2
path.QuadCurveTo(q0X+dx, q0Y+dy, midX+dx, midY+dy)
}
}
q0X, q0Y, on0 = qX, qY, on
}
// Close the curve.
if on0 {
path.LineTo(startX+dx, startY+dy)
} else {
path.QuadCurveTo(q0X+dx, q0Y+dy, startX+dx, startY+dy)
}
} | |
c179527 | flattener.LineTo(x, y)
i += 4
case draw2d.CubicCurveToCmp:
TraceCubic(flattener, path.Points[i-2:], 0.5)
x, y = path.Points[i+4], path.Points[i+5]
flattener.LineTo(x, y)
i += 6
case draw2d.ArcToCmp:
x, y = TraceArc(flattener, path.Points[i], path.Points[i+1], path.Points[i+2], path.Points[i+3], path.Points[i+4], path.Points[i+5], scale)
flattener.LineTo(x, y)
i += 6
case draw2d.CloseCmp:
flattener.LineTo(startX, startY)
flattener.Close()
}
}
flattener.End()
} | |
c179528 | gc.img.Bounds().Dx(), gc.img.Bounds().Dy()
gc.ClearRect(0, 0, width, height)
} | |
c179529 | image.Rect(x1, y1, x2, y2), imageColor, image.ZP, draw.Over)
} | |
c179530 | transformer = draw.CatmullRom
}
transformer.Transform(dest, f64.Aff3{tr[0], tr[1], tr[4], tr[2], tr[3], tr[5]}, src, src.Bounds(), op, nil)
} | |
c179531 | gopher
err := Draw(gc, gopher, 297, 210, margin, lineWidth)
// Return the output filename
return samples.Output("frameimage", ext), err
} | |
c179532 | Seems to have a transform bug here on draw image
scale := math.Min((dw-margin*2)/sw, (dh-margin*2)/sh)
gc.Save()
gc.Translate((dw-sw*scale)/2, (dh-sh*scale)/2)
gc.Scale(scale, scale)
gc.Rotate(0.2)
gc.DrawImage(source)
gc.Restore()
return nil
} | |
c179533 | y+75+90, 10, 10)
gc.FillStroke()
draw2dkit.Rectangle(gc, x+30, y+75, x+30+100, y+75+80)
gc.FillStroke()
// left arm
draw2dkit.RoundedRectangle(gc, x+5, y+80, x+5+20, y+80+70, 10, 10)
gc.FillStroke()
// right arm
draw2dkit.RoundedRectangle(gc, x+135, y+80, x+135+20, y+80+70, 10, 10)
gc.FillStroke()
// left leg
draw2dkit.RoundedRectangle(gc, x+50, y+150, x+50+20, y+150+50, 10, 10)
gc.FillStroke()
// right leg
draw2dkit.RoundedRectangle(gc, x+90, y+150, x+90+20, y+150+50, 10, 10)
gc.FillStroke()
} | |
c179534 | Checksum32S((*[maxInt32]byte)(unsafe.Pointer(ss.Data))[:len(s):len(s)], seed)
} | |
c179535 | return Checksum64S((*[maxInt32]byte)(unsafe.Pointer(ss.Data))[:len(s):len(s)], seed)
} | |
c179536 | {
xx = &XXHash32{
seed: seed,
}
xx.Reset()
return
} | |
c179537 | {
xx = &XXHash64{
seed: seed,
}
xx.Reset()
return
} | |
c179538 | h = rotl64_31(h)
h *= prime64x1
return h
} | |
c179539 | <= len(in)-4; i += 4 {
in := in[i : i+4 : len(in)]
h += u32(in[0:4:len(in)]) * prime32x3
h = rotl32_17(h) * prime32x4
}
for ; i < len(in); i++ {
h += uint32(in[i]) * prime32x5
h = rotl32_11(h) * prime32x1
}
h ^= h >> 15
h *= prime32x2
h ^= h >> 13
h *= prime32x3
h ^= h >> 16
return
} | |
c179540 | return 0xef46db3751d8e999
}
if len(in) > 31 {
return checksum64(in, seed)
}
return checksum64Short(in, seed)
} | |
c179541 | := fmt.Sprintf("%d/%09d/", stage+1, time.Now().Nanosecond())
hash := sha1.New()
hash.Write([]byte(base))
tag := base + hex.EncodeToString(hash.Sum([]byte{}))
if err := os.Setenv(stageVar, tag+":"+origValue); err != nil {
return fmt.Errorf("can't set %s: %s", stageVar, err)
}
return nil
}
resetEnv = func() error {
return os.Setenv(stageVar, origValue)
}
return stage, advanceStage, resetEnv
} | |
c179542 | os.Stdout,
color: Green,
isColor: true,
mode: STD,
},
DEBG: {
std: os.Stdout,
color: Purple,
isColor: true,
mode: STD,
},
OK: {
std: os.Stdout,
color: Cyan,
isColor: true,
mode: STD,
},
WARN: {
std: os.Stdout,
color: Orange,
isColor: true,
mode: STD,
},
// error out
ERR: {
std: os.Stderr,
color: Red,
isColor: true,
mode: STD,
},
FAIL: {
std: os.Stderr,
color: Red,
isColor: true,
mode: STD,
},
FATAL: {
std: os.Stderr,
color: Red,
isColor: true,
mode: STD,
},
} {
log.tag = lev.String()
log.updateMode()
g.logger.Store(lev, log)
}
return g
} | |
c179543 | glg = New()
})
return glg
} | |
c179544 | {
l := val.(*logger)
l.mode = mode
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | |
c179545 |
value.tag = pref
g.logger.Store(PRINT, value)
}
return g
} | |
c179546 | return l.(*logger).mode
}
return NONE
} | |
c179547 |
l := val.(*logger)
l.writer = nil
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | |
c179548 | interface{}) bool {
l := val.(*logger)
l.writer = writer
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | |
c179549 | l := lev.(*logger)
l.color = color
g.logger.Store(level, l)
}
return g
} | |
c179550 | l.writer = writer
l.updateMode()
g.logger.Store(level, l)
}
return g
} | |
c179551 | os.Stdout,
color: Colorless,
isColor: isColor,
mode: mode,
tag: tag,
}
l.updateMode()
g.logger.Store(lev, l)
return g
} | |
c179552 |
l := val.(*logger)
l.isColor = true
l.updateMode()
g.logger.Store(key.(LEVEL), l)
return true
})
return g
} | |
c179553 | if ok {
l := ins.(*logger)
l.isColor = true
l.updateMode()
g.logger.Store(lv, l)
}
return g
} | |
c179554 |
l.isColor = false
l.updateMode()
g.logger.Store(lv, l)
}
return g
} | |
c179555 | str[strings.Index(str, sep)+sepl : len(str)-rcl]
} | |
c179556 |
l, ok := g.levelMap.Load(tag)
if !ok {
return 255
}
return l.(LEVEL)
} | |
c179557 | blankFormat(len(val)), val...)
} | |
c179558 | err = g.Error(err.Error())
if err != nil {
panic(err)
}
}
exit(1)
} | |
c179559 | err = g.Error(err.Error())
if err != nil {
panic(err)
}
}
exit(1)
} | |
c179560 | g.GetCurrentMode(l) != NONE
} | |
c179561 | CaptureMetricsFn(w, func(ww http.ResponseWriter) {
hnd.ServeHTTP(ww, r)
})
} | |
c179562 |
from = da.follow(from, key[pos])
}
to := from
if da.Array[from].Value < 0 {
to = da.follow(from, 0)
}
return &da.Array[to].Value
} | |
c179563 | dataEecoder := json.NewEncoder(out)
return dataEecoder.Encode(da.cedar)
}
return ErrInvalidDataType
} | |
c179564 |
if err != nil {
return err
}
defer file.Close()
out := bufio.NewWriter(file)
defer out.Flush()
da.Save(out, dataType)
return nil
} | |
c179565 | dataDecoder := json.NewDecoder(in)
return dataDecoder.Decode(da.cedar)
}
return ErrInvalidDataType
} | |
c179566 | nil {
return err
}
in := bufio.NewReader(file)
return da.Load(in, dataType)
} | |
c179567 | nil, ErrInvalidKey
}
for i := 0; i < len(key)/2; i++ {
key[i], key[len(key)-i-1] = key[len(key)-i-1], key[i]
}
return key, nil
} | |
c179568 | if da.Array[to].Check == id && da.Array[to].Value >= 0 {
return da.Array[to].Value, nil
}
return 0, ErrNoValue
} | |
c179569 |
// delete the label from the child ring first
da.popSibling(from, base, label)
// then release the current node `to` to the empty node ring
da.pushEnode(to)
break
}
// otherwise, just release the current node `to` to the empty node ring
da.pushEnode(to)
// then check its parent node
to = from
}
return nil
} | |
c179570 |
parsed := make([]int64, 3, 3)
for i, v := range dotParts[:3] {
val, err := strconv.ParseInt(v, 10, 64)
parsed[i] = val
if err != nil {
return err
}
}
v.Metadata = metadata
v.PreRelease = preRelease
v.Major = parsed[0]
v.Minor = parsed[1]
v.Patch = parsed[2]
return nil
} | |
c179571 | versionB.Slice()); cmp != 0 {
return cmp
}
return preReleaseCompare(v, versionB)
} | |
c179572 | {
return []int64{v.Major, v.Minor, v.Patch}
} | |
c179573 | = 0
v.Patch = 0
v.PreRelease = PreRelease("")
v.Metadata = ""
} | |
c179574 | 1
v.Patch = 0
v.PreRelease = PreRelease("")
v.Metadata = ""
} | |
c179575 | = PreRelease("")
v.Metadata = ""
} | |
c179576 | fmt.Errorf("%s is not a valid semver identifier", id)
}
return nil
} | |
c179577 | make(chan *Event, bufsize),
quit: make(chan bool),
Eventlog: make(EventLog, 0),
}
} | |
c179578 | connection: make(chan *Event, 64),
}
str.register <- sub
return sub
} | |
c179579 |
AutoStream: false,
AutoReplay: true,
Streams: make(map[string]*Stream),
}
} | |
c179580 | s.Streams[id].quit <- true
delete(s.Streams, id)
}
} | |
c179581 |
str := newStream(s.BufferSize, s.AutoReplay)
str.run()
s.Streams[id] = str
return str
} | |
c179582 | s.Streams[id].close()
delete(s.Streams, id)
}
} | |
c179583 | defer s.mu.Unlock()
return s.Streams[id] != nil
} | |
c179584 |
defer s.mu.Unlock()
if s.Streams[id] != nil {
s.Streams[id].event <- s.process(event)
}
} | |
c179585 | &http.Client{},
Headers: make(map[string]string),
subscribed: make(map[chan *Event]chan bool),
}
} | |
c179586 | // If we get an error, ignore it.
if msg, err := c.processEvent(event); err == nil {
if len(msg.ID) > 0 {
c.EventID = string(msg.ID)
} else {
msg.ID = []byte(c.EventID)
}
handler(msg)
}
}
}
return backoff.Retry(operation, backoff.NewExponentialBackOff())
} | |
c179587 | event
event, err := reader.ReadEvent()
if err != nil {
if err == io.EOF {
c.cleanup(resp, ch)
return nil
}
// run user specified disconnect function
if c.disconnectcb != nil {
c.disconnectcb(c)
}
return err
}
// If we get an error, ignore it.
if msg, err := c.processEvent(event); err == nil {
if len(msg.ID) > 0 {
c.EventID = string(msg.ID)
} else {
msg.ID = []byte(c.EventID)
}
select {
case <-c.subscribed[ch]:
c.cleanup(resp, ch)
return nil
case ch <- msg:
// message sent
}
}
}
}
err := backoff.Retry(operation, backoff.NewExponentialBackOff())
if err != nil && !connected {
errch <- err
}
}()
err := <-errch
close(errch)
return err
} | |
c179588 | return c.Subscribe("", handler)
} | |
c179589 |
if c.subscribed[ch] != nil {
c.subscribed[ch] <- true
}
} | |
c179590 | return i + 1, data[0:i], nil
}
if i := bytes.Index(data, []byte("\r\r")); i >= 0 {
return i + 1, data[0:i], nil
}
if i := bytes.Index(data, []byte("\n\n")); i >= 0 {
return i + 1, data[0:i], nil
}
// If we're at EOF, we have all of the data.
if atEOF {
return len(data), data, nil
}
// Request more data.
return 0, nil, nil
}
// Set the split function for the scanning operation.
scanner.Split(split)
return &EventStreamReader{
scanner: scanner,
}
} | |
c179591 |
if err := e.scanner.Err(); err != nil {
return nil, err
}
return nil, io.EOF
} | |
c179592 | // Push events to client
for {
select {
case ev, ok := <-sub.connection:
if !ok {
return
}
// If the data buffer is an empty string abort.
if len(ev.Data) == 0 {
break
}
// if the event has expired, dont send it
if s.EventTTL != 0 && time.Now().After(ev.timestamp.Add(s.EventTTL)) {
continue
}
fmt.Fprintf(w, "id: %s\n", ev.ID)
fmt.Fprintf(w, "data: %s\n", ev.Data)
if len(ev.Event) > 0 {
fmt.Fprintf(w, "event: %s\n", ev.Event)
}
if len(ev.Retry) > 0 {
fmt.Fprintf(w, "retry: %s\n", ev.Retry)
}
fmt.Fprint(w, "\n")
flusher.Flush()
}
}
} | |
c179593 |
ev.timestamp = time.Now()
(*e) = append((*e), ev)
} | |
c179594 | i++ {
if string((*e)[i].ID) >= s.eventid {
s.connection <- (*e)[i]
}
}
} | |
c179595 | x509.ParsePKCS1PrivateKey(d.Bytes)
case ecPrivateKey:
return x509.ParseECPrivateKey(d.Bytes)
default:
return nil, fmt.Errorf("%q is unsupported", d.Type)
}
} | |
c179596 |
}
b := &pem.Block{Type: ecPrivateKey, Bytes: bytes}
if err := pem.Encode(f, b); err != nil {
f.Close()
return err
}
return f.Close()
} | |
c179597 | || !gen {
return nil, err
}
ecKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
return nil, err
}
return ecKey, writeKey(filename, ecKey)
} | |
c179598 | {
return filepath.Join(filepath.Dir(existing), filename)
} | |
c179599 | agreed = "no"
} else if a.AgreedTerms == a.CurrentTerms {
agreed = "yes"
}
fmt.Fprintln(tw, "Accepted:\t", agreed)
// TODO: print authorization and certificates
tw.Flush()
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.