_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q33300 | Marshal | train | func (c protobufCodec) Marshal(v interface{}) ([]byte, error) {
message, ok := v.(proto.Message)
if !ok {
// toBytes() may need to encode non-protobuf type, if that occurs use json
return json.Codec.Marshal(v)
}
return proto.Marshal(message)
} | go | {
"resource": ""
} |
q33301 | Open | train | func Open(path string, stormOptions ...func(*Options) error) (*DB, error) {
var err error
var opts Options
for _, option := range stormOptions {
if err = option(&opts); err != nil {
return nil, err
}
}
s := DB{
Bolt: opts.bolt,
}
n := node{
s: &s,
codec: opts.codec,
batchMode: op... | go | {
"resource": ""
} |
q33302 | toBytes | train | func toBytes(key interface{}, codec codec.MarshalUnmarshaler) ([]byte, error) {
if key == nil {
return nil, nil
}
switch t := key.(type) {
case []byte:
return t, nil
case string:
return []byte(t), nil
case int:
return numbertob(int64(t))
case uint:
return numbertob(uint64(t))
case int8, int16, int32, ... | go | {
"resource": ""
} |
q33303 | BoltOptions | train | func BoltOptions(mode os.FileMode, options *bolt.Options) func(*Options) error {
return func(opts *Options) error {
opts.boltMode = mode
opts.boltOptions = options
return nil
}
} | go | {
"resource": ""
} |
q33304 | Codec | train | func Codec(c codec.MarshalUnmarshaler) func(*Options) error {
return func(opts *Options) error {
opts.codec = c
return nil
}
} | go | {
"resource": ""
} |
q33305 | Batch | train | func Batch() func(*Options) error {
return func(opts *Options) error {
opts.batchMode = true
return nil
}
} | go | {
"resource": ""
} |
q33306 | Root | train | func Root(root ...string) func(*Options) error {
return func(opts *Options) error {
opts.rootBucket = root
return nil
}
} | go | {
"resource": ""
} |
q33307 | Limit | train | func Limit(limit int) func(*index.Options) {
return func(opts *index.Options) {
opts.Limit = limit
}
} | go | {
"resource": ""
} |
q33308 | Skip | train | func Skip(offset int) func(*index.Options) {
return func(opts *index.Options) {
opts.Skip = offset
}
} | go | {
"resource": ""
} |
q33309 | Init | train | func (n *node) Init(data interface{}) error {
v := reflect.ValueOf(data)
cfg, err := extract(&v)
if err != nil {
return err
}
return n.readWriteTx(func(tx *bolt.Tx) error {
return n.init(tx, cfg)
})
} | go | {
"resource": ""
} |
q33310 | Save | train | func (n *node) Save(data interface{}) error {
ref := reflect.ValueOf(data)
if !ref.IsValid() || ref.Kind() != reflect.Ptr || ref.Elem().Kind() != reflect.Struct {
return ErrStructPtrNeeded
}
cfg, err := extract(&ref)
if err != nil {
return err
}
if cfg.ID.IsZero {
if !cfg.ID.IsInteger || !cfg.ID.Increme... | go | {
"resource": ""
} |
q33311 | Update | train | func (n *node) Update(data interface{}) error {
return n.update(data, func(ref *reflect.Value, current *reflect.Value, cfg *structConfig) error {
numfield := ref.NumField()
for i := 0; i < numfield; i++ {
f := ref.Field(i)
if ref.Type().Field(i).PkgPath != "" {
continue
}
zero := reflect.Zero(f.Typ... | go | {
"resource": ""
} |
q33312 | UpdateField | train | func (n *node) UpdateField(data interface{}, fieldName string, value interface{}) error {
return n.update(data, func(ref *reflect.Value, current *reflect.Value, cfg *structConfig) error {
f := current.FieldByName(fieldName)
if !f.IsValid() {
return ErrNotFound
}
tf, _ := current.Type().FieldByName(fieldName... | go | {
"resource": ""
} |
q33313 | Drop | train | func (n *node) Drop(data interface{}) error {
var bucketName string
v := reflect.ValueOf(data)
if v.Kind() != reflect.String {
info, err := extract(&v)
if err != nil {
return err
}
bucketName = info.Name
} else {
bucketName = v.Interface().(string)
}
return n.readWriteTx(func(tx *bolt.Tx) error {
... | go | {
"resource": ""
} |
q33314 | DeleteStruct | train | func (n *node) DeleteStruct(data interface{}) error {
ref := reflect.ValueOf(data)
if !ref.IsValid() || ref.Kind() != reflect.Ptr || ref.Elem().Kind() != reflect.Struct {
return ErrStructPtrNeeded
}
cfg, err := extract(&ref)
if err != nil {
return err
}
id, err := toBytes(cfg.ID.Value.Interface(), n.codec... | go | {
"resource": ""
} |
q33315 | SetBytes | train | func (n *node) SetBytes(bucketName string, key interface{}, value []byte) error {
if key == nil {
return ErrNilParam
}
id, err := toBytes(key, n.codec)
if err != nil {
return err
}
return n.readWriteTx(func(tx *bolt.Tx) error {
return n.setBytes(tx, bucketName, id, value)
})
} | go | {
"resource": ""
} |
q33316 | Get | train | func (n *node) Get(bucketName string, key interface{}, to interface{}) error {
ref := reflect.ValueOf(to)
if !ref.IsValid() || ref.Kind() != reflect.Ptr {
return ErrPtrNeeded
}
id, err := toBytes(key, n.codec)
if err != nil {
return err
}
return n.readTx(func(tx *bolt.Tx) error {
raw, err := n.getBytes(... | go | {
"resource": ""
} |
q33317 | Delete | train | func (n *node) Delete(bucketName string, key interface{}) error {
id, err := toBytes(key, n.codec)
if err != nil {
return err
}
return n.readWriteTx(func(tx *bolt.Tx) error {
return n.delete(tx, bucketName, id)
})
} | go | {
"resource": ""
} |
q33318 | KeyExists | train | func (n *node) KeyExists(bucketName string, key interface{}) (bool, error) {
id, err := toBytes(key, n.codec)
if err != nil {
return false, err
}
var exists bool
return exists, n.readTx(func(tx *bolt.Tx) error {
bucket := n.GetBucket(tx, bucketName)
if bucket == nil {
return ErrNotFound
}
v := bucke... | go | {
"resource": ""
} |
q33319 | save | train | func (s *FilesystemStore) save(session *Session) error {
encoded, err := securecookie.EncodeMulti(session.Name(), session.Values,
s.Codecs...)
if err != nil {
return err
}
filename := filepath.Join(s.path, "session_"+session.ID)
fileMutex.Lock()
defer fileMutex.Unlock()
return ioutil.WriteFile(filename, []by... | go | {
"resource": ""
} |
q33320 | erase | train | func (s *FilesystemStore) erase(session *Session) error {
filename := filepath.Join(s.path, "session_"+session.ID)
fileMutex.RLock()
defer fileMutex.RUnlock()
err := os.Remove(filename)
return err
} | go | {
"resource": ""
} |
q33321 | GetRegistry | train | func GetRegistry(r *http.Request) *Registry {
var ctx = r.Context()
registry := ctx.Value(registryKey)
if registry != nil {
return registry.(*Registry)
}
newRegistry := &Registry{
request: r,
sessions: make(map[string]sessionInfo),
}
*r = *r.WithContext(context.WithValue(ctx, registryKey, newRegistry))
r... | go | {
"resource": ""
} |
q33322 | Get | train | func (s *Registry) Get(store Store, name string) (session *Session, err error) {
if !isCookieNameValid(name) {
return nil, fmt.Errorf("sessions: invalid character in cookie name: %s", name)
}
if info, ok := s.sessions[name]; ok {
session, err = info.s, info.e
} else {
session, err = store.New(s.request, name)... | go | {
"resource": ""
} |
q33323 | Save | train | func (s *Registry) Save(w http.ResponseWriter) error {
var errMulti MultiError
for name, info := range s.sessions {
session := info.s
if session.store == nil {
errMulti = append(errMulti, fmt.Errorf(
"sessions: missing store for session %q", name))
} else if err := session.store.Save(s.request, w, sessio... | go | {
"resource": ""
} |
q33324 | Save | train | func Save(r *http.Request, w http.ResponseWriter) error {
return GetRegistry(r).Save(w)
} | go | {
"resource": ""
} |
q33325 | newCookieFromOptions | train | func newCookieFromOptions(name, value string, options *Options) *http.Cookie {
return &http.Cookie{
Name: name,
Value: value,
Path: options.Path,
Domain: options.Domain,
MaxAge: options.MaxAge,
Secure: options.Secure,
HttpOnly: options.HttpOnly,
SameSite: options.SameSite,
}
} | go | {
"resource": ""
} |
q33326 | SubImage | train | func (p *ycc) SubImage(r image.Rectangle) image.Image {
r = r.Intersect(p.Rect)
if r.Empty() {
return &ycc{SubsampleRatio: p.SubsampleRatio}
}
i := p.PixOffset(r.Min.X, r.Min.Y)
return &ycc{
Pix: p.Pix[i:],
Stride: p.Stride,
Rect: r,
SubsampleRatio: p.SubsampleRatio,
}
} | go | {
"resource": ""
} |
q33327 | newYCC | train | func newYCC(r image.Rectangle, s image.YCbCrSubsampleRatio) *ycc {
w, h := r.Dx(), r.Dy()
buf := make([]uint8, 3*w*h)
return &ycc{Pix: buf, Stride: 3 * w, Rect: r, SubsampleRatio: s}
} | go | {
"resource": ""
} |
q33328 | YCbCr | train | func (p *ycc) YCbCr() *image.YCbCr {
ycbcr := image.NewYCbCr(p.Rect, p.SubsampleRatio)
switch ycbcr.SubsampleRatio {
case ycbcrSubsampleRatio422:
return p.ycbcr422(ycbcr)
case ycbcrSubsampleRatio420:
return p.ycbcr420(ycbcr)
case ycbcrSubsampleRatio440:
return p.ycbcr440(ycbcr)
case ycbcrSubsampleRatio444:
... | go | {
"resource": ""
} |
q33329 | imageYCbCrToYCC | train | func imageYCbCrToYCC(in *image.YCbCr) *ycc {
w, h := in.Rect.Dx(), in.Rect.Dy()
p := ycc{
Pix: make([]uint8, 3*w*h),
Stride: 3 * w,
Rect: image.Rect(0, 0, w, h),
SubsampleRatio: in.SubsampleRatio,
}
switch in.SubsampleRatio {
case ycbcrSubsampleRatio422:
return convertToYCC42... | go | {
"resource": ""
} |
q33330 | Thumbnail | train | func Thumbnail(maxWidth, maxHeight uint, img image.Image, interp InterpolationFunction) image.Image {
origBounds := img.Bounds()
origWidth := uint(origBounds.Dx())
origHeight := uint(origBounds.Dy())
newWidth, newHeight := origWidth, origHeight
// Return original image if it have same or smaller size as constrain... | go | {
"resource": ""
} |
q33331 | kernel | train | func (i InterpolationFunction) kernel() (int, func(float64) float64) {
switch i {
case Bilinear:
return 2, linear
case Bicubic:
return 4, cubic
case MitchellNetravali:
return 4, mitchellnetravali
case Lanczos2:
return 4, lanczos2
case Lanczos3:
return 6, lanczos3
default:
// Default to NearestNeighbo... | go | {
"resource": ""
} |
q33332 | calcFactors | train | func calcFactors(width, height uint, oldWidth, oldHeight float64) (scaleX, scaleY float64) {
if width == 0 {
if height == 0 {
scaleX = 1.0
scaleY = 1.0
} else {
scaleY = oldHeight / float64(height)
scaleX = scaleY
}
} else {
scaleX = oldWidth / float64(width)
if height == 0 {
scaleY = scaleX
... | go | {
"resource": ""
} |
q33333 | Shutdown | train | func (srv *Server) Shutdown(ctx context.Context) error {
srv.mu.Lock()
lnerr := srv.closeListenersLocked()
srv.closeDoneChanLocked()
srv.mu.Unlock()
finished := make(chan struct{}, 1)
go func() {
srv.listenerWg.Wait()
srv.connWg.Wait()
finished <- struct{}{}
}()
select {
case <-ctx.Done():
return ctx... | go | {
"resource": ""
} |
q33334 | Serve | train | func (srv *Server) Serve(l net.Listener) error {
srv.ensureHandlers()
defer l.Close()
if err := srv.ensureHostSigner(); err != nil {
return err
}
if srv.Handler == nil {
srv.Handler = DefaultHandler
}
if srv.channelHandlers == nil {
srv.channelHandlers = map[string]channelHandler{
"session": sessio... | go | {
"resource": ""
} |
q33335 | Serve | train | func Serve(l net.Listener, handler Handler, options ...Option) error {
srv := &Server{Handler: handler}
for _, option := range options {
if err := srv.SetOption(option); err != nil {
return err
}
}
return srv.Serve(l)
} | go | {
"resource": ""
} |
q33336 | ListenAndServe | train | func ListenAndServe(addr string, handler Handler, options ...Option) error {
srv := &Server{Addr: addr, Handler: handler}
for _, option := range options {
if err := srv.SetOption(option); err != nil {
return err
}
}
return srv.ListenAndServe()
} | go | {
"resource": ""
} |
q33337 | KeysEqual | train | func KeysEqual(ak, bk PublicKey) bool {
//avoid panic if one of the keys is nil, return false instead
if ak == nil || bk == nil {
return false
}
a := ak.Marshal()
b := bk.Marshal()
return (len(a) == len(b) && subtle.ConstantTimeCompare(a, b) == 1)
} | go | {
"resource": ""
} |
q33338 | PasswordAuth | train | func PasswordAuth(fn PasswordHandler) Option {
return func(srv *Server) error {
srv.PasswordHandler = fn
return nil
}
} | go | {
"resource": ""
} |
q33339 | PublicKeyAuth | train | func PublicKeyAuth(fn PublicKeyHandler) Option {
return func(srv *Server) error {
srv.PublicKeyHandler = fn
return nil
}
} | go | {
"resource": ""
} |
q33340 | HostKeyFile | train | func HostKeyFile(filepath string) Option {
return func(srv *Server) error {
pemBytes, err := ioutil.ReadFile(filepath)
if err != nil {
return err
}
signer, err := gossh.ParsePrivateKey(pemBytes)
if err != nil {
return err
}
srv.AddHostKey(signer)
return nil
}
} | go | {
"resource": ""
} |
q33341 | HostKeyPEM | train | func HostKeyPEM(bytes []byte) Option {
return func(srv *Server) error {
signer, err := gossh.ParsePrivateKey(bytes)
if err != nil {
return err
}
srv.AddHostKey(signer)
return nil
}
} | go | {
"resource": ""
} |
q33342 | NoPty | train | func NoPty() Option {
return func(srv *Server) error {
srv.PtyCallback = func(ctx Context, pty Pty) bool {
return false
}
return nil
}
} | go | {
"resource": ""
} |
q33343 | WrapConn | train | func WrapConn(fn ConnCallback) Option {
return func(srv *Server) error {
srv.ConnCallback = fn
return nil
}
} | go | {
"resource": ""
} |
q33344 | applyConnMetadata | train | func applyConnMetadata(ctx Context, conn gossh.ConnMetadata) {
if ctx.Value(ContextKeySessionID) != nil {
return
}
ctx.SetValue(ContextKeySessionID, hex.EncodeToString(conn.SessionID()))
ctx.SetValue(ContextKeyClientVersion, string(conn.ClientVersion()))
ctx.SetValue(ContextKeyServerVersion, string(conn.ServerVe... | go | {
"resource": ""
} |
q33345 | NewAgentListener | train | func NewAgentListener() (net.Listener, error) {
dir, err := ioutil.TempDir("", agentTempDir)
if err != nil {
return nil, err
}
l, err := net.Listen("unix", path.Join(dir, agentListenFile))
if err != nil {
return nil, err
}
return l, nil
} | go | {
"resource": ""
} |
q33346 | ForwardAgentConnections | train | func ForwardAgentConnections(l net.Listener, s Session) {
sshConn := s.Context().Value(ContextKeyConn).(gossh.Conn)
for {
conn, err := l.Accept()
if err != nil {
return
}
go func(conn net.Conn) {
defer conn.Close()
channel, reqs, err := sshConn.OpenChannel(agentChannelType, nil)
if err != nil {
... | go | {
"resource": ""
} |
q33347 | PopupOpen | train | func (mw *masterWindowCommon) PopupOpen(title string, flags WindowFlags, rect rect.Rect, scale bool, updateFn UpdateFn) {
go func() {
mw.ctx.mw.Lock()
defer mw.ctx.mw.Unlock()
mw.ctx.popupOpen(title, flags, rect, scale, updateFn)
mw.ctx.mw.Changed()
}()
} | go | {
"resource": ""
} |
q33348 | drawChanged | train | func (w *masterWindowCommon) drawChanged() bool {
contextAllCommands(w.ctx)
w.ctx.Reset()
cmds := w.ctx.cmds
if len(cmds) != len(w.prevCmds) {
return true
}
for i := range cmds {
if cmds[i].Kind != w.prevCmds[i].Kind {
return true
}
cmd := &cmds[i]
pcmd := &w.prevCmds[i]
switch cmds[i].Kind {... | go | {
"resource": ""
} |
q33349 | NewMasterWindowSize | train | func NewMasterWindowSize(flags WindowFlags, title string, sz image.Point, updatefn UpdateFn) MasterWindow {
ctx := &context{}
wnd := &masterWindow{}
wnd.masterWindowCommonInit(ctx, flags, updatefn, wnd)
wnd.Title = title
wnd.initialSize = sz
clipboardMu.Lock()
if !clipboardStarted {
clipboardStarted = true
... | go | {
"resource": ""
} |
q33350 | Close | train | func (mw *masterWindow) Close() {
mw.wnd.Send(lifecycle.Event{From: lifecycle.StageAlive, To: lifecycle.StageDead})
} | go | {
"resource": ""
} |
q33351 | Closed | train | func (mw *masterWindow) Closed() bool {
mw.uilock.Lock()
defer mw.uilock.Unlock()
return mw.closing
} | go | {
"resource": ""
} |
q33352 | Delete | train | func (edit *TextEditor) Delete(where int, len int) {
/* delete characters while updating undo */
edit.makeundoDelete(where, len)
edit.Buffer = strDeleteText(edit.Buffer, where, len)
edit.HasPreferredX = false
} | go | {
"resource": ""
} |
q33353 | DeleteSelection | train | func (edit *TextEditor) DeleteSelection() {
/* delete the section */
edit.clamp()
if edit.hasSelection() {
if edit.SelectStart < edit.SelectEnd {
edit.Delete(edit.SelectStart, edit.SelectEnd-edit.SelectStart)
edit.Cursor = edit.SelectStart
edit.SelectEnd = edit.Cursor
} else {
edit.Delete(edit.Selec... | go | {
"resource": ""
} |
q33354 | tonl | train | func (state *TextEditor) tonl(start int, dir int) int {
sz := len(state.Buffer)
i := start
if i < 0 {
return 0
}
if i >= sz {
i = sz - 1
}
for ; (i >= 0) && (i < sz); i += dir {
c := state.Buffer[i]
if c == '\n' {
if dir >= 0 {
return i
} else {
return i + 1
}
}
}
if dir < 0 {
re... | go | {
"resource": ""
} |
q33355 | towd | train | func (state *TextEditor) towd(start int, dir int, dontForceAdvance bool) int {
first := (dir < 0)
notfirst := !first
var i int
for i = start; (i >= 0) && (i < len(state.Buffer)); i += dir {
c := state.Buffer[i]
if !(unicode.IsLetter(c) || unicode.IsDigit(c) || (c == '_')) {
if !first && !dontForceAdvance {
... | go | {
"resource": ""
} |
q33356 | tospc | train | func (state *TextEditor) tospc(start int, dir int) int {
return state.tof(start, dir, unicode.IsSpace)
} | go | {
"resource": ""
} |
q33357 | tof | train | func (state *TextEditor) tof(start int, dir int, f func(rune) bool) int {
first := (dir < 0)
notfirst := !first
var i int
for i = start; (i >= 0) && (i < len(state.Buffer)); i += dir {
c := state.Buffer[i]
if f(c) {
if !first {
i++
}
break
}
first = notfirst
}
if i < 0 {
i = 0
}
return i
... | go | {
"resource": ""
} |
q33358 | tofp | train | func (state *TextEditor) tofp(start int, dir int) int {
first := (dir < 0)
notfirst := !first
var i int
for i = start; (i >= 0) && (i < len(state.Buffer)); i += dir {
c := state.Buffer[i]
if !(unicode.IsLetter(c) || unicode.IsDigit(c) || (c == '_') || (c == '-') || (c == '+') || (c == '/') || (c == '=') || (c =... | go | {
"resource": ""
} |
q33359 | Paste | train | func (edit *TextEditor) Paste(ctext string) {
if edit.Flags&EditReadOnly != 0 {
return
}
/* if there's a selection, the paste should delete it */
edit.clamp()
edit.DeleteSelection()
text := []rune(ctext)
edit.Buffer = strInsertText(edit.Buffer, edit.Cursor, text)
edit.makeundoInsert(edit.Cursor, len(text... | go | {
"resource": ""
} |
q33360 | Edit | train | func (edit *TextEditor) Edit(win *Window) EditEvents {
edit.init(win)
if edit.Maxlen > 0 {
if len(edit.Buffer) > edit.Maxlen {
edit.Buffer = edit.Buffer[:edit.Maxlen]
}
}
if edit.Flags&EditNoCursor != 0 {
edit.Cursor = len(edit.Buffer)
}
if edit.Flags&EditSelectable == 0 {
edit.SelectStart = edit.Curs... | go | {
"resource": ""
} |
q33361 | SetColor | train | func (r *myRGBAPainter) SetColor(c color.Color) {
r.cr, r.cg, r.cb, r.ca = c.RGBA()
} | go | {
"resource": ""
} |
q33362 | MenubarBegin | train | func (win *Window) MenubarBegin() {
layout := win.layout
layout.Menu.X = layout.AtX
layout.Menu.Y = layout.Bounds.Y + layout.HeaderH
layout.Menu.W = layout.Width
layout.Menu.Offset = *layout.Offset
layout.Offset.Y = 0
} | go | {
"resource": ""
} |
q33363 | MenubarEnd | train | func (win *Window) MenubarEnd() {
layout := win.layout
layout.Menu.H = layout.AtY - layout.Menu.Y
layout.Clip.Y = layout.Bounds.Y + layout.HeaderH + layout.Menu.H + layout.Row.Height
layout.Height -= layout.Menu.H
*layout.Offset = layout.Menu.Offset
layout.Clip.H -= layout.Menu.H + layout.Row.Height
layout.AtY ... | go | {
"resource": ""
} |
q33364 | LayoutReserveRow | train | func (win *Window) LayoutReserveRow(height int, num int) {
win.LayoutReserveRowScaled(win.ctx.scale(height), num)
} | go | {
"resource": ""
} |
q33365 | LayoutReserveRowScaled | train | func (win *Window) LayoutReserveRowScaled(height int, num int) {
win.layout.ReservedHeight += height*num + win.style().Spacing.Y*num
} | go | {
"resource": ""
} |
q33366 | RowScaled | train | func (win *Window) RowScaled(height int) *rowConstructor {
win.rowCtor.height = height
return &win.rowCtor
} | go | {
"resource": ""
} |
q33367 | Dynamic | train | func (ctr *rowConstructor) Dynamic(cols int) {
rowLayoutCtr(ctr.win, ctr.height, cols, 0)
} | go | {
"resource": ""
} |
q33368 | Ratio | train | func (ctr *rowConstructor) Ratio(ratio ...float64) {
layout := ctr.win.layout
panelLayout(ctr.win.ctx, ctr.win, ctr.height, len(ratio), 0)
/* calculate width of undefined widget ratios */
r := 0.0
n_undef := 0
layout.Row.Ratio = ratio
for i := range ratio {
if ratio[i] < 0.0 {
n_undef++
} else {
r += ... | go | {
"resource": ""
} |
q33369 | StaticScaled | train | func (ctr *rowConstructor) StaticScaled(width ...int) {
layout := ctr.win.layout
cnt := 0
if len(width) == 0 {
if len(layout.Row.WidthArr) == 0 {
cnt = layout.Cnt
} else {
cnt = ctr.win.lastLayoutCnt + 1
ctr.win.lastLayoutCnt = cnt
}
}
panelLayout(ctr.win.ctx, ctr.win, ctr.height, len(width), cnt... | go | {
"resource": ""
} |
q33370 | LayoutResetStatic | train | func (win *Window) LayoutResetStatic(width ...int) {
for i := range width {
width[i] = win.ctx.scale(width[i])
}
win.LayoutResetStaticScaled(width...)
} | go | {
"resource": ""
} |
q33371 | SpaceBeginRatio | train | func (ctr *rowConstructor) SpaceBeginRatio(widget_count int) {
layout := ctr.win.layout
panelLayout(ctr.win.ctx, ctr.win, ctr.height, widget_count, 0)
layout.Row.Type = layoutDynamicFree
layout.Row.Ratio = nil
layout.Row.ItemWidth = 0
layout.Row.ItemRatio = 0.0
layout.Row.ItemOffset = 0
layout.Row.Filled = 0
} | go | {
"resource": ""
} |
q33372 | LayoutSetWidth | train | func (win *Window) LayoutSetWidth(width int) {
layout := win.layout
if layout.Row.Type != layoutStatic || len(layout.Row.WidthArr) > 0 {
panic(WrongLayoutErr)
}
layout.Row.Index2++
layout.Row.CalcMaxWidth = false
layout.Row.ItemWidth = win.ctx.scale(width)
} | go | {
"resource": ""
} |
q33373 | LayoutFitWidth | train | func (win *Window) LayoutFitWidth(id int, minwidth int) {
layout := win.layout
if layout.Row.Type != layoutStatic || len(layout.Row.WidthArr) > 0 {
panic(WrongLayoutErr)
}
if win.adjust == nil {
win.adjust = make(map[int]map[int]*adjustCol)
}
adjust, ok := win.adjust[layout.Cnt]
if !ok {
adjust = make(map[... | go | {
"resource": ""
} |
q33374 | LayoutSpacePushScaled | train | func (win *Window) LayoutSpacePushScaled(rect rect.Rect) {
if win.layout.Row.Type != layoutStaticFree {
panic(WrongLayoutErr)
}
win.layout.Row.Item = rect
} | go | {
"resource": ""
} |
q33375 | WidgetBounds | train | func (win *Window) WidgetBounds() rect.Rect {
var bounds rect.Rect
win.layoutPeek(&bounds)
return bounds
} | go | {
"resource": ""
} |
q33376 | LayoutAvailableHeight | train | func (win *Window) LayoutAvailableHeight() int {
return win.layout.Clip.H - (win.layout.AtY - win.layout.Bounds.Y) - win.style().Spacing.Y - win.layout.Row.Height
} | go | {
"resource": ""
} |
q33377 | TreePushNamed | train | func (win *Window) TreePushNamed(type_ TreeType, name, title string, initial_open bool) bool {
labelBounds, _, ok := win.TreePushCustom(type_, name, initial_open)
style := win.style()
z := &win.ctx.Style
out := &win.cmds
var text textWidget
if type_ == TreeTab {
var background *nstyle.Item = &z.Tab.Background... | go | {
"resource": ""
} |
q33378 | TreeIsOpen | train | func (win *Window) TreeIsOpen(name string) bool {
node := win.curNode.Children[name]
if node != nil {
return node.Open
}
return false
} | go | {
"resource": ""
} |
q33379 | TreePop | train | func (win *Window) TreePop() {
layout := win.layout
panel_padding := win.style().Padding
layout.AtX -= panel_padding.X + win.ctx.Style.Tab.Indent
layout.Width += panel_padding.X + win.ctx.Style.Tab.Indent
if layout.Row.TreeDepth == 0 {
panic("TreePop called without opened tree nodes")
}
win.curNode = win.curNo... | go | {
"resource": ""
} |
q33380 | LabelWrapColored | train | func (win *Window) LabelWrapColored(str string, color color.RGBA) {
var bounds rect.Rect
var text textWidget
style := &win.ctx.Style
panelAllocSpace(&bounds, win)
item_padding := style.Text.Padding
text.Padding.X = item_padding.X
text.Padding.Y = item_padding.Y
text.Background = win.style().Background
text.T... | go | {
"resource": ""
} |
q33381 | Label | train | func (win *Window) Label(str string, alignment label.Align) {
win.LabelColored(str, alignment, win.ctx.Style.Text.Color)
} | go | {
"resource": ""
} |
q33382 | LabelWrap | train | func (win *Window) LabelWrap(str string) {
win.LabelWrapColored(str, win.ctx.Style.Text.Color)
} | go | {
"resource": ""
} |
q33383 | Image | train | func (win *Window) Image(img *image.RGBA) {
s, bounds, fitting := win.widget()
if fitting != nil {
fitting(img.Bounds().Dx())
}
if !s {
return
}
win.widgets.Add(nstyle.WidgetStateInactive, bounds)
win.cmds.DrawImage(bounds, img)
} | go | {
"resource": ""
} |
q33384 | Spacing | train | func (win *Window) Spacing(cols int) {
for i := 0; i < cols; i++ {
win.widget()
}
} | go | {
"resource": ""
} |
q33385 | CustomState | train | func (win *Window) CustomState() nstyle.WidgetStates {
bounds := win.WidgetBounds()
s := true
if !win.layout.Clip.Intersect(&bounds) {
s = false
}
ws := win.widgets.PrevState(bounds)
basicWidgetStateControl(&ws, win.inputMaybe(s), bounds)
return ws
} | go | {
"resource": ""
} |
q33386 | Custom | train | func (win *Window) Custom(state nstyle.WidgetStates) (bounds rect.Rect, out *command.Buffer) {
var s bool
if s, bounds, _ = win.widget(); !s {
return
}
prevstate := win.widgets.PrevState(bounds)
exitstate := basicWidgetStateControl(&prevstate, win.inputMaybe(s), bounds)
if state != nstyle.WidgetStateActive {
... | go | {
"resource": ""
} |
q33387 | Button | train | func (win *Window) Button(lbl label.Label, repeat bool) bool {
style := &win.ctx.Style
state, bounds, fitting := win.widget()
if fitting != nil {
buttonWidth(lbl, &style.Button, style.Font)
}
if !state {
return false
}
in := win.inputMaybe(state)
return doButton(win, lbl, bounds, &style.Button, in, repeat)
... | go | {
"resource": ""
} |
q33388 | SelectableLabel | train | func (win *Window) SelectableLabel(str string, align label.Align, value *bool) bool {
style := &win.ctx.Style
state, bounds, fitting := win.widget()
if fitting != nil {
fitting(selectableWidth(str, &style.Selectable, style.Font))
}
if !state {
return false
}
in := win.inputMaybe(state)
return doSelectable(w... | go | {
"resource": ""
} |
q33389 | OptionText | train | func (win *Window) OptionText(text string, is_active bool) bool {
style := &win.ctx.Style
state, bounds, fitting := win.widget()
if fitting != nil {
fitting(toggleWidth(text, toggleOption, &style.Option, style.Font))
}
if !state {
return false
}
in := win.inputMaybe(state)
is_active = doToggle(win, bounds, ... | go | {
"resource": ""
} |
q33390 | CheckboxText | train | func (win *Window) CheckboxText(text string, active *bool) bool {
state, bounds, fitting := win.widget()
if fitting != nil {
fitting(toggleWidth(text, toggleCheck, &win.ctx.Style.Checkbox, win.ctx.Style.Font))
}
if !state {
return false
}
in := win.inputMaybe(state)
old_active := *active
*active = doToggle(... | go | {
"resource": ""
} |
q33391 | SliderFloat | train | func (win *Window) SliderFloat(min_value float64, value *float64, max_value float64, value_step float64) bool {
style := &win.ctx.Style
state, bounds, _ := win.widget()
if !state {
return false
}
in := win.inputMaybe(state)
old_value := *value
*value = doSlider(win, bounds, min_value, old_value, max_value, va... | go | {
"resource": ""
} |
q33392 | SliderInt | train | func (win *Window) SliderInt(min int, val *int, max int, step int) bool {
value := float64(*val)
ret := win.SliderFloat(float64(min), &value, float64(max), float64(step))
*val = int(value)
return ret
} | go | {
"resource": ""
} |
q33393 | Progress | train | func (win *Window) Progress(cur *int, maxval int, is_modifiable bool) bool {
style := &win.ctx.Style
state, bounds, _ := win.widget()
if !state {
return false
}
in := win.inputMaybe(state)
old_value := *cur
*cur = doProgress(win, bounds, *cur, maxval, is_modifiable, &style.Progress, in)
return *cur != old_va... | go | {
"resource": ""
} |
q33394 | PropertyInt | train | func (win *Window) PropertyInt(name string, min int, val *int, max, step, inc_per_pixel int) (changed bool) {
s, bounds, fitting := win.widget()
if fitting != nil {
fitting(propertyWidth(max, &win.ctx.Style.Property, win.ctx.Style.Font))
}
if !s {
return
}
in := win.inputMaybe(s)
text := strconv.Itoa(*val)
... | go | {
"resource": ""
} |
q33395 | MenuItem | train | func (win *Window) MenuItem(lbl label.Label) bool {
style := &win.ctx.Style
state, bounds := win.widgetFitting(style.ContextualButton.Padding)
if !state {
return false
}
if win.flags&windowHDynamic != 0 {
w := FontWidth(style.Font, lbl.Text) + 2*style.ContextualButton.Padding.X
if w > win.menuItemWidth {
... | go | {
"resource": ""
} |
q33396 | TooltipOpen | train | func (win *Window) TooltipOpen(width int, scale bool, updateFn UpdateFn) {
in := &win.ctx.Input
if scale {
width = win.ctx.scale(width)
}
var bounds rect.Rect
bounds.W = width
bounds.H = nk_null_rect.H
bounds.X = (in.Mouse.Pos.X + 1)
bounds.Y = (in.Mouse.Pos.Y + 1)
win.ctx.popupOpen(tooltipWindowTitle, Wi... | go | {
"resource": ""
} |
q33397 | Tooltip | train | func (win *Window) Tooltip(text string) {
if text == "" {
return
}
/* fetch configuration data */
padding := win.ctx.Style.TooltipWindow.Padding
item_spacing := win.ctx.Style.TooltipWindow.Spacing
/* calculate size of the text and tooltip */
text_width := FontWidth(win.ctx.Style.Font, text) + win.ctx.scale(4... | go | {
"resource": ""
} |
q33398 | ComboSimple | train | func (win *Window) ComboSimple(items []string, selected int, item_height int) int {
if len(items) == 0 {
return selected
}
item_height = win.ctx.scale(item_height)
item_padding := win.ctx.Style.Combo.ButtonPadding.Y
window_padding := win.style().Padding.Y
max_height := (len(items)+1)*item_height + item_padding... | go | {
"resource": ""
} |
q33399 | GroupEnd | train | func (win *Window) GroupEnd() {
panelEnd(win.ctx, win)
win.parent.usingSub = false
// immediate drawing
win.parent.cmds.Commands = append(win.parent.cmds.Commands, win.cmds.Commands...)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.