id
int32 0
167k
| repo
stringlengths 5
54
| path
stringlengths 4
155
| func_name
stringlengths 1
118
| original_string
stringlengths 52
85.5k
| language
stringclasses 1
value | code
stringlengths 52
85.5k
| code_tokens
listlengths 21
1.41k
| docstring
stringlengths 6
2.61k
| docstring_tokens
listlengths 3
215
| sha
stringlengths 40
40
| url
stringlengths 85
252
|
|---|---|---|---|---|---|---|---|---|---|---|---|
150,900 |
labstack/gommon
|
color/color.go
|
Printf
|
func (c *Color) Printf(format string, args ...interface{}) {
fmt.Fprintf(c.output, format, args...)
}
|
go
|
func (c *Color) Printf(format string, args ...interface{}) {
fmt.Fprintf(c.output, format, args...)
}
|
[
"func",
"(",
"c",
"*",
"Color",
")",
"Printf",
"(",
"format",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"c",
".",
"output",
",",
"format",
",",
"args",
"...",
")",
"\n",
"}"
] |
// Printf is analogous to `fmt.Printf` with termial detection.
|
[
"Printf",
"is",
"analogous",
"to",
"fmt",
".",
"Printf",
"with",
"termial",
"detection",
"."
] |
82ef680aef5189b68682876cf70d09daa4ac0f51
|
https://github.com/labstack/gommon/blob/82ef680aef5189b68682876cf70d09daa4ac0f51/color/color.go#L172-L174
|
150,901 |
caarlos0/env
|
env.go
|
ParseWithFuncs
|
func ParseWithFuncs(v interface{}, funcMap CustomParsers) error {
ptrRef := reflect.ValueOf(v)
if ptrRef.Kind() != reflect.Ptr {
return ErrNotAStructPtr
}
ref := ptrRef.Elem()
if ref.Kind() != reflect.Struct {
return ErrNotAStructPtr
}
var parsers = defaultCustomParsers()
for k, v := range funcMap {
parsers[k] = v
}
return doParse(ref, parsers)
}
|
go
|
func ParseWithFuncs(v interface{}, funcMap CustomParsers) error {
ptrRef := reflect.ValueOf(v)
if ptrRef.Kind() != reflect.Ptr {
return ErrNotAStructPtr
}
ref := ptrRef.Elem()
if ref.Kind() != reflect.Struct {
return ErrNotAStructPtr
}
var parsers = defaultCustomParsers()
for k, v := range funcMap {
parsers[k] = v
}
return doParse(ref, parsers)
}
|
[
"func",
"ParseWithFuncs",
"(",
"v",
"interface",
"{",
"}",
",",
"funcMap",
"CustomParsers",
")",
"error",
"{",
"ptrRef",
":=",
"reflect",
".",
"ValueOf",
"(",
"v",
")",
"\n",
"if",
"ptrRef",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Ptr",
"{",
"return",
"ErrNotAStructPtr",
"\n",
"}",
"\n",
"ref",
":=",
"ptrRef",
".",
"Elem",
"(",
")",
"\n",
"if",
"ref",
".",
"Kind",
"(",
")",
"!=",
"reflect",
".",
"Struct",
"{",
"return",
"ErrNotAStructPtr",
"\n",
"}",
"\n",
"var",
"parsers",
"=",
"defaultCustomParsers",
"(",
")",
"\n",
"for",
"k",
",",
"v",
":=",
"range",
"funcMap",
"{",
"parsers",
"[",
"k",
"]",
"=",
"v",
"\n",
"}",
"\n",
"return",
"doParse",
"(",
"ref",
",",
"parsers",
")",
"\n",
"}"
] |
// ParseWithFuncs is the same as `Parse` except it also allows the user to pass
// in custom parsers.
|
[
"ParseWithFuncs",
"is",
"the",
"same",
"as",
"Parse",
"except",
"it",
"also",
"allows",
"the",
"user",
"to",
"pass",
"in",
"custom",
"parsers",
"."
] |
2ae6b6e118789b55aae151656169a4a07d4bff42
|
https://github.com/caarlos0/env/blob/2ae6b6e118789b55aae151656169a4a07d4bff42/env.go#L98-L112
|
150,902 |
caarlos0/env
|
env.go
|
parseKeyForOption
|
func parseKeyForOption(key string) (string, []string) {
opts := strings.Split(key, ",")
return opts[0], opts[1:]
}
|
go
|
func parseKeyForOption(key string) (string, []string) {
opts := strings.Split(key, ",")
return opts[0], opts[1:]
}
|
[
"func",
"parseKeyForOption",
"(",
"key",
"string",
")",
"(",
"string",
",",
"[",
"]",
"string",
")",
"{",
"opts",
":=",
"strings",
".",
"Split",
"(",
"key",
",",
"\"",
"\"",
")",
"\n",
"return",
"opts",
"[",
"0",
"]",
",",
"opts",
"[",
"1",
":",
"]",
"\n",
"}"
] |
// split the env tag's key into the expected key and desired option, if any.
|
[
"split",
"the",
"env",
"tag",
"s",
"key",
"into",
"the",
"expected",
"key",
"and",
"desired",
"option",
"if",
"any",
"."
] |
2ae6b6e118789b55aae151656169a4a07d4bff42
|
https://github.com/caarlos0/env/blob/2ae6b6e118789b55aae151656169a4a07d4bff42/env.go#L183-L186
|
150,903 |
go-gl/glfw
|
v3.2/glfw/native_windows.go
|
GetWin32Adapter
|
func (m *Monitor) GetWin32Adapter() string {
ret := C.glfwGetWin32Adapter(m.data)
panicError()
return C.GoString(ret)
}
|
go
|
func (m *Monitor) GetWin32Adapter() string {
ret := C.glfwGetWin32Adapter(m.data)
panicError()
return C.GoString(ret)
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetWin32Adapter",
"(",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"glfwGetWin32Adapter",
"(",
"m",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"ret",
")",
"\n",
"}"
] |
// GetWin32Adapter returns the adapter device name of the monitor.
|
[
"GetWin32Adapter",
"returns",
"the",
"adapter",
"device",
"name",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_windows.go#L11-L15
|
150,904 |
go-gl/glfw
|
v3.2/glfw/native_windows.go
|
GetWin32Monitor
|
func (m *Monitor) GetWin32Monitor() string {
ret := C.glfwGetWin32Monitor(m.data)
panicError()
return C.GoString(ret)
}
|
go
|
func (m *Monitor) GetWin32Monitor() string {
ret := C.glfwGetWin32Monitor(m.data)
panicError()
return C.GoString(ret)
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetWin32Monitor",
"(",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"glfwGetWin32Monitor",
"(",
"m",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"ret",
")",
"\n",
"}"
] |
// GetWin32Monitor returns the display device name of the monitor.
|
[
"GetWin32Monitor",
"returns",
"the",
"display",
"device",
"name",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_windows.go#L18-L22
|
150,905 |
go-gl/glfw
|
v3.2/glfw/native_windows.go
|
GetWin32Window
|
func (w *Window) GetWin32Window() C.HWND {
ret := C.glfwGetWin32Window(w.data)
panicError()
return ret
}
|
go
|
func (w *Window) GetWin32Window() C.HWND {
ret := C.glfwGetWin32Window(w.data)
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetWin32Window",
"(",
")",
"C",
".",
"HWND",
"{",
"ret",
":=",
"C",
".",
"glfwGetWin32Window",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetWin32Window returns the HWND of the window.
|
[
"GetWin32Window",
"returns",
"the",
"HWND",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_windows.go#L25-L29
|
150,906 |
go-gl/glfw
|
v3.2/glfw/native_windows.go
|
GetWGLContext
|
func (w *Window) GetWGLContext() C.HGLRC {
ret := C.glfwGetWGLContext(w.data)
panicError()
return ret
}
|
go
|
func (w *Window) GetWGLContext() C.HGLRC {
ret := C.glfwGetWGLContext(w.data)
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetWGLContext",
"(",
")",
"C",
".",
"HGLRC",
"{",
"ret",
":=",
"C",
".",
"glfwGetWGLContext",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetWGLContext returns the HGLRC of the window.
|
[
"GetWGLContext",
"returns",
"the",
"HGLRC",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_windows.go#L32-L36
|
150,907 |
go-gl/glfw
|
v3.0/glfw/monitor.go
|
GetPosition
|
func (m *Monitor) GetPosition() (x, y int) {
var xpos, ypos C.int
C.glfwGetMonitorPos(m.data, &xpos, &ypos)
return int(xpos), int(ypos)
}
|
go
|
func (m *Monitor) GetPosition() (x, y int) {
var xpos, ypos C.int
C.glfwGetMonitorPos(m.data, &xpos, &ypos)
return int(xpos), int(ypos)
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetPosition",
"(",
")",
"(",
"x",
",",
"y",
"int",
")",
"{",
"var",
"xpos",
",",
"ypos",
"C",
".",
"int",
"\n\n",
"C",
".",
"glfwGetMonitorPos",
"(",
"m",
".",
"data",
",",
"&",
"xpos",
",",
"&",
"ypos",
")",
"\n",
"return",
"int",
"(",
"xpos",
")",
",",
"int",
"(",
"ypos",
")",
"\n",
"}"
] |
//GetPosition returns the position, in screen coordinates, of the upper-left
//corner of the monitor.
|
[
"GetPosition",
"returns",
"the",
"position",
"in",
"screen",
"coordinates",
"of",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/monitor.go#L86-L91
|
150,908 |
go-gl/glfw
|
v3.0/glfw/monitor.go
|
SetGamma
|
func (m *Monitor) SetGamma(gamma float32) {
C.glfwSetGamma(m.data, C.float(gamma))
}
|
go
|
func (m *Monitor) SetGamma(gamma float32) {
C.glfwSetGamma(m.data, C.float(gamma))
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"SetGamma",
"(",
"gamma",
"float32",
")",
"{",
"C",
".",
"glfwSetGamma",
"(",
"m",
".",
"data",
",",
"C",
".",
"float",
"(",
"gamma",
")",
")",
"\n",
"}"
] |
//SetGamma generates a 256-element gamma ramp from the specified exponent and then calls
//SetGamma with it.
|
[
"SetGamma",
"generates",
"a",
"256",
"-",
"element",
"gamma",
"ramp",
"from",
"the",
"specified",
"exponent",
"and",
"then",
"calls",
"SetGamma",
"with",
"it",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/monitor.go#L164-L166
|
150,909 |
go-gl/glfw
|
v3.0/glfw/monitor.go
|
GetGammaRamp
|
func (m *Monitor) GetGammaRamp() (*GammaRamp, error) {
var ramp GammaRamp
rampC := C.glfwGetGammaRamp(m.data)
if rampC == nil {
return nil, errors.New("Can't get the gamma ramp.")
}
length := int(rampC.size)
ramp.Red = make([]uint16, length)
ramp.Green = make([]uint16, length)
ramp.Blue = make([]uint16, length)
for i := 0; i < length; i++ {
ramp.Red[i] = uint16(C.GetGammaAtIndex(rampC.red, C.int(i)))
ramp.Green[i] = uint16(C.GetGammaAtIndex(rampC.green, C.int(i)))
ramp.Blue[i] = uint16(C.GetGammaAtIndex(rampC.blue, C.int(i)))
}
return &ramp, nil
}
|
go
|
func (m *Monitor) GetGammaRamp() (*GammaRamp, error) {
var ramp GammaRamp
rampC := C.glfwGetGammaRamp(m.data)
if rampC == nil {
return nil, errors.New("Can't get the gamma ramp.")
}
length := int(rampC.size)
ramp.Red = make([]uint16, length)
ramp.Green = make([]uint16, length)
ramp.Blue = make([]uint16, length)
for i := 0; i < length; i++ {
ramp.Red[i] = uint16(C.GetGammaAtIndex(rampC.red, C.int(i)))
ramp.Green[i] = uint16(C.GetGammaAtIndex(rampC.green, C.int(i)))
ramp.Blue[i] = uint16(C.GetGammaAtIndex(rampC.blue, C.int(i)))
}
return &ramp, nil
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetGammaRamp",
"(",
")",
"(",
"*",
"GammaRamp",
",",
"error",
")",
"{",
"var",
"ramp",
"GammaRamp",
"\n\n",
"rampC",
":=",
"C",
".",
"glfwGetGammaRamp",
"(",
"m",
".",
"data",
")",
"\n",
"if",
"rampC",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"length",
":=",
"int",
"(",
"rampC",
".",
"size",
")",
"\n",
"ramp",
".",
"Red",
"=",
"make",
"(",
"[",
"]",
"uint16",
",",
"length",
")",
"\n",
"ramp",
".",
"Green",
"=",
"make",
"(",
"[",
"]",
"uint16",
",",
"length",
")",
"\n",
"ramp",
".",
"Blue",
"=",
"make",
"(",
"[",
"]",
"uint16",
",",
"length",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"ramp",
".",
"Red",
"[",
"i",
"]",
"=",
"uint16",
"(",
"C",
".",
"GetGammaAtIndex",
"(",
"rampC",
".",
"red",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
")",
"\n",
"ramp",
".",
"Green",
"[",
"i",
"]",
"=",
"uint16",
"(",
"C",
".",
"GetGammaAtIndex",
"(",
"rampC",
".",
"green",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
")",
"\n",
"ramp",
".",
"Blue",
"[",
"i",
"]",
"=",
"uint16",
"(",
"C",
".",
"GetGammaAtIndex",
"(",
"rampC",
".",
"blue",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"&",
"ramp",
",",
"nil",
"\n",
"}"
] |
//GetGammaRamp retrieves the current gamma ramp of the monitor.
|
[
"GetGammaRamp",
"retrieves",
"the",
"current",
"gamma",
"ramp",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/monitor.go#L169-L189
|
150,910 |
go-gl/glfw
|
v3.0/glfw/monitor.go
|
SetGammaRamp
|
func (m *Monitor) SetGammaRamp(ramp *GammaRamp) {
var rampC C.GLFWgammaramp
length := len(ramp.Red)
for i := 0; i < length; i++ {
C.SetGammaAtIndex(rampC.red, C.int(i), C.ushort(ramp.Red[i]))
C.SetGammaAtIndex(rampC.green, C.int(i), C.ushort(ramp.Green[i]))
C.SetGammaAtIndex(rampC.blue, C.int(i), C.ushort(ramp.Blue[i]))
}
C.glfwSetGammaRamp(m.data, &rampC)
}
|
go
|
func (m *Monitor) SetGammaRamp(ramp *GammaRamp) {
var rampC C.GLFWgammaramp
length := len(ramp.Red)
for i := 0; i < length; i++ {
C.SetGammaAtIndex(rampC.red, C.int(i), C.ushort(ramp.Red[i]))
C.SetGammaAtIndex(rampC.green, C.int(i), C.ushort(ramp.Green[i]))
C.SetGammaAtIndex(rampC.blue, C.int(i), C.ushort(ramp.Blue[i]))
}
C.glfwSetGammaRamp(m.data, &rampC)
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"SetGammaRamp",
"(",
"ramp",
"*",
"GammaRamp",
")",
"{",
"var",
"rampC",
"C",
".",
"GLFWgammaramp",
"\n\n",
"length",
":=",
"len",
"(",
"ramp",
".",
"Red",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"C",
".",
"SetGammaAtIndex",
"(",
"rampC",
".",
"red",
",",
"C",
".",
"int",
"(",
"i",
")",
",",
"C",
".",
"ushort",
"(",
"ramp",
".",
"Red",
"[",
"i",
"]",
")",
")",
"\n",
"C",
".",
"SetGammaAtIndex",
"(",
"rampC",
".",
"green",
",",
"C",
".",
"int",
"(",
"i",
")",
",",
"C",
".",
"ushort",
"(",
"ramp",
".",
"Green",
"[",
"i",
"]",
")",
")",
"\n",
"C",
".",
"SetGammaAtIndex",
"(",
"rampC",
".",
"blue",
",",
"C",
".",
"int",
"(",
"i",
")",
",",
"C",
".",
"ushort",
"(",
"ramp",
".",
"Blue",
"[",
"i",
"]",
")",
")",
"\n",
"}",
"\n\n",
"C",
".",
"glfwSetGammaRamp",
"(",
"m",
".",
"data",
",",
"&",
"rampC",
")",
"\n",
"}"
] |
//SetGammaRamp sets the current gamma ramp for the monitor.
|
[
"SetGammaRamp",
"sets",
"the",
"current",
"gamma",
"ramp",
"for",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/monitor.go#L192-L204
|
150,911 |
go-gl/glfw
|
v3.2/glfw/input.go
|
GetInputMode
|
func (w *Window) GetInputMode(mode InputMode) int {
ret := int(C.glfwGetInputMode(w.data, C.int(mode)))
panicError()
return ret
}
|
go
|
func (w *Window) GetInputMode(mode InputMode) int {
ret := int(C.glfwGetInputMode(w.data, C.int(mode)))
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetInputMode",
"(",
"mode",
"InputMode",
")",
"int",
"{",
"ret",
":=",
"int",
"(",
"C",
".",
"glfwGetInputMode",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"mode",
")",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetInputMode returns the value of an input option of the window.
|
[
"GetInputMode",
"returns",
"the",
"value",
"of",
"an",
"input",
"option",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L317-L321
|
150,912 |
go-gl/glfw
|
v3.2/glfw/input.go
|
SetInputMode
|
func (w *Window) SetInputMode(mode InputMode, value int) {
C.glfwSetInputMode(w.data, C.int(mode), C.int(value))
panicError()
}
|
go
|
func (w *Window) SetInputMode(mode InputMode, value int) {
C.glfwSetInputMode(w.data, C.int(mode), C.int(value))
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetInputMode",
"(",
"mode",
"InputMode",
",",
"value",
"int",
")",
"{",
"C",
".",
"glfwSetInputMode",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"mode",
")",
",",
"C",
".",
"int",
"(",
"value",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetInputMode sets an input option for the window.
|
[
"SetInputMode",
"sets",
"an",
"input",
"option",
"for",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L324-L327
|
150,913 |
go-gl/glfw
|
v3.2/glfw/input.go
|
GetKeyName
|
func GetKeyName(key Key, scancode int) string {
ret := C.glfwGetKeyName(C.int(key), C.int(scancode))
panicError()
return C.GoString(ret)
}
|
go
|
func GetKeyName(key Key, scancode int) string {
ret := C.glfwGetKeyName(C.int(key), C.int(scancode))
panicError()
return C.GoString(ret)
}
|
[
"func",
"GetKeyName",
"(",
"key",
"Key",
",",
"scancode",
"int",
")",
"string",
"{",
"ret",
":=",
"C",
".",
"glfwGetKeyName",
"(",
"C",
".",
"int",
"(",
"key",
")",
",",
"C",
".",
"int",
"(",
"scancode",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"ret",
")",
"\n",
"}"
] |
// GetKeyName returns the localized name of the specified printable key.
//
// If the key is glfw.KeyUnknown, the scancode is used, otherwise the scancode is ignored.
|
[
"GetKeyName",
"returns",
"the",
"localized",
"name",
"of",
"the",
"specified",
"printable",
"key",
".",
"If",
"the",
"key",
"is",
"glfw",
".",
"KeyUnknown",
"the",
"scancode",
"is",
"used",
"otherwise",
"the",
"scancode",
"is",
"ignored",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L349-L353
|
150,914 |
go-gl/glfw
|
v3.2/glfw/input.go
|
SetCursor
|
func (w *Window) SetCursor(c *Cursor) {
if c == nil {
C.glfwSetCursor(w.data, nil)
} else {
C.glfwSetCursor(w.data, c.data)
}
panicError()
}
|
go
|
func (w *Window) SetCursor(c *Cursor) {
if c == nil {
C.glfwSetCursor(w.data, nil)
} else {
C.glfwSetCursor(w.data, c.data)
}
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetCursor",
"(",
"c",
"*",
"Cursor",
")",
"{",
"if",
"c",
"==",
"nil",
"{",
"C",
".",
"glfwSetCursor",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"C",
".",
"glfwSetCursor",
"(",
"w",
".",
"data",
",",
"c",
".",
"data",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetCursor sets the cursor image to be used when the cursor is over the client area
// of the specified window. The set cursor will only be visible when the cursor mode of the
// window is CursorNormal.
//
// On some platforms, the set cursor may not be visible unless the window also has input focus.
|
[
"SetCursor",
"sets",
"the",
"cursor",
"image",
"to",
"be",
"used",
"when",
"the",
"cursor",
"is",
"over",
"the",
"client",
"area",
"of",
"the",
"specified",
"window",
".",
"The",
"set",
"cursor",
"will",
"only",
"be",
"visible",
"when",
"the",
"cursor",
"mode",
"of",
"the",
"window",
"is",
"CursorNormal",
".",
"On",
"some",
"platforms",
"the",
"set",
"cursor",
"may",
"not",
"be",
"visible",
"unless",
"the",
"window",
"also",
"has",
"input",
"focus",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L451-L458
|
150,915 |
go-gl/glfw
|
v3.2/glfw/input.go
|
SetJoystickCallback
|
func SetJoystickCallback(cbfun JoystickCallback) (previous JoystickCallback) {
previous = fJoystickHolder
fJoystickHolder = cbfun
if cbfun == nil {
C.glfwSetJoystickCallback(nil)
} else {
C.glfwSetJoystickCallbackCB()
}
panicError()
return previous
}
|
go
|
func SetJoystickCallback(cbfun JoystickCallback) (previous JoystickCallback) {
previous = fJoystickHolder
fJoystickHolder = cbfun
if cbfun == nil {
C.glfwSetJoystickCallback(nil)
} else {
C.glfwSetJoystickCallbackCB()
}
panicError()
return previous
}
|
[
"func",
"SetJoystickCallback",
"(",
"cbfun",
"JoystickCallback",
")",
"(",
"previous",
"JoystickCallback",
")",
"{",
"previous",
"=",
"fJoystickHolder",
"\n",
"fJoystickHolder",
"=",
"cbfun",
"\n",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetJoystickCallback",
"(",
"nil",
")",
"\n",
"}",
"else",
"{",
"C",
".",
"glfwSetJoystickCallbackCB",
"(",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"previous",
"\n",
"}"
] |
// SetJoystickCallback sets the joystick configuration callback, or removes the
// currently set callback. This is called when a joystick is connected to or
// disconnected from the system.
|
[
"SetJoystickCallback",
"sets",
"the",
"joystick",
"configuration",
"callback",
"or",
"removes",
"the",
"currently",
"set",
"callback",
".",
"This",
"is",
"called",
"when",
"a",
"joystick",
"is",
"connected",
"to",
"or",
"disconnected",
"from",
"the",
"system",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L466-L476
|
150,916 |
go-gl/glfw
|
v3.2/glfw/input.go
|
SetCursorPosCallback
|
func (w *Window) SetCursorPosCallback(cbfun CursorPosCallback) (previous CursorPosCallback) {
previous = w.fCursorPosHolder
w.fCursorPosHolder = cbfun
if cbfun == nil {
C.glfwSetCursorPosCallback(w.data, nil)
} else {
C.glfwSetCursorPosCallbackCB(w.data)
}
panicError()
return previous
}
|
go
|
func (w *Window) SetCursorPosCallback(cbfun CursorPosCallback) (previous CursorPosCallback) {
previous = w.fCursorPosHolder
w.fCursorPosHolder = cbfun
if cbfun == nil {
C.glfwSetCursorPosCallback(w.data, nil)
} else {
C.glfwSetCursorPosCallbackCB(w.data)
}
panicError()
return previous
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetCursorPosCallback",
"(",
"cbfun",
"CursorPosCallback",
")",
"(",
"previous",
"CursorPosCallback",
")",
"{",
"previous",
"=",
"w",
".",
"fCursorPosHolder",
"\n",
"w",
".",
"fCursorPosHolder",
"=",
"cbfun",
"\n",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetCursorPosCallback",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"C",
".",
"glfwSetCursorPosCallbackCB",
"(",
"w",
".",
"data",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"previous",
"\n",
"}"
] |
// SetCursorPosCallback sets the cursor position callback which is called
// when the cursor is moved. The callback is provided with the position relative
// to the upper-left corner of the client area of the window.
|
[
"SetCursorPosCallback",
"sets",
"the",
"cursor",
"position",
"callback",
"which",
"is",
"called",
"when",
"the",
"cursor",
"is",
"moved",
".",
"The",
"callback",
"is",
"provided",
"with",
"the",
"position",
"relative",
"to",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"client",
"area",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L588-L598
|
150,917 |
go-gl/glfw
|
v3.2/glfw/input.go
|
SetDropCallback
|
func (w *Window) SetDropCallback(cbfun DropCallback) (previous DropCallback) {
previous = w.fDropHolder
w.fDropHolder = cbfun
if cbfun == nil {
C.glfwSetDropCallback(w.data, nil)
} else {
C.glfwSetDropCallbackCB(w.data)
}
panicError()
return previous
}
|
go
|
func (w *Window) SetDropCallback(cbfun DropCallback) (previous DropCallback) {
previous = w.fDropHolder
w.fDropHolder = cbfun
if cbfun == nil {
C.glfwSetDropCallback(w.data, nil)
} else {
C.glfwSetDropCallbackCB(w.data)
}
panicError()
return previous
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetDropCallback",
"(",
"cbfun",
"DropCallback",
")",
"(",
"previous",
"DropCallback",
")",
"{",
"previous",
"=",
"w",
".",
"fDropHolder",
"\n",
"w",
".",
"fDropHolder",
"=",
"cbfun",
"\n",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetDropCallback",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"C",
".",
"glfwSetDropCallbackCB",
"(",
"w",
".",
"data",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"previous",
"\n",
"}"
] |
// SetDropCallback sets the drop callback which is called when an object
// is dropped over the window.
|
[
"SetDropCallback",
"sets",
"the",
"drop",
"callback",
"which",
"is",
"called",
"when",
"an",
"object",
"is",
"dropped",
"over",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L639-L649
|
150,918 |
go-gl/glfw
|
v3.2/glfw/input.go
|
JoystickPresent
|
func JoystickPresent(joy Joystick) bool {
ret := glfwbool(C.glfwJoystickPresent(C.int(joy)))
panicError()
return ret
}
|
go
|
func JoystickPresent(joy Joystick) bool {
ret := glfwbool(C.glfwJoystickPresent(C.int(joy)))
panicError()
return ret
}
|
[
"func",
"JoystickPresent",
"(",
"joy",
"Joystick",
")",
"bool",
"{",
"ret",
":=",
"glfwbool",
"(",
"C",
".",
"glfwJoystickPresent",
"(",
"C",
".",
"int",
"(",
"joy",
")",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// JoystickPresent reports whether the specified joystick is present.
|
[
"JoystickPresent",
"reports",
"whether",
"the",
"specified",
"joystick",
"is",
"present",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L652-L656
|
150,919 |
go-gl/glfw
|
v3.2/glfw/input.go
|
GetJoystickAxes
|
func GetJoystickAxes(joy Joystick) []float32 {
var length int
axis := C.glfwGetJoystickAxes(C.int(joy), (*C.int)(unsafe.Pointer(&length)))
panicError()
if axis == nil {
return nil
}
a := make([]float32, length)
for i := 0; i < length; i++ {
a[i] = float32(C.GetAxisAtIndex(axis, C.int(i)))
}
return a
}
|
go
|
func GetJoystickAxes(joy Joystick) []float32 {
var length int
axis := C.glfwGetJoystickAxes(C.int(joy), (*C.int)(unsafe.Pointer(&length)))
panicError()
if axis == nil {
return nil
}
a := make([]float32, length)
for i := 0; i < length; i++ {
a[i] = float32(C.GetAxisAtIndex(axis, C.int(i)))
}
return a
}
|
[
"func",
"GetJoystickAxes",
"(",
"joy",
"Joystick",
")",
"[",
"]",
"float32",
"{",
"var",
"length",
"int",
"\n\n",
"axis",
":=",
"C",
".",
"glfwGetJoystickAxes",
"(",
"C",
".",
"int",
"(",
"joy",
")",
",",
"(",
"*",
"C",
".",
"int",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"length",
")",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"if",
"axis",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"a",
":=",
"make",
"(",
"[",
"]",
"float32",
",",
"length",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"a",
"[",
"i",
"]",
"=",
"float32",
"(",
"C",
".",
"GetAxisAtIndex",
"(",
"axis",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"a",
"\n",
"}"
] |
// GetJoystickAxes returns a slice of axis values.
|
[
"GetJoystickAxes",
"returns",
"a",
"slice",
"of",
"axis",
"values",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/input.go#L659-L673
|
150,920 |
go-gl/glfw
|
v3.2/glfw/error.go
|
Error
|
func (e *Error) Error() string {
return fmt.Sprintf("%s: %s", e.Code.String(), e.Desc)
}
|
go
|
func (e *Error) Error() string {
return fmt.Sprintf("%s: %s", e.Code.String(), e.Desc)
}
|
[
"func",
"(",
"e",
"*",
"Error",
")",
"Error",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"Code",
".",
"String",
"(",
")",
",",
"e",
".",
"Desc",
")",
"\n",
"}"
] |
// Error prints the error code and description in a readable format.
|
[
"Error",
"prints",
"the",
"error",
"code",
"and",
"description",
"in",
"a",
"readable",
"format",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/error.go#L104-L106
|
150,921 |
go-gl/glfw
|
v3.2/glfw/error.go
|
flushErrors
|
func flushErrors() {
err := fetchError()
if err != nil {
fmt.Println("GLFW: An uncaught error has occurred:", err)
fmt.Println("GLFW: Please report this bug in the Go package immediately.")
}
}
|
go
|
func flushErrors() {
err := fetchError()
if err != nil {
fmt.Println("GLFW: An uncaught error has occurred:", err)
fmt.Println("GLFW: Please report this bug in the Go package immediately.")
}
}
|
[
"func",
"flushErrors",
"(",
")",
"{",
"err",
":=",
"fetchError",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"}"
] |
// flushErrors is called by Terminate before it actually calls C.glfwTerminate,
// this ensures that any uncaught errors buffered in lastError are printed
// before the program exits.
|
[
"flushErrors",
"is",
"called",
"by",
"Terminate",
"before",
"it",
"actually",
"calls",
"C",
".",
"glfwTerminate",
"this",
"ensures",
"that",
"any",
"uncaught",
"errors",
"buffered",
"in",
"lastError",
"are",
"printed",
"before",
"the",
"program",
"exits",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/error.go#L134-L140
|
150,922 |
go-gl/glfw
|
v3.0/glfw/glfw.go
|
GetVersion
|
func GetVersion() (major, minor, revision int) {
var (
maj C.int
min C.int
rev C.int
)
C.glfwGetVersion(&maj, &min, &rev)
return int(maj), int(min), int(rev)
}
|
go
|
func GetVersion() (major, minor, revision int) {
var (
maj C.int
min C.int
rev C.int
)
C.glfwGetVersion(&maj, &min, &rev)
return int(maj), int(min), int(rev)
}
|
[
"func",
"GetVersion",
"(",
")",
"(",
"major",
",",
"minor",
",",
"revision",
"int",
")",
"{",
"var",
"(",
"maj",
"C",
".",
"int",
"\n",
"min",
"C",
".",
"int",
"\n",
"rev",
"C",
".",
"int",
"\n",
")",
"\n\n",
"C",
".",
"glfwGetVersion",
"(",
"&",
"maj",
",",
"&",
"min",
",",
"&",
"rev",
")",
"\n",
"return",
"int",
"(",
"maj",
")",
",",
"int",
"(",
"min",
")",
",",
"int",
"(",
"rev",
")",
"\n",
"}"
] |
//GetVersion retrieves the major, minor and revision numbers of the GLFW
//library. It is intended for when you are using GLFW as a shared library and
//want to ensure that you are using the minimum required version.
//
//This function may be called before Init.
|
[
"GetVersion",
"retrieves",
"the",
"major",
"minor",
"and",
"revision",
"numbers",
"of",
"the",
"GLFW",
"library",
".",
"It",
"is",
"intended",
"for",
"when",
"you",
"are",
"using",
"GLFW",
"as",
"a",
"shared",
"library",
"and",
"want",
"to",
"ensure",
"that",
"you",
"are",
"using",
"the",
"minimum",
"required",
"version",
".",
"This",
"function",
"may",
"be",
"called",
"before",
"Init",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/glfw.go#L67-L76
|
150,923 |
go-gl/glfw
|
v3.0/glfw/input.go
|
GetKey
|
func (w *Window) GetKey(key Key) Action {
return Action(C.glfwGetKey(w.data, C.int(key)))
}
|
go
|
func (w *Window) GetKey(key Key) Action {
return Action(C.glfwGetKey(w.data, C.int(key)))
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetKey",
"(",
"key",
"Key",
")",
"Action",
"{",
"return",
"Action",
"(",
"C",
".",
"glfwGetKey",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"key",
")",
")",
")",
"\n",
"}"
] |
//GetKey returns the last reported state of a keyboard key. The returned state
//is one of Press or Release. The higher-level state Repeat is only reported to
//the key callback.
//
//If the StickyKeys input mode is enabled, this function returns Press the first
//time you call this function after a key has been pressed, even if the key has
//already been released.
//
//The key functions deal with physical keys, with key tokens named after their
//use on the standard US keyboard layout. If you want to input text, use the
//Unicode character callback instead.
|
[
"GetKey",
"returns",
"the",
"last",
"reported",
"state",
"of",
"a",
"keyboard",
"key",
".",
"The",
"returned",
"state",
"is",
"one",
"of",
"Press",
"or",
"Release",
".",
"The",
"higher",
"-",
"level",
"state",
"Repeat",
"is",
"only",
"reported",
"to",
"the",
"key",
"callback",
".",
"If",
"the",
"StickyKeys",
"input",
"mode",
"is",
"enabled",
"this",
"function",
"returns",
"Press",
"the",
"first",
"time",
"you",
"call",
"this",
"function",
"after",
"a",
"key",
"has",
"been",
"pressed",
"even",
"if",
"the",
"key",
"has",
"already",
"been",
"released",
".",
"The",
"key",
"functions",
"deal",
"with",
"physical",
"keys",
"with",
"key",
"tokens",
"named",
"after",
"their",
"use",
"on",
"the",
"standard",
"US",
"keyboard",
"layout",
".",
"If",
"you",
"want",
"to",
"input",
"text",
"use",
"the",
"Unicode",
"character",
"callback",
"instead",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/input.go#L290-L292
|
150,924 |
go-gl/glfw
|
v3.0/glfw/input.go
|
GetMouseButton
|
func (w *Window) GetMouseButton(button MouseButton) Action {
return Action(C.glfwGetMouseButton(w.data, C.int(button)))
}
|
go
|
func (w *Window) GetMouseButton(button MouseButton) Action {
return Action(C.glfwGetMouseButton(w.data, C.int(button)))
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetMouseButton",
"(",
"button",
"MouseButton",
")",
"Action",
"{",
"return",
"Action",
"(",
"C",
".",
"glfwGetMouseButton",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"button",
")",
")",
")",
"\n",
"}"
] |
//GetMouseButton returns the last state reported for the specified mouse button.
//
//If the StickyMouseButtons input mode is enabled, this function returns Press
//the first time you call this function after a mouse button has been pressed,
//even if the mouse button has already been released.
|
[
"GetMouseButton",
"returns",
"the",
"last",
"state",
"reported",
"for",
"the",
"specified",
"mouse",
"button",
".",
"If",
"the",
"StickyMouseButtons",
"input",
"mode",
"is",
"enabled",
"this",
"function",
"returns",
"Press",
"the",
"first",
"time",
"you",
"call",
"this",
"function",
"after",
"a",
"mouse",
"button",
"has",
"been",
"pressed",
"even",
"if",
"the",
"mouse",
"button",
"has",
"already",
"been",
"released",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/input.go#L299-L301
|
150,925 |
go-gl/glfw
|
v3.0/glfw/input.go
|
SetCharacterCallback
|
func (w *Window) SetCharacterCallback(cbfun func(w *Window, char uint)) {
if cbfun == nil {
C.glfwSetCharCallback(w.data, nil)
} else {
w.fCharHolder = cbfun
C.glfwSetCharCallbackCB(w.data)
}
}
|
go
|
func (w *Window) SetCharacterCallback(cbfun func(w *Window, char uint)) {
if cbfun == nil {
C.glfwSetCharCallback(w.data, nil)
} else {
w.fCharHolder = cbfun
C.glfwSetCharCallbackCB(w.data)
}
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetCharacterCallback",
"(",
"cbfun",
"func",
"(",
"w",
"*",
"Window",
",",
"char",
"uint",
")",
")",
"{",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetCharCallback",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"w",
".",
"fCharHolder",
"=",
"cbfun",
"\n",
"C",
".",
"glfwSetCharCallbackCB",
"(",
"w",
".",
"data",
")",
"\n",
"}",
"\n",
"}"
] |
//SetCharacterCallback sets the character callback which is called when a
//Unicode character is input.
//
//The character callback is intended for text input. If you want to know whether
//a specific key was pressed or released, use the key callback instead.
|
[
"SetCharacterCallback",
"sets",
"the",
"character",
"callback",
"which",
"is",
"called",
"when",
"a",
"Unicode",
"character",
"is",
"input",
".",
"The",
"character",
"callback",
"is",
"intended",
"for",
"text",
"input",
".",
"If",
"you",
"want",
"to",
"know",
"whether",
"a",
"specific",
"key",
"was",
"pressed",
"or",
"released",
"use",
"the",
"key",
"callback",
"instead",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/input.go#L354-L361
|
150,926 |
go-gl/glfw
|
v3.0/glfw/input.go
|
SetCursorPositionCallback
|
func (w *Window) SetCursorPositionCallback(cbfun func(w *Window, xpos float64, ypos float64)) {
if cbfun == nil {
C.glfwSetCursorPosCallback(w.data, nil)
} else {
w.fCursorPosHolder = cbfun
C.glfwSetCursorPosCallbackCB(w.data)
}
}
|
go
|
func (w *Window) SetCursorPositionCallback(cbfun func(w *Window, xpos float64, ypos float64)) {
if cbfun == nil {
C.glfwSetCursorPosCallback(w.data, nil)
} else {
w.fCursorPosHolder = cbfun
C.glfwSetCursorPosCallbackCB(w.data)
}
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetCursorPositionCallback",
"(",
"cbfun",
"func",
"(",
"w",
"*",
"Window",
",",
"xpos",
"float64",
",",
"ypos",
"float64",
")",
")",
"{",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetCursorPosCallback",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"w",
".",
"fCursorPosHolder",
"=",
"cbfun",
"\n",
"C",
".",
"glfwSetCursorPosCallbackCB",
"(",
"w",
".",
"data",
")",
"\n",
"}",
"\n",
"}"
] |
//SetCursorPositionCallback sets the cursor position callback which is called
//when the cursor is moved. The callback is provided with the position relative
//to the upper-left corner of the client area of the window.
|
[
"SetCursorPositionCallback",
"sets",
"the",
"cursor",
"position",
"callback",
"which",
"is",
"called",
"when",
"the",
"cursor",
"is",
"moved",
".",
"The",
"callback",
"is",
"provided",
"with",
"the",
"position",
"relative",
"to",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"client",
"area",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/input.go#L383-L390
|
150,927 |
go-gl/glfw
|
v3.0/glfw/input.go
|
GetJoystickButtons
|
func GetJoystickButtons(joy Joystick) ([]byte, error) {
var length int
buttons := C.glfwGetJoystickButtons(C.int(joy), (*C.int)(unsafe.Pointer(&length)))
if buttons == nil {
return nil, errors.New("Joystick is not present.")
}
b := make([]byte, length)
for i := 0; i < length; i++ {
b[i] = byte(C.GetButtonsAtIndex(buttons, C.int(i)))
}
return b, nil
}
|
go
|
func GetJoystickButtons(joy Joystick) ([]byte, error) {
var length int
buttons := C.glfwGetJoystickButtons(C.int(joy), (*C.int)(unsafe.Pointer(&length)))
if buttons == nil {
return nil, errors.New("Joystick is not present.")
}
b := make([]byte, length)
for i := 0; i < length; i++ {
b[i] = byte(C.GetButtonsAtIndex(buttons, C.int(i)))
}
return b, nil
}
|
[
"func",
"GetJoystickButtons",
"(",
"joy",
"Joystick",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"length",
"int",
"\n\n",
"buttons",
":=",
"C",
".",
"glfwGetJoystickButtons",
"(",
"C",
".",
"int",
"(",
"joy",
")",
",",
"(",
"*",
"C",
".",
"int",
")",
"(",
"unsafe",
".",
"Pointer",
"(",
"&",
"length",
")",
")",
")",
"\n",
"if",
"buttons",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"b",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"length",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"b",
"[",
"i",
"]",
"=",
"byte",
"(",
"C",
".",
"GetButtonsAtIndex",
"(",
"buttons",
",",
"C",
".",
"int",
"(",
"i",
")",
")",
")",
"\n",
"}",
"\n\n",
"return",
"b",
",",
"nil",
"\n",
"}"
] |
//GetJoystickButtons returns a slice of button values.
|
[
"GetJoystickButtons",
"returns",
"a",
"slice",
"of",
"button",
"values",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/input.go#L437-L451
|
150,928 |
go-gl/glfw
|
v3.0/glfw/window.go
|
GetPosition
|
func (w *Window) GetPosition() (x, y int) {
var xpos, ypos C.int
C.glfwGetWindowPos(w.data, &xpos, &ypos)
return int(xpos), int(ypos)
}
|
go
|
func (w *Window) GetPosition() (x, y int) {
var xpos, ypos C.int
C.glfwGetWindowPos(w.data, &xpos, &ypos)
return int(xpos), int(ypos)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetPosition",
"(",
")",
"(",
"x",
",",
"y",
"int",
")",
"{",
"var",
"xpos",
",",
"ypos",
"C",
".",
"int",
"\n\n",
"C",
".",
"glfwGetWindowPos",
"(",
"w",
".",
"data",
",",
"&",
"xpos",
",",
"&",
"ypos",
")",
"\n",
"return",
"int",
"(",
"xpos",
")",
",",
"int",
"(",
"ypos",
")",
"\n",
"}"
] |
//GetPosition returns the position, in screen coordinates, of the upper-left
//corner of the client area of the window.
|
[
"GetPosition",
"returns",
"the",
"position",
"in",
"screen",
"coordinates",
"of",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"client",
"area",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/window.go#L300-L305
|
150,929 |
go-gl/glfw
|
v3.0/glfw/window.go
|
GetSize
|
func (w *Window) GetSize() (width, height int) {
var wi, h C.int
C.glfwGetWindowSize(w.data, &wi, &h)
return int(wi), int(h)
}
|
go
|
func (w *Window) GetSize() (width, height int) {
var wi, h C.int
C.glfwGetWindowSize(w.data, &wi, &h)
return int(wi), int(h)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetSize",
"(",
")",
"(",
"width",
",",
"height",
"int",
")",
"{",
"var",
"wi",
",",
"h",
"C",
".",
"int",
"\n",
"C",
".",
"glfwGetWindowSize",
"(",
"w",
".",
"data",
",",
"&",
"wi",
",",
"&",
"h",
")",
"\n",
"return",
"int",
"(",
"wi",
")",
",",
"int",
"(",
"h",
")",
"\n",
"}"
] |
//GetSize returns the size, in screen coordinates, of the client area of the
//specified window.
|
[
"GetSize",
"returns",
"the",
"size",
"in",
"screen",
"coordinates",
"of",
"the",
"client",
"area",
"of",
"the",
"specified",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/window.go#L328-L332
|
150,930 |
go-gl/glfw
|
v3.0/glfw/window.go
|
GetFramebufferSize
|
func (w *Window) GetFramebufferSize() (width, height int) {
var wi, h C.int
C.glfwGetFramebufferSize(w.data, &wi, &h)
return int(wi), int(h)
}
|
go
|
func (w *Window) GetFramebufferSize() (width, height int) {
var wi, h C.int
C.glfwGetFramebufferSize(w.data, &wi, &h)
return int(wi), int(h)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetFramebufferSize",
"(",
")",
"(",
"width",
",",
"height",
"int",
")",
"{",
"var",
"wi",
",",
"h",
"C",
".",
"int",
"\n",
"C",
".",
"glfwGetFramebufferSize",
"(",
"w",
".",
"data",
",",
"&",
"wi",
",",
"&",
"h",
")",
"\n",
"return",
"int",
"(",
"wi",
")",
",",
"int",
"(",
"h",
")",
"\n",
"}"
] |
//GetFramebufferSize retrieves the size, in pixels, of the framebuffer of the
//specified window.
|
[
"GetFramebufferSize",
"retrieves",
"the",
"size",
"in",
"pixels",
"of",
"the",
"framebuffer",
"of",
"the",
"specified",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/window.go#L351-L355
|
150,931 |
go-gl/glfw
|
v3.0/glfw/window.go
|
GetMonitor
|
func (w *Window) GetMonitor() (*Monitor, error) {
m := C.glfwGetWindowMonitor(w.data)
if m == nil {
return nil, errors.New("Can't get the monitor.")
}
return &Monitor{m}, nil
}
|
go
|
func (w *Window) GetMonitor() (*Monitor, error) {
m := C.glfwGetWindowMonitor(w.data)
if m == nil {
return nil, errors.New("Can't get the monitor.")
}
return &Monitor{m}, nil
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetMonitor",
"(",
")",
"(",
"*",
"Monitor",
",",
"error",
")",
"{",
"m",
":=",
"C",
".",
"glfwGetWindowMonitor",
"(",
"w",
".",
"data",
")",
"\n\n",
"if",
"m",
"==",
"nil",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"return",
"&",
"Monitor",
"{",
"m",
"}",
",",
"nil",
"\n",
"}"
] |
//GetMonitor returns the handle of the monitor that the window is in
//fullscreen on.
|
[
"GetMonitor",
"returns",
"the",
"handle",
"of",
"the",
"monitor",
"that",
"the",
"window",
"is",
"in",
"fullscreen",
"on",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/window.go#L399-L406
|
150,932 |
go-gl/glfw
|
v3.0/glfw/window.go
|
GetAttribute
|
func (w *Window) GetAttribute(attrib Hint) int {
return int(C.glfwGetWindowAttrib(w.data, C.int(attrib)))
}
|
go
|
func (w *Window) GetAttribute(attrib Hint) int {
return int(C.glfwGetWindowAttrib(w.data, C.int(attrib)))
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetAttribute",
"(",
"attrib",
"Hint",
")",
"int",
"{",
"return",
"int",
"(",
"C",
".",
"glfwGetWindowAttrib",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"attrib",
")",
")",
")",
"\n",
"}"
] |
//GetAttribute returns an attribute of the window. There are many attributes,
//some related to the window and others to its context.
|
[
"GetAttribute",
"returns",
"an",
"attribute",
"of",
"the",
"window",
".",
"There",
"are",
"many",
"attributes",
"some",
"related",
"to",
"the",
"window",
"and",
"others",
"to",
"its",
"context",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/window.go#L410-L412
|
150,933 |
go-gl/glfw
|
v3.0/glfw/window.go
|
SetPositionCallback
|
func (w *Window) SetPositionCallback(cbfun func(w *Window, xpos int, ypos int)) {
if cbfun == nil {
C.glfwSetWindowPosCallback(w.data, nil)
} else {
w.fPosHolder = cbfun
C.glfwSetWindowPosCallbackCB(w.data)
}
}
|
go
|
func (w *Window) SetPositionCallback(cbfun func(w *Window, xpos int, ypos int)) {
if cbfun == nil {
C.glfwSetWindowPosCallback(w.data, nil)
} else {
w.fPosHolder = cbfun
C.glfwSetWindowPosCallbackCB(w.data)
}
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetPositionCallback",
"(",
"cbfun",
"func",
"(",
"w",
"*",
"Window",
",",
"xpos",
"int",
",",
"ypos",
"int",
")",
")",
"{",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetWindowPosCallback",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"w",
".",
"fPosHolder",
"=",
"cbfun",
"\n",
"C",
".",
"glfwSetWindowPosCallbackCB",
"(",
"w",
".",
"data",
")",
"\n",
"}",
"\n",
"}"
] |
//SetPositionCallback sets the position callback of the window, which is called
//when the window is moved. The callback is provided with the screen position
//of the upper-left corner of the client area of the window.
|
[
"SetPositionCallback",
"sets",
"the",
"position",
"callback",
"of",
"the",
"window",
"which",
"is",
"called",
"when",
"the",
"window",
"is",
"moved",
".",
"The",
"callback",
"is",
"provided",
"with",
"the",
"screen",
"position",
"of",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"client",
"area",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/window.go#L429-L436
|
150,934 |
go-gl/glfw
|
v3.2/glfw/window.go
|
WindowHint
|
func WindowHint(target Hint, hint int) {
C.glfwWindowHint(C.int(target), C.int(hint))
panicError()
}
|
go
|
func WindowHint(target Hint, hint int) {
C.glfwWindowHint(C.int(target), C.int(hint))
panicError()
}
|
[
"func",
"WindowHint",
"(",
"target",
"Hint",
",",
"hint",
"int",
")",
"{",
"C",
".",
"glfwWindowHint",
"(",
"C",
".",
"int",
"(",
"target",
")",
",",
"C",
".",
"int",
"(",
"hint",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// WindowHint sets hints for the next call to CreateWindow. The hints,
// once set, retain their values until changed by a call to WindowHint or
// DefaultWindowHints, or until the library is terminated with Terminate.
//
// This function may only be called from the main thread.
|
[
"WindowHint",
"sets",
"hints",
"for",
"the",
"next",
"call",
"to",
"CreateWindow",
".",
"The",
"hints",
"once",
"set",
"retain",
"their",
"values",
"until",
"changed",
"by",
"a",
"call",
"to",
"WindowHint",
"or",
"DefaultWindowHints",
"or",
"until",
"the",
"library",
"is",
"terminated",
"with",
"Terminate",
".",
"This",
"function",
"may",
"only",
"be",
"called",
"from",
"the",
"main",
"thread",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L234-L237
|
150,935 |
go-gl/glfw
|
v3.2/glfw/window.go
|
Destroy
|
func (w *Window) Destroy() {
windows.remove(w.data)
C.glfwDestroyWindow(w.data)
panicError()
}
|
go
|
func (w *Window) Destroy() {
windows.remove(w.data)
C.glfwDestroyWindow(w.data)
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"Destroy",
"(",
")",
"{",
"windows",
".",
"remove",
"(",
"w",
".",
"data",
")",
"\n",
"C",
".",
"glfwDestroyWindow",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// Destroy destroys the specified window and its context. On calling this
// function, no further callbacks will be called for that window.
//
// This function may only be called from the main thread.
|
[
"Destroy",
"destroys",
"the",
"specified",
"window",
"and",
"its",
"context",
".",
"On",
"calling",
"this",
"function",
"no",
"further",
"callbacks",
"will",
"be",
"called",
"for",
"that",
"window",
".",
"This",
"function",
"may",
"only",
"be",
"called",
"from",
"the",
"main",
"thread",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L301-L305
|
150,936 |
go-gl/glfw
|
v3.2/glfw/window.go
|
ShouldClose
|
func (w *Window) ShouldClose() bool {
ret := glfwbool(C.glfwWindowShouldClose(w.data))
panicError()
return ret
}
|
go
|
func (w *Window) ShouldClose() bool {
ret := glfwbool(C.glfwWindowShouldClose(w.data))
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"ShouldClose",
"(",
")",
"bool",
"{",
"ret",
":=",
"glfwbool",
"(",
"C",
".",
"glfwWindowShouldClose",
"(",
"w",
".",
"data",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// ShouldClose reports the value of the close flag of the specified window.
|
[
"ShouldClose",
"reports",
"the",
"value",
"of",
"the",
"close",
"flag",
"of",
"the",
"specified",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L308-L312
|
150,937 |
go-gl/glfw
|
v3.2/glfw/window.go
|
SetShouldClose
|
func (w *Window) SetShouldClose(value bool) {
if !value {
C.glfwSetWindowShouldClose(w.data, C.int(False))
} else {
C.glfwSetWindowShouldClose(w.data, C.int(True))
}
panicError()
}
|
go
|
func (w *Window) SetShouldClose(value bool) {
if !value {
C.glfwSetWindowShouldClose(w.data, C.int(False))
} else {
C.glfwSetWindowShouldClose(w.data, C.int(True))
}
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetShouldClose",
"(",
"value",
"bool",
")",
"{",
"if",
"!",
"value",
"{",
"C",
".",
"glfwSetWindowShouldClose",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"False",
")",
")",
"\n",
"}",
"else",
"{",
"C",
".",
"glfwSetWindowShouldClose",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"True",
")",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetShouldClose sets the value of the close flag of the window. This can be
// used to override the user's attempt to close the window, or to signal that it
// should be closed.
|
[
"SetShouldClose",
"sets",
"the",
"value",
"of",
"the",
"close",
"flag",
"of",
"the",
"window",
".",
"This",
"can",
"be",
"used",
"to",
"override",
"the",
"user",
"s",
"attempt",
"to",
"close",
"the",
"window",
"or",
"to",
"signal",
"that",
"it",
"should",
"be",
"closed",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L317-L324
|
150,938 |
go-gl/glfw
|
v3.2/glfw/window.go
|
GetPos
|
func (w *Window) GetPos() (x, y int) {
var xpos, ypos C.int
C.glfwGetWindowPos(w.data, &xpos, &ypos)
panicError()
return int(xpos), int(ypos)
}
|
go
|
func (w *Window) GetPos() (x, y int) {
var xpos, ypos C.int
C.glfwGetWindowPos(w.data, &xpos, &ypos)
panicError()
return int(xpos), int(ypos)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetPos",
"(",
")",
"(",
"x",
",",
"y",
"int",
")",
"{",
"var",
"xpos",
",",
"ypos",
"C",
".",
"int",
"\n",
"C",
".",
"glfwGetWindowPos",
"(",
"w",
".",
"data",
",",
"&",
"xpos",
",",
"&",
"ypos",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"int",
"(",
"xpos",
")",
",",
"int",
"(",
"ypos",
")",
"\n",
"}"
] |
// GetPos returns the position, in screen coordinates, of the upper-left
// corner of the client area of the window.
|
[
"GetPos",
"returns",
"the",
"position",
"in",
"screen",
"coordinates",
"of",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"client",
"area",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L389-L394
|
150,939 |
go-gl/glfw
|
v3.2/glfw/window.go
|
SetSizeLimits
|
func (w *Window) SetSizeLimits(minw, minh, maxw, maxh int) {
C.glfwSetWindowSizeLimits(w.data, C.int(minw), C.int(minh), C.int(maxw), C.int(maxh))
panicError()
}
|
go
|
func (w *Window) SetSizeLimits(minw, minh, maxw, maxh int) {
C.glfwSetWindowSizeLimits(w.data, C.int(minw), C.int(minh), C.int(maxw), C.int(maxh))
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetSizeLimits",
"(",
"minw",
",",
"minh",
",",
"maxw",
",",
"maxh",
"int",
")",
"{",
"C",
".",
"glfwSetWindowSizeLimits",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"minw",
")",
",",
"C",
".",
"int",
"(",
"minh",
")",
",",
"C",
".",
"int",
"(",
"maxw",
")",
",",
"C",
".",
"int",
"(",
"maxh",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetSizeLimits sets the size limits of the client area of the specified window.
// If the window is full screen or not resizable, this function does nothing.
//
// The size limits are applied immediately and may cause the window to be resized.
|
[
"SetSizeLimits",
"sets",
"the",
"size",
"limits",
"of",
"the",
"client",
"area",
"of",
"the",
"specified",
"window",
".",
"If",
"the",
"window",
"is",
"full",
"screen",
"or",
"not",
"resizable",
"this",
"function",
"does",
"nothing",
".",
"The",
"size",
"limits",
"are",
"applied",
"immediately",
"and",
"may",
"cause",
"the",
"window",
"to",
"be",
"resized",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L443-L446
|
150,940 |
go-gl/glfw
|
v3.2/glfw/window.go
|
GetFrameSize
|
func (w *Window) GetFrameSize() (left, top, right, bottom int) {
var l, t, r, b C.int
C.glfwGetWindowFrameSize(w.data, &l, &t, &r, &b)
panicError()
return int(l), int(t), int(r), int(b)
}
|
go
|
func (w *Window) GetFrameSize() (left, top, right, bottom int) {
var l, t, r, b C.int
C.glfwGetWindowFrameSize(w.data, &l, &t, &r, &b)
panicError()
return int(l), int(t), int(r), int(b)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetFrameSize",
"(",
")",
"(",
"left",
",",
"top",
",",
"right",
",",
"bottom",
"int",
")",
"{",
"var",
"l",
",",
"t",
",",
"r",
",",
"b",
"C",
".",
"int",
"\n",
"C",
".",
"glfwGetWindowFrameSize",
"(",
"w",
".",
"data",
",",
"&",
"l",
",",
"&",
"t",
",",
"&",
"r",
",",
"&",
"b",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"int",
"(",
"l",
")",
",",
"int",
"(",
"t",
")",
",",
"int",
"(",
"r",
")",
",",
"int",
"(",
"b",
")",
"\n",
"}"
] |
// GetFrameSize retrieves the size, in screen coordinates, of each edge of the frame
// of the specified window. This size includes the title bar, if the window has one.
// The size of the frame may vary depending on the window-related hints used to create it.
//
// Because this function retrieves the size of each window frame edge and not the offset
// along a particular coordinate axis, the retrieved values will always be zero or positive.
|
[
"GetFrameSize",
"retrieves",
"the",
"size",
"in",
"screen",
"coordinates",
"of",
"each",
"edge",
"of",
"the",
"frame",
"of",
"the",
"specified",
"window",
".",
"This",
"size",
"includes",
"the",
"title",
"bar",
"if",
"the",
"window",
"has",
"one",
".",
"The",
"size",
"of",
"the",
"frame",
"may",
"vary",
"depending",
"on",
"the",
"window",
"-",
"related",
"hints",
"used",
"to",
"create",
"it",
".",
"Because",
"this",
"function",
"retrieves",
"the",
"size",
"of",
"each",
"window",
"frame",
"edge",
"and",
"not",
"the",
"offset",
"along",
"a",
"particular",
"coordinate",
"axis",
"the",
"retrieved",
"values",
"will",
"always",
"be",
"zero",
"or",
"positive",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L477-L482
|
150,941 |
go-gl/glfw
|
v3.2/glfw/window.go
|
Focus
|
func (w *Window) Focus() error {
C.glfwFocusWindow(w.data)
return acceptError(APIUnavailable)
}
|
go
|
func (w *Window) Focus() error {
C.glfwFocusWindow(w.data)
return acceptError(APIUnavailable)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"Focus",
"(",
")",
"error",
"{",
"C",
".",
"glfwFocusWindow",
"(",
"w",
".",
"data",
")",
"\n",
"return",
"acceptError",
"(",
"APIUnavailable",
")",
"\n",
"}"
] |
// Focus brings the specified window to front and sets input focus.
// The window should already be visible and not iconified.
//
// By default, both windowed and full screen mode windows are focused when initially created.
// Set the glfw.Focused to disable this behavior.
//
// Do not use this function to steal focus from other applications unless you are certain that
// is what the user wants. Focus stealing can be extremely disruptive.
|
[
"Focus",
"brings",
"the",
"specified",
"window",
"to",
"front",
"and",
"sets",
"input",
"focus",
".",
"The",
"window",
"should",
"already",
"be",
"visible",
"and",
"not",
"iconified",
".",
"By",
"default",
"both",
"windowed",
"and",
"full",
"screen",
"mode",
"windows",
"are",
"focused",
"when",
"initially",
"created",
".",
"Set",
"the",
"glfw",
".",
"Focused",
"to",
"disable",
"this",
"behavior",
".",
"Do",
"not",
"use",
"this",
"function",
"to",
"steal",
"focus",
"from",
"other",
"applications",
"unless",
"you",
"are",
"certain",
"that",
"is",
"what",
"the",
"user",
"wants",
".",
"Focus",
"stealing",
"can",
"be",
"extremely",
"disruptive",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L492-L495
|
150,942 |
go-gl/glfw
|
v3.2/glfw/window.go
|
Maximize
|
func (w *Window) Maximize() error {
C.glfwMaximizeWindow(w.data)
return acceptError(APIUnavailable)
}
|
go
|
func (w *Window) Maximize() error {
C.glfwMaximizeWindow(w.data)
return acceptError(APIUnavailable)
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"Maximize",
"(",
")",
"error",
"{",
"C",
".",
"glfwMaximizeWindow",
"(",
"w",
".",
"data",
")",
"\n",
"return",
"acceptError",
"(",
"APIUnavailable",
")",
"\n",
"}"
] |
// Maximize maximizes the specified window if it was previously not maximized.
// If the window is already maximized, this function does nothing.
//
// If the specified window is a full screen window, this function does nothing.
|
[
"Maximize",
"maximizes",
"the",
"specified",
"window",
"if",
"it",
"was",
"previously",
"not",
"maximized",
".",
"If",
"the",
"window",
"is",
"already",
"maximized",
"this",
"function",
"does",
"nothing",
".",
"If",
"the",
"specified",
"window",
"is",
"a",
"full",
"screen",
"window",
"this",
"function",
"does",
"nothing",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L512-L515
|
150,943 |
go-gl/glfw
|
v3.2/glfw/window.go
|
GetMonitor
|
func (w *Window) GetMonitor() *Monitor {
m := C.glfwGetWindowMonitor(w.data)
panicError()
if m == nil {
return nil
}
return &Monitor{m}
}
|
go
|
func (w *Window) GetMonitor() *Monitor {
m := C.glfwGetWindowMonitor(w.data)
panicError()
if m == nil {
return nil
}
return &Monitor{m}
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetMonitor",
"(",
")",
"*",
"Monitor",
"{",
"m",
":=",
"C",
".",
"glfwGetWindowMonitor",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"if",
"m",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"&",
"Monitor",
"{",
"m",
"}",
"\n",
"}"
] |
// GetMonitor returns the handle of the monitor that the window is in
// fullscreen on.
//
// Returns nil if the window is in windowed mode.
|
[
"GetMonitor",
"returns",
"the",
"handle",
"of",
"the",
"monitor",
"that",
"the",
"window",
"is",
"in",
"fullscreen",
"on",
".",
"Returns",
"nil",
"if",
"the",
"window",
"is",
"in",
"windowed",
"mode",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L550-L557
|
150,944 |
go-gl/glfw
|
v3.2/glfw/window.go
|
SetMonitor
|
func (w *Window) SetMonitor(monitor *Monitor, xpos, ypos, width, height, refreshRate int) {
var m *C.GLFWmonitor
if monitor == nil {
m = nil
} else {
m = monitor.data
}
C.glfwSetWindowMonitor(w.data, m, C.int(xpos), C.int(ypos), C.int(width), C.int(height), C.int(refreshRate))
panicError()
}
|
go
|
func (w *Window) SetMonitor(monitor *Monitor, xpos, ypos, width, height, refreshRate int) {
var m *C.GLFWmonitor
if monitor == nil {
m = nil
} else {
m = monitor.data
}
C.glfwSetWindowMonitor(w.data, m, C.int(xpos), C.int(ypos), C.int(width), C.int(height), C.int(refreshRate))
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetMonitor",
"(",
"monitor",
"*",
"Monitor",
",",
"xpos",
",",
"ypos",
",",
"width",
",",
"height",
",",
"refreshRate",
"int",
")",
"{",
"var",
"m",
"*",
"C",
".",
"GLFWmonitor",
"\n",
"if",
"monitor",
"==",
"nil",
"{",
"m",
"=",
"nil",
"\n",
"}",
"else",
"{",
"m",
"=",
"monitor",
".",
"data",
"\n",
"}",
"\n",
"C",
".",
"glfwSetWindowMonitor",
"(",
"w",
".",
"data",
",",
"m",
",",
"C",
".",
"int",
"(",
"xpos",
")",
",",
"C",
".",
"int",
"(",
"ypos",
")",
",",
"C",
".",
"int",
"(",
"width",
")",
",",
"C",
".",
"int",
"(",
"height",
")",
",",
"C",
".",
"int",
"(",
"refreshRate",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetMonitor sets the monitor that the window uses for full screen mode or,
// if the monitor is NULL, makes it windowed mode.
//
// When setting a monitor, this function updates the width, height and refresh
// rate of the desired video mode and switches to the video mode closest to it.
// The window position is ignored when setting a monitor.
//
// When the monitor is NULL, the position, width and height are used to place
// the window client area. The refresh rate is ignored when no monitor is specified.
// If you only wish to update the resolution of a full screen window or the size of
// a windowed mode window, see window.SetSize.
//
// When a window transitions from full screen to windowed mode, this function
// restores any previous window settings such as whether it is decorated, floating,
// resizable, has size or aspect ratio limits, etc..
|
[
"SetMonitor",
"sets",
"the",
"monitor",
"that",
"the",
"window",
"uses",
"for",
"full",
"screen",
"mode",
"or",
"if",
"the",
"monitor",
"is",
"NULL",
"makes",
"it",
"windowed",
"mode",
".",
"When",
"setting",
"a",
"monitor",
"this",
"function",
"updates",
"the",
"width",
"height",
"and",
"refresh",
"rate",
"of",
"the",
"desired",
"video",
"mode",
"and",
"switches",
"to",
"the",
"video",
"mode",
"closest",
"to",
"it",
".",
"The",
"window",
"position",
"is",
"ignored",
"when",
"setting",
"a",
"monitor",
".",
"When",
"the",
"monitor",
"is",
"NULL",
"the",
"position",
"width",
"and",
"height",
"are",
"used",
"to",
"place",
"the",
"window",
"client",
"area",
".",
"The",
"refresh",
"rate",
"is",
"ignored",
"when",
"no",
"monitor",
"is",
"specified",
".",
"If",
"you",
"only",
"wish",
"to",
"update",
"the",
"resolution",
"of",
"a",
"full",
"screen",
"window",
"or",
"the",
"size",
"of",
"a",
"windowed",
"mode",
"window",
"see",
"window",
".",
"SetSize",
".",
"When",
"a",
"window",
"transitions",
"from",
"full",
"screen",
"to",
"windowed",
"mode",
"this",
"function",
"restores",
"any",
"previous",
"window",
"settings",
"such",
"as",
"whether",
"it",
"is",
"decorated",
"floating",
"resizable",
"has",
"size",
"or",
"aspect",
"ratio",
"limits",
"etc",
".."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L574-L583
|
150,945 |
go-gl/glfw
|
v3.2/glfw/window.go
|
GetAttrib
|
func (w *Window) GetAttrib(attrib Hint) int {
ret := int(C.glfwGetWindowAttrib(w.data, C.int(attrib)))
panicError()
return ret
}
|
go
|
func (w *Window) GetAttrib(attrib Hint) int {
ret := int(C.glfwGetWindowAttrib(w.data, C.int(attrib)))
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetAttrib",
"(",
"attrib",
"Hint",
")",
"int",
"{",
"ret",
":=",
"int",
"(",
"C",
".",
"glfwGetWindowAttrib",
"(",
"w",
".",
"data",
",",
"C",
".",
"int",
"(",
"attrib",
")",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetAttrib returns an attribute of the window. There are many attributes,
// some related to the window and others to its context.
|
[
"GetAttrib",
"returns",
"an",
"attribute",
"of",
"the",
"window",
".",
"There",
"are",
"many",
"attributes",
"some",
"related",
"to",
"the",
"window",
"and",
"others",
"to",
"its",
"context",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L587-L591
|
150,946 |
go-gl/glfw
|
v3.2/glfw/window.go
|
SetUserPointer
|
func (w *Window) SetUserPointer(pointer unsafe.Pointer) {
C.glfwSetWindowUserPointer(w.data, pointer)
panicError()
}
|
go
|
func (w *Window) SetUserPointer(pointer unsafe.Pointer) {
C.glfwSetWindowUserPointer(w.data, pointer)
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetUserPointer",
"(",
"pointer",
"unsafe",
".",
"Pointer",
")",
"{",
"C",
".",
"glfwSetWindowUserPointer",
"(",
"w",
".",
"data",
",",
"pointer",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetUserPointer sets the user-defined pointer of the window. The current value
// is retained until the window is destroyed. The initial value is nil.
|
[
"SetUserPointer",
"sets",
"the",
"user",
"-",
"defined",
"pointer",
"of",
"the",
"window",
".",
"The",
"current",
"value",
"is",
"retained",
"until",
"the",
"window",
"is",
"destroyed",
".",
"The",
"initial",
"value",
"is",
"nil",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L595-L598
|
150,947 |
go-gl/glfw
|
v3.2/glfw/window.go
|
GetUserPointer
|
func (w *Window) GetUserPointer() unsafe.Pointer {
ret := C.glfwGetWindowUserPointer(w.data)
panicError()
return ret
}
|
go
|
func (w *Window) GetUserPointer() unsafe.Pointer {
ret := C.glfwGetWindowUserPointer(w.data)
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetUserPointer",
"(",
")",
"unsafe",
".",
"Pointer",
"{",
"ret",
":=",
"C",
".",
"glfwGetWindowUserPointer",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetUserPointer returns the current value of the user-defined pointer of the
// window. The initial value is nil.
|
[
"GetUserPointer",
"returns",
"the",
"current",
"value",
"of",
"the",
"user",
"-",
"defined",
"pointer",
"of",
"the",
"window",
".",
"The",
"initial",
"value",
"is",
"nil",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L602-L606
|
150,948 |
go-gl/glfw
|
v3.2/glfw/window.go
|
SetPosCallback
|
func (w *Window) SetPosCallback(cbfun PosCallback) (previous PosCallback) {
previous = w.fPosHolder
w.fPosHolder = cbfun
if cbfun == nil {
C.glfwSetWindowPosCallback(w.data, nil)
} else {
C.glfwSetWindowPosCallbackCB(w.data)
}
panicError()
return previous
}
|
go
|
func (w *Window) SetPosCallback(cbfun PosCallback) (previous PosCallback) {
previous = w.fPosHolder
w.fPosHolder = cbfun
if cbfun == nil {
C.glfwSetWindowPosCallback(w.data, nil)
} else {
C.glfwSetWindowPosCallbackCB(w.data)
}
panicError()
return previous
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetPosCallback",
"(",
"cbfun",
"PosCallback",
")",
"(",
"previous",
"PosCallback",
")",
"{",
"previous",
"=",
"w",
".",
"fPosHolder",
"\n",
"w",
".",
"fPosHolder",
"=",
"cbfun",
"\n",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetWindowPosCallback",
"(",
"w",
".",
"data",
",",
"nil",
")",
"\n",
"}",
"else",
"{",
"C",
".",
"glfwSetWindowPosCallbackCB",
"(",
"w",
".",
"data",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"previous",
"\n",
"}"
] |
// SetPosCallback sets the position callback of the window, which is called
// when the window is moved. The callback is provided with the screen position
// of the upper-left corner of the client area of the window.
|
[
"SetPosCallback",
"sets",
"the",
"position",
"callback",
"of",
"the",
"window",
"which",
"is",
"called",
"when",
"the",
"window",
"is",
"moved",
".",
"The",
"callback",
"is",
"provided",
"with",
"the",
"screen",
"position",
"of",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"client",
"area",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L614-L624
|
150,949 |
go-gl/glfw
|
v3.2/glfw/window.go
|
SetClipboardString
|
func (w *Window) SetClipboardString(str string) {
cp := C.CString(str)
defer C.free(unsafe.Pointer(cp))
C.glfwSetClipboardString(w.data, cp)
panicError()
}
|
go
|
func (w *Window) SetClipboardString(str string) {
cp := C.CString(str)
defer C.free(unsafe.Pointer(cp))
C.glfwSetClipboardString(w.data, cp)
panicError()
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"SetClipboardString",
"(",
"str",
"string",
")",
"{",
"cp",
":=",
"C",
".",
"CString",
"(",
"str",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cp",
")",
")",
"\n",
"C",
".",
"glfwSetClipboardString",
"(",
"w",
".",
"data",
",",
"cp",
")",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetClipboardString sets the system clipboard to the specified UTF-8 encoded
// string.
//
// This function may only be called from the main thread.
|
[
"SetClipboardString",
"sets",
"the",
"system",
"clipboard",
"to",
"the",
"specified",
"UTF",
"-",
"8",
"encoded",
"string",
".",
"This",
"function",
"may",
"only",
"be",
"called",
"from",
"the",
"main",
"thread",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L749-L754
|
150,950 |
go-gl/glfw
|
v3.2/glfw/window.go
|
GetClipboardString
|
func (w *Window) GetClipboardString() (string, error) {
cs := C.glfwGetClipboardString(w.data)
if cs == nil {
return "", acceptError(FormatUnavailable)
}
return C.GoString(cs), nil
}
|
go
|
func (w *Window) GetClipboardString() (string, error) {
cs := C.glfwGetClipboardString(w.data)
if cs == nil {
return "", acceptError(FormatUnavailable)
}
return C.GoString(cs), nil
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetClipboardString",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"cs",
":=",
"C",
".",
"glfwGetClipboardString",
"(",
"w",
".",
"data",
")",
"\n",
"if",
"cs",
"==",
"nil",
"{",
"return",
"\"",
"\"",
",",
"acceptError",
"(",
"FormatUnavailable",
")",
"\n",
"}",
"\n",
"return",
"C",
".",
"GoString",
"(",
"cs",
")",
",",
"nil",
"\n",
"}"
] |
// GetClipboardString returns the contents of the system clipboard, if it
// contains or is convertible to a UTF-8 encoded string.
//
// This function may only be called from the main thread.
|
[
"GetClipboardString",
"returns",
"the",
"contents",
"of",
"the",
"system",
"clipboard",
"if",
"it",
"contains",
"or",
"is",
"convertible",
"to",
"a",
"UTF",
"-",
"8",
"encoded",
"string",
".",
"This",
"function",
"may",
"only",
"be",
"called",
"from",
"the",
"main",
"thread",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/window.go#L760-L766
|
150,951 |
go-gl/glfw
|
v3.2/glfw/native_darwin.go
|
GetCocoaMonitor
|
func (m *Monitor) GetCocoaMonitor() uintptr {
ret := uintptr(C.glfwGetCocoaMonitor(m.data))
panicError()
return ret
}
|
go
|
func (m *Monitor) GetCocoaMonitor() uintptr {
ret := uintptr(C.glfwGetCocoaMonitor(m.data))
panicError()
return ret
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetCocoaMonitor",
"(",
")",
"uintptr",
"{",
"ret",
":=",
"uintptr",
"(",
"C",
".",
"glfwGetCocoaMonitor",
"(",
"m",
".",
"data",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetCocoaMonitor returns the CGDirectDisplayID of the monitor.
|
[
"GetCocoaMonitor",
"returns",
"the",
"CGDirectDisplayID",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_darwin.go#L21-L25
|
150,952 |
go-gl/glfw
|
v3.2/glfw/native_darwin.go
|
GetCocoaWindow
|
func (w *Window) GetCocoaWindow() uintptr {
ret := uintptr(C.workaround_glfwGetCocoaWindow(w.data))
panicError()
return ret
}
|
go
|
func (w *Window) GetCocoaWindow() uintptr {
ret := uintptr(C.workaround_glfwGetCocoaWindow(w.data))
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetCocoaWindow",
"(",
")",
"uintptr",
"{",
"ret",
":=",
"uintptr",
"(",
"C",
".",
"workaround_glfwGetCocoaWindow",
"(",
"w",
".",
"data",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetCocoaWindow returns the NSWindow of the window.
|
[
"GetCocoaWindow",
"returns",
"the",
"NSWindow",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_darwin.go#L28-L32
|
150,953 |
go-gl/glfw
|
v3.2/glfw/native_darwin.go
|
GetNSGLContext
|
func (w *Window) GetNSGLContext() uintptr {
ret := uintptr(C.workaround_glfwGetNSGLContext(w.data))
panicError()
return ret
}
|
go
|
func (w *Window) GetNSGLContext() uintptr {
ret := uintptr(C.workaround_glfwGetNSGLContext(w.data))
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetNSGLContext",
"(",
")",
"uintptr",
"{",
"ret",
":=",
"uintptr",
"(",
"C",
".",
"workaround_glfwGetNSGLContext",
"(",
"w",
".",
"data",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetNSGLContext returns the NSOpenGLContext of the window.
|
[
"GetNSGLContext",
"returns",
"the",
"NSOpenGLContext",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_darwin.go#L35-L39
|
150,954 |
go-gl/glfw
|
v3.2/glfw/native_linbsd.go
|
GetX11Adapter
|
func (m *Monitor) GetX11Adapter() C.RRCrtc {
ret := C.glfwGetX11Adapter(m.data)
panicError()
return ret
}
|
go
|
func (m *Monitor) GetX11Adapter() C.RRCrtc {
ret := C.glfwGetX11Adapter(m.data)
panicError()
return ret
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetX11Adapter",
"(",
")",
"C",
".",
"RRCrtc",
"{",
"ret",
":=",
"C",
".",
"glfwGetX11Adapter",
"(",
"m",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetX11Adapter returns the RRCrtc of the monitor.
|
[
"GetX11Adapter",
"returns",
"the",
"RRCrtc",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_linbsd.go#L19-L23
|
150,955 |
go-gl/glfw
|
v3.2/glfw/native_linbsd.go
|
GetX11Monitor
|
func (m *Monitor) GetX11Monitor() C.RROutput {
ret := C.glfwGetX11Monitor(m.data)
panicError()
return ret
}
|
go
|
func (m *Monitor) GetX11Monitor() C.RROutput {
ret := C.glfwGetX11Monitor(m.data)
panicError()
return ret
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetX11Monitor",
"(",
")",
"C",
".",
"RROutput",
"{",
"ret",
":=",
"C",
".",
"glfwGetX11Monitor",
"(",
"m",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetX11Monitor returns the RROutput of the monitor.
|
[
"GetX11Monitor",
"returns",
"the",
"RROutput",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_linbsd.go#L26-L30
|
150,956 |
go-gl/glfw
|
v3.2/glfw/native_linbsd.go
|
GetX11Window
|
func (w *Window) GetX11Window() C.Window {
ret := C.glfwGetX11Window(w.data)
panicError()
return ret
}
|
go
|
func (w *Window) GetX11Window() C.Window {
ret := C.glfwGetX11Window(w.data)
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetX11Window",
"(",
")",
"C",
".",
"Window",
"{",
"ret",
":=",
"C",
".",
"glfwGetX11Window",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetX11Window returns the Window of the window.
|
[
"GetX11Window",
"returns",
"the",
"Window",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_linbsd.go#L33-L37
|
150,957 |
go-gl/glfw
|
v3.2/glfw/native_linbsd.go
|
GetGLXContext
|
func (w *Window) GetGLXContext() C.GLXContext {
ret := C.glfwGetGLXContext(w.data)
panicError()
return ret
}
|
go
|
func (w *Window) GetGLXContext() C.GLXContext {
ret := C.glfwGetGLXContext(w.data)
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetGLXContext",
"(",
")",
"C",
".",
"GLXContext",
"{",
"ret",
":=",
"C",
".",
"glfwGetGLXContext",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetGLXContext returns the GLXContext of the window.
|
[
"GetGLXContext",
"returns",
"the",
"GLXContext",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_linbsd.go#L40-L44
|
150,958 |
go-gl/glfw
|
v3.2/glfw/native_linbsd.go
|
GetGLXWindow
|
func (w *Window) GetGLXWindow() C.GLXWindow {
ret := C.glfwGetGLXWindow(w.data)
panicError()
return ret
}
|
go
|
func (w *Window) GetGLXWindow() C.GLXWindow {
ret := C.glfwGetGLXWindow(w.data)
panicError()
return ret
}
|
[
"func",
"(",
"w",
"*",
"Window",
")",
"GetGLXWindow",
"(",
")",
"C",
".",
"GLXWindow",
"{",
"ret",
":=",
"C",
".",
"glfwGetGLXWindow",
"(",
"w",
".",
"data",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetGLXWindow returns the GLXWindow of the window.
|
[
"GetGLXWindow",
"returns",
"the",
"GLXWindow",
"of",
"the",
"window",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/native_linbsd.go#L47-L51
|
150,959 |
go-gl/glfw
|
v3.0/glfw/error.go
|
SetErrorCallback
|
func SetErrorCallback(cbfun func(code ErrorCode, desc string)) {
if cbfun == nil {
C.glfwSetErrorCallback(nil)
} else {
fErrorHolder = cbfun
C.glfwSetErrorCallbackCB()
}
}
|
go
|
func SetErrorCallback(cbfun func(code ErrorCode, desc string)) {
if cbfun == nil {
C.glfwSetErrorCallback(nil)
} else {
fErrorHolder = cbfun
C.glfwSetErrorCallbackCB()
}
}
|
[
"func",
"SetErrorCallback",
"(",
"cbfun",
"func",
"(",
"code",
"ErrorCode",
",",
"desc",
"string",
")",
")",
"{",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetErrorCallback",
"(",
"nil",
")",
"\n",
"}",
"else",
"{",
"fErrorHolder",
"=",
"cbfun",
"\n",
"C",
".",
"glfwSetErrorCallbackCB",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
//SetErrorCallback sets the error callback, which is called with an error code
//and a human-readable description each time a GLFW error occurs.
//
//This function may be called before Init.
|
[
"SetErrorCallback",
"sets",
"the",
"error",
"callback",
"which",
"is",
"called",
"with",
"an",
"error",
"code",
"and",
"a",
"human",
"-",
"readable",
"description",
"each",
"time",
"a",
"GLFW",
"error",
"occurs",
".",
"This",
"function",
"may",
"be",
"called",
"before",
"Init",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.0/glfw/error.go#L35-L42
|
150,960 |
go-gl/glfw
|
v3.2/glfw/context.go
|
ExtensionSupported
|
func ExtensionSupported(extension string) bool {
e := C.CString(extension)
defer C.free(unsafe.Pointer(e))
ret := glfwbool(C.glfwExtensionSupported(e))
panicError()
return ret
}
|
go
|
func ExtensionSupported(extension string) bool {
e := C.CString(extension)
defer C.free(unsafe.Pointer(e))
ret := glfwbool(C.glfwExtensionSupported(e))
panicError()
return ret
}
|
[
"func",
"ExtensionSupported",
"(",
"extension",
"string",
")",
"bool",
"{",
"e",
":=",
"C",
".",
"CString",
"(",
"extension",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"e",
")",
")",
"\n",
"ret",
":=",
"glfwbool",
"(",
"C",
".",
"glfwExtensionSupported",
"(",
"e",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// ExtensionSupported reports whether the specified OpenGL or context creation
// API extension is supported by the current context. For example, on Windows
// both the OpenGL and WGL extension strings are checked.
//
// As this functions searches one or more extension strings on each call, it is
// recommended that you cache its results if it's going to be used frequently.
// The extension strings will not change during the lifetime of a context, so
// there is no danger in doing this.
|
[
"ExtensionSupported",
"reports",
"whether",
"the",
"specified",
"OpenGL",
"or",
"context",
"creation",
"API",
"extension",
"is",
"supported",
"by",
"the",
"current",
"context",
".",
"For",
"example",
"on",
"Windows",
"both",
"the",
"OpenGL",
"and",
"WGL",
"extension",
"strings",
"are",
"checked",
".",
"As",
"this",
"functions",
"searches",
"one",
"or",
"more",
"extension",
"strings",
"on",
"each",
"call",
"it",
"is",
"recommended",
"that",
"you",
"cache",
"its",
"results",
"if",
"it",
"s",
"going",
"to",
"be",
"used",
"frequently",
".",
"The",
"extension",
"strings",
"will",
"not",
"change",
"during",
"the",
"lifetime",
"of",
"a",
"context",
"so",
"there",
"is",
"no",
"danger",
"in",
"doing",
"this",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/context.go#L72-L78
|
150,961 |
go-gl/glfw
|
v3.2/glfw/context.go
|
GetProcAddress
|
func GetProcAddress(procname string) unsafe.Pointer {
p := C.CString(procname)
defer C.free(unsafe.Pointer(p))
ret := unsafe.Pointer(C.glfwGetProcAddress(p))
panicError()
return ret
}
|
go
|
func GetProcAddress(procname string) unsafe.Pointer {
p := C.CString(procname)
defer C.free(unsafe.Pointer(p))
ret := unsafe.Pointer(C.glfwGetProcAddress(p))
panicError()
return ret
}
|
[
"func",
"GetProcAddress",
"(",
"procname",
"string",
")",
"unsafe",
".",
"Pointer",
"{",
"p",
":=",
"C",
".",
"CString",
"(",
"procname",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"p",
")",
")",
"\n",
"ret",
":=",
"unsafe",
".",
"Pointer",
"(",
"C",
".",
"glfwGetProcAddress",
"(",
"p",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"ret",
"\n",
"}"
] |
// GetProcAddress returns the address of the specified OpenGL or OpenGL ES core
// or extension function, if it is supported by the current context.
//
// A context must be current on the calling thread. Calling this function
// without a current context will cause a GLFW_NO_CURRENT_CONTEXT error.
//
// This function is used to provide GL proc resolving capabilities to an
// external C library.
|
[
"GetProcAddress",
"returns",
"the",
"address",
"of",
"the",
"specified",
"OpenGL",
"or",
"OpenGL",
"ES",
"core",
"or",
"extension",
"function",
"if",
"it",
"is",
"supported",
"by",
"the",
"current",
"context",
".",
"A",
"context",
"must",
"be",
"current",
"on",
"the",
"calling",
"thread",
".",
"Calling",
"this",
"function",
"without",
"a",
"current",
"context",
"will",
"cause",
"a",
"GLFW_NO_CURRENT_CONTEXT",
"error",
".",
"This",
"function",
"is",
"used",
"to",
"provide",
"GL",
"proc",
"resolving",
"capabilities",
"to",
"an",
"external",
"C",
"library",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/context.go#L88-L94
|
150,962 |
go-gl/glfw
|
v3.1/glfw/input.go
|
CreateCursor
|
func CreateCursor(img image.Image, xhot, yhot int) *Cursor {
var img_c C.GLFWimage
var pixels []uint8
b := img.Bounds()
switch img := img.(type) {
case *image.RGBA:
pixels = img.Pix
default:
m := image.NewRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
draw.Draw(m, m.Bounds(), img, b.Min, draw.Src)
pixels = m.Pix
}
pix, free := bytes(pixels)
img_c.width = C.int(b.Dx())
img_c.height = C.int(b.Dy())
img_c.pixels = (*C.uchar)(pix)
c := C.glfwCreateCursor(&img_c, C.int(xhot), C.int(yhot))
free()
panicError()
return &Cursor{c}
}
|
go
|
func CreateCursor(img image.Image, xhot, yhot int) *Cursor {
var img_c C.GLFWimage
var pixels []uint8
b := img.Bounds()
switch img := img.(type) {
case *image.RGBA:
pixels = img.Pix
default:
m := image.NewRGBA(image.Rect(0, 0, b.Dx(), b.Dy()))
draw.Draw(m, m.Bounds(), img, b.Min, draw.Src)
pixels = m.Pix
}
pix, free := bytes(pixels)
img_c.width = C.int(b.Dx())
img_c.height = C.int(b.Dy())
img_c.pixels = (*C.uchar)(pix)
c := C.glfwCreateCursor(&img_c, C.int(xhot), C.int(yhot))
free()
panicError()
return &Cursor{c}
}
|
[
"func",
"CreateCursor",
"(",
"img",
"image",
".",
"Image",
",",
"xhot",
",",
"yhot",
"int",
")",
"*",
"Cursor",
"{",
"var",
"img_c",
"C",
".",
"GLFWimage",
"\n",
"var",
"pixels",
"[",
"]",
"uint8",
"\n",
"b",
":=",
"img",
".",
"Bounds",
"(",
")",
"\n\n",
"switch",
"img",
":=",
"img",
".",
"(",
"type",
")",
"{",
"case",
"*",
"image",
".",
"RGBA",
":",
"pixels",
"=",
"img",
".",
"Pix",
"\n",
"default",
":",
"m",
":=",
"image",
".",
"NewRGBA",
"(",
"image",
".",
"Rect",
"(",
"0",
",",
"0",
",",
"b",
".",
"Dx",
"(",
")",
",",
"b",
".",
"Dy",
"(",
")",
")",
")",
"\n",
"draw",
".",
"Draw",
"(",
"m",
",",
"m",
".",
"Bounds",
"(",
")",
",",
"img",
",",
"b",
".",
"Min",
",",
"draw",
".",
"Src",
")",
"\n",
"pixels",
"=",
"m",
".",
"Pix",
"\n",
"}",
"\n\n",
"pix",
",",
"free",
":=",
"bytes",
"(",
"pixels",
")",
"\n\n",
"img_c",
".",
"width",
"=",
"C",
".",
"int",
"(",
"b",
".",
"Dx",
"(",
")",
")",
"\n",
"img_c",
".",
"height",
"=",
"C",
".",
"int",
"(",
"b",
".",
"Dy",
"(",
")",
")",
"\n",
"img_c",
".",
"pixels",
"=",
"(",
"*",
"C",
".",
"uchar",
")",
"(",
"pix",
")",
"\n\n",
"c",
":=",
"C",
".",
"glfwCreateCursor",
"(",
"&",
"img_c",
",",
"C",
".",
"int",
"(",
"xhot",
")",
",",
"C",
".",
"int",
"(",
"yhot",
")",
")",
"\n\n",
"free",
"(",
")",
"\n",
"panicError",
"(",
")",
"\n\n",
"return",
"&",
"Cursor",
"{",
"c",
"}",
"\n",
"}"
] |
// Creates a new custom cursor image that can be set for a window with SetCursor.
// The cursor can be destroyed with Destroy. Any remaining cursors are destroyed by Terminate.
//
// The pixels are 32-bit little-endian RGBA, i.e. eight bits per channel. They are arranged
// canonically as packed sequential rows, starting from the top-left corner.
//
// All non-RGBA images will be converted to RGBA.
//
// The cursor hotspot is specified in pixels, relative to the upper-left corner of the cursor image.
// Like all other coordinate systems in GLFW, the X-axis points to the right and the Y-axis points down.
|
[
"Creates",
"a",
"new",
"custom",
"cursor",
"image",
"that",
"can",
"be",
"set",
"for",
"a",
"window",
"with",
"SetCursor",
".",
"The",
"cursor",
"can",
"be",
"destroyed",
"with",
"Destroy",
".",
"Any",
"remaining",
"cursors",
"are",
"destroyed",
"by",
"Terminate",
".",
"The",
"pixels",
"are",
"32",
"-",
"bit",
"little",
"-",
"endian",
"RGBA",
"i",
".",
"e",
".",
"eight",
"bits",
"per",
"channel",
".",
"They",
"are",
"arranged",
"canonically",
"as",
"packed",
"sequential",
"rows",
"starting",
"from",
"the",
"top",
"-",
"left",
"corner",
".",
"All",
"non",
"-",
"RGBA",
"images",
"will",
"be",
"converted",
"to",
"RGBA",
".",
"The",
"cursor",
"hotspot",
"is",
"specified",
"in",
"pixels",
"relative",
"to",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"cursor",
"image",
".",
"Like",
"all",
"other",
"coordinate",
"systems",
"in",
"GLFW",
"the",
"X",
"-",
"axis",
"points",
"to",
"the",
"right",
"and",
"the",
"Y",
"-",
"axis",
"points",
"down",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.1/glfw/input.go#L383-L409
|
150,963 |
go-gl/glfw
|
v3.1/glfw/input.go
|
CreateStandardCursor
|
func CreateStandardCursor(shape int) *Cursor {
c := C.glfwCreateStandardCursor(C.int(shape))
panicError()
return &Cursor{c}
}
|
go
|
func CreateStandardCursor(shape int) *Cursor {
c := C.glfwCreateStandardCursor(C.int(shape))
panicError()
return &Cursor{c}
}
|
[
"func",
"CreateStandardCursor",
"(",
"shape",
"int",
")",
"*",
"Cursor",
"{",
"c",
":=",
"C",
".",
"glfwCreateStandardCursor",
"(",
"C",
".",
"int",
"(",
"shape",
")",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"&",
"Cursor",
"{",
"c",
"}",
"\n",
"}"
] |
// Returns a cursor with a standard shape, that can be set for a window with SetCursor.
|
[
"Returns",
"a",
"cursor",
"with",
"a",
"standard",
"shape",
"that",
"can",
"be",
"set",
"for",
"a",
"window",
"with",
"SetCursor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.1/glfw/input.go#L412-L416
|
150,964 |
go-gl/glfw
|
v3.2/glfw/monitor.go
|
GetPos
|
func (m *Monitor) GetPos() (x, y int) {
var xpos, ypos C.int
C.glfwGetMonitorPos(m.data, &xpos, &ypos)
panicError()
return int(xpos), int(ypos)
}
|
go
|
func (m *Monitor) GetPos() (x, y int) {
var xpos, ypos C.int
C.glfwGetMonitorPos(m.data, &xpos, &ypos)
panicError()
return int(xpos), int(ypos)
}
|
[
"func",
"(",
"m",
"*",
"Monitor",
")",
"GetPos",
"(",
")",
"(",
"x",
",",
"y",
"int",
")",
"{",
"var",
"xpos",
",",
"ypos",
"C",
".",
"int",
"\n",
"C",
".",
"glfwGetMonitorPos",
"(",
"m",
".",
"data",
",",
"&",
"xpos",
",",
"&",
"ypos",
")",
"\n",
"panicError",
"(",
")",
"\n",
"return",
"int",
"(",
"xpos",
")",
",",
"int",
"(",
"ypos",
")",
"\n",
"}"
] |
// GetPos returns the position, in screen coordinates, of the upper-left
// corner of the monitor.
|
[
"GetPos",
"returns",
"the",
"position",
"in",
"screen",
"coordinates",
"of",
"the",
"upper",
"-",
"left",
"corner",
"of",
"the",
"monitor",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/monitor.go#L86-L91
|
150,965 |
go-gl/glfw
|
v3.2/glfw/monitor.go
|
SetMonitorCallback
|
func SetMonitorCallback(cbfun func(monitor *Monitor, event MonitorEvent)) {
if cbfun == nil {
C.glfwSetMonitorCallback(nil)
} else {
fMonitorHolder = cbfun
C.glfwSetMonitorCallbackCB()
}
panicError()
}
|
go
|
func SetMonitorCallback(cbfun func(monitor *Monitor, event MonitorEvent)) {
if cbfun == nil {
C.glfwSetMonitorCallback(nil)
} else {
fMonitorHolder = cbfun
C.glfwSetMonitorCallbackCB()
}
panicError()
}
|
[
"func",
"SetMonitorCallback",
"(",
"cbfun",
"func",
"(",
"monitor",
"*",
"Monitor",
",",
"event",
"MonitorEvent",
")",
")",
"{",
"if",
"cbfun",
"==",
"nil",
"{",
"C",
".",
"glfwSetMonitorCallback",
"(",
"nil",
")",
"\n",
"}",
"else",
"{",
"fMonitorHolder",
"=",
"cbfun",
"\n",
"C",
".",
"glfwSetMonitorCallbackCB",
"(",
")",
"\n",
"}",
"\n",
"panicError",
"(",
")",
"\n",
"}"
] |
// SetMonitorCallback sets the monitor configuration callback, or removes the
// currently set callback. This is called when a monitor is connected to or
// disconnected from the system.
|
[
"SetMonitorCallback",
"sets",
"the",
"monitor",
"configuration",
"callback",
"or",
"removes",
"the",
"currently",
"set",
"callback",
".",
"This",
"is",
"called",
"when",
"a",
"monitor",
"is",
"connected",
"to",
"or",
"disconnected",
"from",
"the",
"system",
"."
] |
e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc
|
https://github.com/go-gl/glfw/blob/e6da0acd62b1b57ee2799d4d0a76a7d4514dc5bc/v3.2/glfw/monitor.go#L119-L127
|
150,966 |
karrick/godirwalk
|
dirent.go
|
NewDirent
|
func NewDirent(osPathname string) (*Dirent, error) {
fi, err := os.Lstat(osPathname)
if err != nil {
return nil, err
}
return &Dirent{
name: filepath.Base(osPathname),
modeType: fi.Mode() & os.ModeType,
}, nil
}
|
go
|
func NewDirent(osPathname string) (*Dirent, error) {
fi, err := os.Lstat(osPathname)
if err != nil {
return nil, err
}
return &Dirent{
name: filepath.Base(osPathname),
modeType: fi.Mode() & os.ModeType,
}, nil
}
|
[
"func",
"NewDirent",
"(",
"osPathname",
"string",
")",
"(",
"*",
"Dirent",
",",
"error",
")",
"{",
"fi",
",",
"err",
":=",
"os",
".",
"Lstat",
"(",
"osPathname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"&",
"Dirent",
"{",
"name",
":",
"filepath",
".",
"Base",
"(",
"osPathname",
")",
",",
"modeType",
":",
"fi",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeType",
",",
"}",
",",
"nil",
"\n",
"}"
] |
// NewDirent returns a newly initialized Dirent structure, or an error. This
// function does not follow symbolic links.
//
// This function is rarely used, as Dirent structures are provided by other
// functions in this library that read and walk directories.
|
[
"NewDirent",
"returns",
"a",
"newly",
"initialized",
"Dirent",
"structure",
"or",
"an",
"error",
".",
"This",
"function",
"does",
"not",
"follow",
"symbolic",
"links",
".",
"This",
"function",
"is",
"rarely",
"used",
"as",
"Dirent",
"structures",
"are",
"provided",
"by",
"other",
"functions",
"in",
"this",
"library",
"that",
"read",
"and",
"walk",
"directories",
"."
] |
808a2f88690f523a3fb074bc6626124660bc80eb
|
https://github.com/karrick/godirwalk/blob/808a2f88690f523a3fb074bc6626124660bc80eb/dirent.go#L20-L29
|
150,967 |
karrick/godirwalk
|
readdir_windows.go
|
readdirents
|
func readdirents(osDirname string, _ []byte) (Dirents, error) {
dh, err := os.Open(osDirname)
if err != nil {
return nil, err
}
fileinfos, err := dh.Readdir(0)
if er := dh.Close(); err == nil {
err = er
}
if err != nil {
return nil, err
}
entries := make(Dirents, len(fileinfos))
for i, info := range fileinfos {
entries[i] = &Dirent{name: info.Name(), modeType: info.Mode() & os.ModeType}
}
return entries, nil
}
|
go
|
func readdirents(osDirname string, _ []byte) (Dirents, error) {
dh, err := os.Open(osDirname)
if err != nil {
return nil, err
}
fileinfos, err := dh.Readdir(0)
if er := dh.Close(); err == nil {
err = er
}
if err != nil {
return nil, err
}
entries := make(Dirents, len(fileinfos))
for i, info := range fileinfos {
entries[i] = &Dirent{name: info.Name(), modeType: info.Mode() & os.ModeType}
}
return entries, nil
}
|
[
"func",
"readdirents",
"(",
"osDirname",
"string",
",",
"_",
"[",
"]",
"byte",
")",
"(",
"Dirents",
",",
"error",
")",
"{",
"dh",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"osDirname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"fileinfos",
",",
"err",
":=",
"dh",
".",
"Readdir",
"(",
"0",
")",
"\n",
"if",
"er",
":=",
"dh",
".",
"Close",
"(",
")",
";",
"err",
"==",
"nil",
"{",
"err",
"=",
"er",
"\n",
"}",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"entries",
":=",
"make",
"(",
"Dirents",
",",
"len",
"(",
"fileinfos",
")",
")",
"\n",
"for",
"i",
",",
"info",
":=",
"range",
"fileinfos",
"{",
"entries",
"[",
"i",
"]",
"=",
"&",
"Dirent",
"{",
"name",
":",
"info",
".",
"Name",
"(",
")",
",",
"modeType",
":",
"info",
".",
"Mode",
"(",
")",
"&",
"os",
".",
"ModeType",
"}",
"\n",
"}",
"\n\n",
"return",
"entries",
",",
"nil",
"\n",
"}"
] |
// The functions in this file are mere wrappers of what is already provided by
// standard library, in order to provide the same API as this library provides.
//
// The scratch buffer argument is ignored by this architecture.
//
// Please send PR or link to article if you know of a more performant way of
// enumerating directory contents and mode types on Windows.
|
[
"The",
"functions",
"in",
"this",
"file",
"are",
"mere",
"wrappers",
"of",
"what",
"is",
"already",
"provided",
"by",
"standard",
"library",
"in",
"order",
"to",
"provide",
"the",
"same",
"API",
"as",
"this",
"library",
"provides",
".",
"The",
"scratch",
"buffer",
"argument",
"is",
"ignored",
"by",
"this",
"architecture",
".",
"Please",
"send",
"PR",
"or",
"link",
"to",
"article",
"if",
"you",
"know",
"of",
"a",
"more",
"performant",
"way",
"of",
"enumerating",
"directory",
"contents",
"and",
"mode",
"types",
"on",
"Windows",
"."
] |
808a2f88690f523a3fb074bc6626124660bc80eb
|
https://github.com/karrick/godirwalk/blob/808a2f88690f523a3fb074bc6626124660bc80eb/readdir_windows.go#L15-L35
|
150,968 |
karrick/godirwalk
|
walk.go
|
walk
|
func walk(osPathname string, dirent *Dirent, options *Options) error {
err := options.Callback(osPathname, dirent)
if err != nil {
if err == filepath.SkipDir {
return err
}
err = errCallback(err.Error()) // wrap potential errors returned by callback
if action := options.ErrorCallback(osPathname, err); action == SkipNode {
return nil
}
return err
}
// On some platforms, an entry can have more than one mode type bit set.
// For instance, it could have both the symlink bit and the directory bit
// set indicating it's a symlink to a directory.
if dirent.IsSymlink() {
if !options.FollowSymbolicLinks {
return nil
}
skip, err := symlinkDirHelper(osPathname, dirent, options)
if err != nil || skip {
return err
}
}
if !dirent.IsDir() {
return nil
}
// If get here, then specified pathname refers to a directory.
deChildren, err := ReadDirents(osPathname, options.ScratchBuffer)
if err != nil {
if action := options.ErrorCallback(osPathname, err); action == SkipNode {
return nil
}
return err
}
if !options.Unsorted {
sort.Sort(deChildren) // sort children entries unless upstream says to leave unsorted
}
for _, deChild := range deChildren {
osChildname := filepath.Join(osPathname, deChild.name)
err = walk(osChildname, deChild, options)
if err != nil {
if err != filepath.SkipDir {
return err
}
// If received skipdir on a directory, stop processing that
// directory, but continue to its siblings. If received skipdir on a
// non-directory, stop processing remaining siblings.
if deChild.IsSymlink() {
var skip bool
if skip, err = symlinkDirHelper(osChildname, deChild, options); err != nil {
return err
}
if skip {
continue
}
}
if !deChild.IsDir() {
// If not directory, return immediately, thus skipping remainder
// of siblings.
return nil
}
}
}
if options.PostChildrenCallback == nil {
return nil
}
err = options.PostChildrenCallback(osPathname, dirent)
if err == nil || err == filepath.SkipDir {
return err
}
err = errCallback(err.Error()) // wrap potential errors returned by callback
if action := options.ErrorCallback(osPathname, err); action == SkipNode {
return nil
}
return err
}
|
go
|
func walk(osPathname string, dirent *Dirent, options *Options) error {
err := options.Callback(osPathname, dirent)
if err != nil {
if err == filepath.SkipDir {
return err
}
err = errCallback(err.Error()) // wrap potential errors returned by callback
if action := options.ErrorCallback(osPathname, err); action == SkipNode {
return nil
}
return err
}
// On some platforms, an entry can have more than one mode type bit set.
// For instance, it could have both the symlink bit and the directory bit
// set indicating it's a symlink to a directory.
if dirent.IsSymlink() {
if !options.FollowSymbolicLinks {
return nil
}
skip, err := symlinkDirHelper(osPathname, dirent, options)
if err != nil || skip {
return err
}
}
if !dirent.IsDir() {
return nil
}
// If get here, then specified pathname refers to a directory.
deChildren, err := ReadDirents(osPathname, options.ScratchBuffer)
if err != nil {
if action := options.ErrorCallback(osPathname, err); action == SkipNode {
return nil
}
return err
}
if !options.Unsorted {
sort.Sort(deChildren) // sort children entries unless upstream says to leave unsorted
}
for _, deChild := range deChildren {
osChildname := filepath.Join(osPathname, deChild.name)
err = walk(osChildname, deChild, options)
if err != nil {
if err != filepath.SkipDir {
return err
}
// If received skipdir on a directory, stop processing that
// directory, but continue to its siblings. If received skipdir on a
// non-directory, stop processing remaining siblings.
if deChild.IsSymlink() {
var skip bool
if skip, err = symlinkDirHelper(osChildname, deChild, options); err != nil {
return err
}
if skip {
continue
}
}
if !deChild.IsDir() {
// If not directory, return immediately, thus skipping remainder
// of siblings.
return nil
}
}
}
if options.PostChildrenCallback == nil {
return nil
}
err = options.PostChildrenCallback(osPathname, dirent)
if err == nil || err == filepath.SkipDir {
return err
}
err = errCallback(err.Error()) // wrap potential errors returned by callback
if action := options.ErrorCallback(osPathname, err); action == SkipNode {
return nil
}
return err
}
|
[
"func",
"walk",
"(",
"osPathname",
"string",
",",
"dirent",
"*",
"Dirent",
",",
"options",
"*",
"Options",
")",
"error",
"{",
"err",
":=",
"options",
".",
"Callback",
"(",
"osPathname",
",",
"dirent",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"==",
"filepath",
".",
"SkipDir",
"{",
"return",
"err",
"\n",
"}",
"\n",
"err",
"=",
"errCallback",
"(",
"err",
".",
"Error",
"(",
")",
")",
"// wrap potential errors returned by callback",
"\n",
"if",
"action",
":=",
"options",
".",
"ErrorCallback",
"(",
"osPathname",
",",
"err",
")",
";",
"action",
"==",
"SkipNode",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"// On some platforms, an entry can have more than one mode type bit set.",
"// For instance, it could have both the symlink bit and the directory bit",
"// set indicating it's a symlink to a directory.",
"if",
"dirent",
".",
"IsSymlink",
"(",
")",
"{",
"if",
"!",
"options",
".",
"FollowSymbolicLinks",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"skip",
",",
"err",
":=",
"symlinkDirHelper",
"(",
"osPathname",
",",
"dirent",
",",
"options",
")",
"\n",
"if",
"err",
"!=",
"nil",
"||",
"skip",
"{",
"return",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"!",
"dirent",
".",
"IsDir",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// If get here, then specified pathname refers to a directory.",
"deChildren",
",",
"err",
":=",
"ReadDirents",
"(",
"osPathname",
",",
"options",
".",
"ScratchBuffer",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"action",
":=",
"options",
".",
"ErrorCallback",
"(",
"osPathname",
",",
"err",
")",
";",
"action",
"==",
"SkipNode",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"options",
".",
"Unsorted",
"{",
"sort",
".",
"Sort",
"(",
"deChildren",
")",
"// sort children entries unless upstream says to leave unsorted",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"deChild",
":=",
"range",
"deChildren",
"{",
"osChildname",
":=",
"filepath",
".",
"Join",
"(",
"osPathname",
",",
"deChild",
".",
"name",
")",
"\n",
"err",
"=",
"walk",
"(",
"osChildname",
",",
"deChild",
",",
"options",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"if",
"err",
"!=",
"filepath",
".",
"SkipDir",
"{",
"return",
"err",
"\n",
"}",
"\n",
"// If received skipdir on a directory, stop processing that",
"// directory, but continue to its siblings. If received skipdir on a",
"// non-directory, stop processing remaining siblings.",
"if",
"deChild",
".",
"IsSymlink",
"(",
")",
"{",
"var",
"skip",
"bool",
"\n",
"if",
"skip",
",",
"err",
"=",
"symlinkDirHelper",
"(",
"osChildname",
",",
"deChild",
",",
"options",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"if",
"skip",
"{",
"continue",
"\n",
"}",
"\n",
"}",
"\n",
"if",
"!",
"deChild",
".",
"IsDir",
"(",
")",
"{",
"// If not directory, return immediately, thus skipping remainder",
"// of siblings.",
"return",
"nil",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"options",
".",
"PostChildrenCallback",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"err",
"=",
"options",
".",
"PostChildrenCallback",
"(",
"osPathname",
",",
"dirent",
")",
"\n",
"if",
"err",
"==",
"nil",
"||",
"err",
"==",
"filepath",
".",
"SkipDir",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"err",
"=",
"errCallback",
"(",
"err",
".",
"Error",
"(",
")",
")",
"// wrap potential errors returned by callback",
"\n",
"if",
"action",
":=",
"options",
".",
"ErrorCallback",
"(",
"osPathname",
",",
"err",
")",
";",
"action",
"==",
"SkipNode",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"err",
"\n",
"}"
] |
// walk recursively traverses the file system node specified by pathname and the
// Dirent.
|
[
"walk",
"recursively",
"traverses",
"the",
"file",
"system",
"node",
"specified",
"by",
"pathname",
"and",
"the",
"Dirent",
"."
] |
808a2f88690f523a3fb074bc6626124660bc80eb
|
https://github.com/karrick/godirwalk/blob/808a2f88690f523a3fb074bc6626124660bc80eb/walk.go#L229-L313
|
150,969 |
paulmach/orb
|
clip/helpers.go
|
Geometry
|
func Geometry(b orb.Bound, g orb.Geometry) orb.Geometry {
if g == nil {
return nil
}
if !b.Intersects(g.Bound()) {
return nil
}
switch g := g.(type) {
case orb.Point:
return g // Intersect check above
case orb.MultiPoint:
mp := MultiPoint(b, g)
if len(mp) == 1 {
return mp[0]
}
if mp == nil {
return nil
}
return mp
case orb.LineString:
mls := LineString(b, g)
if len(mls) == 1 {
return mls[0]
}
if len(mls) == 0 {
return nil
}
return mls
case orb.MultiLineString:
mls := MultiLineString(b, g)
if len(mls) == 1 {
return mls[0]
}
if mls == nil {
return nil
}
return mls
case orb.Ring:
r := Ring(b, g)
if r == nil {
return nil
}
return r
case orb.Polygon:
p := Polygon(b, g)
if p == nil {
return nil
}
return p
case orb.MultiPolygon:
mp := MultiPolygon(b, g)
if len(mp) == 1 {
return mp[0]
}
if mp == nil {
return nil
}
return mp
case orb.Collection:
c := Collection(b, g)
if len(c) == 1 {
return c[0]
}
if c == nil {
return nil
}
return c
case orb.Bound:
b = Bound(b, g)
if b.IsEmpty() {
return nil
}
return b
}
panic(fmt.Sprintf("geometry type not supported: %T", g))
}
|
go
|
func Geometry(b orb.Bound, g orb.Geometry) orb.Geometry {
if g == nil {
return nil
}
if !b.Intersects(g.Bound()) {
return nil
}
switch g := g.(type) {
case orb.Point:
return g // Intersect check above
case orb.MultiPoint:
mp := MultiPoint(b, g)
if len(mp) == 1 {
return mp[0]
}
if mp == nil {
return nil
}
return mp
case orb.LineString:
mls := LineString(b, g)
if len(mls) == 1 {
return mls[0]
}
if len(mls) == 0 {
return nil
}
return mls
case orb.MultiLineString:
mls := MultiLineString(b, g)
if len(mls) == 1 {
return mls[0]
}
if mls == nil {
return nil
}
return mls
case orb.Ring:
r := Ring(b, g)
if r == nil {
return nil
}
return r
case orb.Polygon:
p := Polygon(b, g)
if p == nil {
return nil
}
return p
case orb.MultiPolygon:
mp := MultiPolygon(b, g)
if len(mp) == 1 {
return mp[0]
}
if mp == nil {
return nil
}
return mp
case orb.Collection:
c := Collection(b, g)
if len(c) == 1 {
return c[0]
}
if c == nil {
return nil
}
return c
case orb.Bound:
b = Bound(b, g)
if b.IsEmpty() {
return nil
}
return b
}
panic(fmt.Sprintf("geometry type not supported: %T", g))
}
|
[
"func",
"Geometry",
"(",
"b",
"orb",
".",
"Bound",
",",
"g",
"orb",
".",
"Geometry",
")",
"orb",
".",
"Geometry",
"{",
"if",
"g",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"!",
"b",
".",
"Intersects",
"(",
"g",
".",
"Bound",
"(",
")",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"switch",
"g",
":=",
"g",
".",
"(",
"type",
")",
"{",
"case",
"orb",
".",
"Point",
":",
"return",
"g",
"// Intersect check above",
"\n",
"case",
"orb",
".",
"MultiPoint",
":",
"mp",
":=",
"MultiPoint",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"len",
"(",
"mp",
")",
"==",
"1",
"{",
"return",
"mp",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"if",
"mp",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"mp",
"\n",
"case",
"orb",
".",
"LineString",
":",
"mls",
":=",
"LineString",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"len",
"(",
"mls",
")",
"==",
"1",
"{",
"return",
"mls",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"mls",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"mls",
"\n",
"case",
"orb",
".",
"MultiLineString",
":",
"mls",
":=",
"MultiLineString",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"len",
"(",
"mls",
")",
"==",
"1",
"{",
"return",
"mls",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"if",
"mls",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"mls",
"\n",
"case",
"orb",
".",
"Ring",
":",
"r",
":=",
"Ring",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"r",
"\n",
"case",
"orb",
".",
"Polygon",
":",
"p",
":=",
"Polygon",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"p",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"p",
"\n",
"case",
"orb",
".",
"MultiPolygon",
":",
"mp",
":=",
"MultiPolygon",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"len",
"(",
"mp",
")",
"==",
"1",
"{",
"return",
"mp",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"if",
"mp",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"mp",
"\n",
"case",
"orb",
".",
"Collection",
":",
"c",
":=",
"Collection",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"len",
"(",
"c",
")",
"==",
"1",
"{",
"return",
"c",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"if",
"c",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"c",
"\n",
"case",
"orb",
".",
"Bound",
":",
"b",
"=",
"Bound",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"b",
".",
"IsEmpty",
"(",
")",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"b",
"\n",
"}",
"\n\n",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"g",
")",
")",
"\n",
"}"
] |
// Geometry will clip the geometry to the bounding box using the
// correct functions for the type.
// This operation will modify the input of '1d or 2d geometry' by using as a
// scratch space so clone if necessary.
|
[
"Geometry",
"will",
"clip",
"the",
"geometry",
"to",
"the",
"bounding",
"box",
"using",
"the",
"correct",
"functions",
"for",
"the",
"type",
".",
"This",
"operation",
"will",
"modify",
"the",
"input",
"of",
"1d",
"or",
"2d",
"geometry",
"by",
"using",
"as",
"a",
"scratch",
"space",
"so",
"clone",
"if",
"necessary",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L15-L105
|
150,970 |
paulmach/orb
|
clip/helpers.go
|
MultiPoint
|
func MultiPoint(b orb.Bound, mp orb.MultiPoint) orb.MultiPoint {
var result orb.MultiPoint
for _, p := range mp {
if b.Contains(p) {
result = append(result, p)
}
}
return result
}
|
go
|
func MultiPoint(b orb.Bound, mp orb.MultiPoint) orb.MultiPoint {
var result orb.MultiPoint
for _, p := range mp {
if b.Contains(p) {
result = append(result, p)
}
}
return result
}
|
[
"func",
"MultiPoint",
"(",
"b",
"orb",
".",
"Bound",
",",
"mp",
"orb",
".",
"MultiPoint",
")",
"orb",
".",
"MultiPoint",
"{",
"var",
"result",
"orb",
".",
"MultiPoint",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"mp",
"{",
"if",
"b",
".",
"Contains",
"(",
"p",
")",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// MultiPoint returns a new set with the points outside the bound removed.
|
[
"MultiPoint",
"returns",
"a",
"new",
"set",
"with",
"the",
"points",
"outside",
"the",
"bound",
"removed",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L108-L117
|
150,971 |
paulmach/orb
|
clip/helpers.go
|
LineString
|
func LineString(b orb.Bound, ls orb.LineString, opts ...Option) orb.MultiLineString {
open := false
if len(opts) > 0 {
o := &options{}
for _, opt := range opts {
opt(o)
}
open = o.openBound
}
result := line(b, ls, open)
if len(result) == 0 {
return nil
}
return result
}
|
go
|
func LineString(b orb.Bound, ls orb.LineString, opts ...Option) orb.MultiLineString {
open := false
if len(opts) > 0 {
o := &options{}
for _, opt := range opts {
opt(o)
}
open = o.openBound
}
result := line(b, ls, open)
if len(result) == 0 {
return nil
}
return result
}
|
[
"func",
"LineString",
"(",
"b",
"orb",
".",
"Bound",
",",
"ls",
"orb",
".",
"LineString",
",",
"opts",
"...",
"Option",
")",
"orb",
".",
"MultiLineString",
"{",
"open",
":=",
"false",
"\n",
"if",
"len",
"(",
"opts",
")",
">",
"0",
"{",
"o",
":=",
"&",
"options",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"o",
")",
"\n",
"}",
"\n\n",
"open",
"=",
"o",
".",
"openBound",
"\n",
"}",
"\n\n",
"result",
":=",
"line",
"(",
"b",
",",
"ls",
",",
"open",
")",
"\n",
"if",
"len",
"(",
"result",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// LineString clips the linestring to the bounding box.
|
[
"LineString",
"clips",
"the",
"linestring",
"to",
"the",
"bounding",
"box",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L120-L137
|
150,972 |
paulmach/orb
|
clip/helpers.go
|
MultiLineString
|
func MultiLineString(b orb.Bound, mls orb.MultiLineString, opts ...Option) orb.MultiLineString {
open := false
if len(opts) > 0 {
o := &options{}
for _, opt := range opts {
opt(o)
}
open = o.openBound
}
var result orb.MultiLineString
for _, ls := range mls {
r := line(b, ls, open)
if len(r) != 0 {
result = append(result, r...)
}
}
return result
}
|
go
|
func MultiLineString(b orb.Bound, mls orb.MultiLineString, opts ...Option) orb.MultiLineString {
open := false
if len(opts) > 0 {
o := &options{}
for _, opt := range opts {
opt(o)
}
open = o.openBound
}
var result orb.MultiLineString
for _, ls := range mls {
r := line(b, ls, open)
if len(r) != 0 {
result = append(result, r...)
}
}
return result
}
|
[
"func",
"MultiLineString",
"(",
"b",
"orb",
".",
"Bound",
",",
"mls",
"orb",
".",
"MultiLineString",
",",
"opts",
"...",
"Option",
")",
"orb",
".",
"MultiLineString",
"{",
"open",
":=",
"false",
"\n",
"if",
"len",
"(",
"opts",
")",
">",
"0",
"{",
"o",
":=",
"&",
"options",
"{",
"}",
"\n",
"for",
"_",
",",
"opt",
":=",
"range",
"opts",
"{",
"opt",
"(",
"o",
")",
"\n",
"}",
"\n\n",
"open",
"=",
"o",
".",
"openBound",
"\n",
"}",
"\n\n",
"var",
"result",
"orb",
".",
"MultiLineString",
"\n",
"for",
"_",
",",
"ls",
":=",
"range",
"mls",
"{",
"r",
":=",
"line",
"(",
"b",
",",
"ls",
",",
"open",
")",
"\n",
"if",
"len",
"(",
"r",
")",
"!=",
"0",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"r",
"...",
")",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"}"
] |
// MultiLineString clips the linestrings to the bounding box
// and returns a linestring union.
|
[
"MultiLineString",
"clips",
"the",
"linestrings",
"to",
"the",
"bounding",
"box",
"and",
"returns",
"a",
"linestring",
"union",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L141-L160
|
150,973 |
paulmach/orb
|
clip/helpers.go
|
Ring
|
func Ring(b orb.Bound, r orb.Ring) orb.Ring {
result := ring(b, r)
if len(result) == 0 {
return nil
}
return result
}
|
go
|
func Ring(b orb.Bound, r orb.Ring) orb.Ring {
result := ring(b, r)
if len(result) == 0 {
return nil
}
return result
}
|
[
"func",
"Ring",
"(",
"b",
"orb",
".",
"Bound",
",",
"r",
"orb",
".",
"Ring",
")",
"orb",
".",
"Ring",
"{",
"result",
":=",
"ring",
"(",
"b",
",",
"r",
")",
"\n",
"if",
"len",
"(",
"result",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Ring clips the ring to the bounding box and returns another ring.
// This operation will modify the input by using as a scratch space
// so clone if necessary.
|
[
"Ring",
"clips",
"the",
"ring",
"to",
"the",
"bounding",
"box",
"and",
"returns",
"another",
"ring",
".",
"This",
"operation",
"will",
"modify",
"the",
"input",
"by",
"using",
"as",
"a",
"scratch",
"space",
"so",
"clone",
"if",
"necessary",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L165-L172
|
150,974 |
paulmach/orb
|
clip/helpers.go
|
Polygon
|
func Polygon(b orb.Bound, p orb.Polygon) orb.Polygon {
if len(p) == 0 {
return nil
}
r := Ring(b, p[0])
if r == nil {
return nil
}
result := orb.Polygon{r}
for i := 1; i < len(p); i++ {
r := Ring(b, p[i])
if r != nil {
result = append(result, r)
}
}
return result
}
|
go
|
func Polygon(b orb.Bound, p orb.Polygon) orb.Polygon {
if len(p) == 0 {
return nil
}
r := Ring(b, p[0])
if r == nil {
return nil
}
result := orb.Polygon{r}
for i := 1; i < len(p); i++ {
r := Ring(b, p[i])
if r != nil {
result = append(result, r)
}
}
return result
}
|
[
"func",
"Polygon",
"(",
"b",
"orb",
".",
"Bound",
",",
"p",
"orb",
".",
"Polygon",
")",
"orb",
".",
"Polygon",
"{",
"if",
"len",
"(",
"p",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"r",
":=",
"Ring",
"(",
"b",
",",
"p",
"[",
"0",
"]",
")",
"\n",
"if",
"r",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"result",
":=",
"orb",
".",
"Polygon",
"{",
"r",
"}",
"\n",
"for",
"i",
":=",
"1",
";",
"i",
"<",
"len",
"(",
"p",
")",
";",
"i",
"++",
"{",
"r",
":=",
"Ring",
"(",
"b",
",",
"p",
"[",
"i",
"]",
")",
"\n",
"if",
"r",
"!=",
"nil",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Polygon clips the polygon to the bounding box excluding the inner rings
// if they do not intersect the bounding box.
// This operation will modify the input by using as a scratch space
// so clone if necessary.
|
[
"Polygon",
"clips",
"the",
"polygon",
"to",
"the",
"bounding",
"box",
"excluding",
"the",
"inner",
"rings",
"if",
"they",
"do",
"not",
"intersect",
"the",
"bounding",
"box",
".",
"This",
"operation",
"will",
"modify",
"the",
"input",
"by",
"using",
"as",
"a",
"scratch",
"space",
"so",
"clone",
"if",
"necessary",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L178-L197
|
150,975 |
paulmach/orb
|
clip/helpers.go
|
MultiPolygon
|
func MultiPolygon(b orb.Bound, mp orb.MultiPolygon) orb.MultiPolygon {
var result orb.MultiPolygon
for _, polygon := range mp {
p := Polygon(b, polygon)
if p != nil {
result = append(result, p)
}
}
return result
}
|
go
|
func MultiPolygon(b orb.Bound, mp orb.MultiPolygon) orb.MultiPolygon {
var result orb.MultiPolygon
for _, polygon := range mp {
p := Polygon(b, polygon)
if p != nil {
result = append(result, p)
}
}
return result
}
|
[
"func",
"MultiPolygon",
"(",
"b",
"orb",
".",
"Bound",
",",
"mp",
"orb",
".",
"MultiPolygon",
")",
"orb",
".",
"MultiPolygon",
"{",
"var",
"result",
"orb",
".",
"MultiPolygon",
"\n",
"for",
"_",
",",
"polygon",
":=",
"range",
"mp",
"{",
"p",
":=",
"Polygon",
"(",
"b",
",",
"polygon",
")",
"\n",
"if",
"p",
"!=",
"nil",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"p",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// MultiPolygon clips the multi polygon to the bounding box excluding
// any polygons if they don't intersect the bounding box.
// This operation will modify the input by using as a scratch space
// so clone if necessary.
|
[
"MultiPolygon",
"clips",
"the",
"multi",
"polygon",
"to",
"the",
"bounding",
"box",
"excluding",
"any",
"polygons",
"if",
"they",
"don",
"t",
"intersect",
"the",
"bounding",
"box",
".",
"This",
"operation",
"will",
"modify",
"the",
"input",
"by",
"using",
"as",
"a",
"scratch",
"space",
"so",
"clone",
"if",
"necessary",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L203-L213
|
150,976 |
paulmach/orb
|
clip/helpers.go
|
Collection
|
func Collection(b orb.Bound, c orb.Collection) orb.Collection {
var result orb.Collection
for _, g := range c {
clipped := Geometry(b, g)
if clipped != nil {
result = append(result, clipped)
}
}
return result
}
|
go
|
func Collection(b orb.Bound, c orb.Collection) orb.Collection {
var result orb.Collection
for _, g := range c {
clipped := Geometry(b, g)
if clipped != nil {
result = append(result, clipped)
}
}
return result
}
|
[
"func",
"Collection",
"(",
"b",
"orb",
".",
"Bound",
",",
"c",
"orb",
".",
"Collection",
")",
"orb",
".",
"Collection",
"{",
"var",
"result",
"orb",
".",
"Collection",
"\n",
"for",
"_",
",",
"g",
":=",
"range",
"c",
"{",
"clipped",
":=",
"Geometry",
"(",
"b",
",",
"g",
")",
"\n",
"if",
"clipped",
"!=",
"nil",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"clipped",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Collection clips each element in the collection to the bounding box.
// It will exclude elements if they don't intersect the bounding box.
// This operation will modify the input of '2d geometry' by using as a
// scratch space so clone if necessary.
|
[
"Collection",
"clips",
"each",
"element",
"in",
"the",
"collection",
"to",
"the",
"bounding",
"box",
".",
"It",
"will",
"exclude",
"elements",
"if",
"they",
"don",
"t",
"intersect",
"the",
"bounding",
"box",
".",
"This",
"operation",
"will",
"modify",
"the",
"input",
"of",
"2d",
"geometry",
"by",
"using",
"as",
"a",
"scratch",
"space",
"so",
"clone",
"if",
"necessary",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/helpers.go#L219-L229
|
150,977 |
paulmach/orb
|
maptile/tilecover/polygon.go
|
Ring
|
func Ring(r orb.Ring, z maptile.Zoom) maptile.Set {
if len(r) == 0 {
return make(maptile.Set)
}
return Polygon(orb.Polygon{r}, z)
}
|
go
|
func Ring(r orb.Ring, z maptile.Zoom) maptile.Set {
if len(r) == 0 {
return make(maptile.Set)
}
return Polygon(orb.Polygon{r}, z)
}
|
[
"func",
"Ring",
"(",
"r",
"orb",
".",
"Ring",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"if",
"len",
"(",
"r",
")",
"==",
"0",
"{",
"return",
"make",
"(",
"maptile",
".",
"Set",
")",
"\n",
"}",
"\n\n",
"return",
"Polygon",
"(",
"orb",
".",
"Polygon",
"{",
"r",
"}",
",",
"z",
")",
"\n",
"}"
] |
// Ring creates a tile cover for the ring.
|
[
"Ring",
"creates",
"a",
"tile",
"cover",
"for",
"the",
"ring",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/polygon.go#L11-L17
|
150,978 |
paulmach/orb
|
maptile/tilecover/polygon.go
|
Polygon
|
func Polygon(p orb.Polygon, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
polygon(set, p, z)
return set
}
|
go
|
func Polygon(p orb.Polygon, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
polygon(set, p, z)
return set
}
|
[
"func",
"Polygon",
"(",
"p",
"orb",
".",
"Polygon",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"set",
":=",
"make",
"(",
"maptile",
".",
"Set",
")",
"\n",
"polygon",
"(",
"set",
",",
"p",
",",
"z",
")",
"\n\n",
"return",
"set",
"\n",
"}"
] |
// Polygon creates a tile cover for the polygon.
|
[
"Polygon",
"creates",
"a",
"tile",
"cover",
"for",
"the",
"polygon",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/polygon.go#L20-L25
|
150,979 |
paulmach/orb
|
maptile/tilecover/polygon.go
|
MultiPolygon
|
func MultiPolygon(mp orb.MultiPolygon, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
for _, p := range mp {
polygon(set, p, z)
}
return set
}
|
go
|
func MultiPolygon(mp orb.MultiPolygon, z maptile.Zoom) maptile.Set {
set := make(maptile.Set)
for _, p := range mp {
polygon(set, p, z)
}
return set
}
|
[
"func",
"MultiPolygon",
"(",
"mp",
"orb",
".",
"MultiPolygon",
",",
"z",
"maptile",
".",
"Zoom",
")",
"maptile",
".",
"Set",
"{",
"set",
":=",
"make",
"(",
"maptile",
".",
"Set",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"mp",
"{",
"polygon",
"(",
"set",
",",
"p",
",",
"z",
")",
"\n",
"}",
"\n\n",
"return",
"set",
"\n",
"}"
] |
// MultiPolygon creates a tile cover for the multi-polygon.
|
[
"MultiPolygon",
"creates",
"a",
"tile",
"cover",
"for",
"the",
"multi",
"-",
"polygon",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/maptile/tilecover/polygon.go#L28-L35
|
150,980 |
paulmach/orb
|
geometry.go
|
Bound
|
func (c Collection) Bound() Bound {
if len(c) == 0 {
return emptyBound
}
var b Bound
start := -1
for i, g := range c {
if g != nil {
start = i
b = g.Bound()
break
}
}
if start == -1 {
return emptyBound
}
for i := start + 1; i < len(c); i++ {
if c[i] == nil {
continue
}
b = b.Union(c[i].Bound())
}
return b
}
|
go
|
func (c Collection) Bound() Bound {
if len(c) == 0 {
return emptyBound
}
var b Bound
start := -1
for i, g := range c {
if g != nil {
start = i
b = g.Bound()
break
}
}
if start == -1 {
return emptyBound
}
for i := start + 1; i < len(c); i++ {
if c[i] == nil {
continue
}
b = b.Union(c[i].Bound())
}
return b
}
|
[
"func",
"(",
"c",
"Collection",
")",
"Bound",
"(",
")",
"Bound",
"{",
"if",
"len",
"(",
"c",
")",
"==",
"0",
"{",
"return",
"emptyBound",
"\n",
"}",
"\n\n",
"var",
"b",
"Bound",
"\n",
"start",
":=",
"-",
"1",
"\n\n",
"for",
"i",
",",
"g",
":=",
"range",
"c",
"{",
"if",
"g",
"!=",
"nil",
"{",
"start",
"=",
"i",
"\n",
"b",
"=",
"g",
".",
"Bound",
"(",
")",
"\n",
"break",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"start",
"==",
"-",
"1",
"{",
"return",
"emptyBound",
"\n",
"}",
"\n\n",
"for",
"i",
":=",
"start",
"+",
"1",
";",
"i",
"<",
"len",
"(",
"c",
")",
";",
"i",
"++",
"{",
"if",
"c",
"[",
"i",
"]",
"==",
"nil",
"{",
"continue",
"\n",
"}",
"\n\n",
"b",
"=",
"b",
".",
"Union",
"(",
"c",
"[",
"i",
"]",
".",
"Bound",
"(",
")",
")",
"\n",
"}",
"\n\n",
"return",
"b",
"\n",
"}"
] |
// Bound returns the bounding box of all the Geometries combined.
|
[
"Bound",
"returns",
"the",
"bounding",
"box",
"of",
"all",
"the",
"Geometries",
"combined",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/geometry.go#L87-L116
|
150,981 |
paulmach/orb
|
geometry.go
|
Equal
|
func (c Collection) Equal(collection Collection) bool {
if len(c) != len(collection) {
return false
}
for i, g := range c {
if !Equal(g, collection[i]) {
return false
}
}
return true
}
|
go
|
func (c Collection) Equal(collection Collection) bool {
if len(c) != len(collection) {
return false
}
for i, g := range c {
if !Equal(g, collection[i]) {
return false
}
}
return true
}
|
[
"func",
"(",
"c",
"Collection",
")",
"Equal",
"(",
"collection",
"Collection",
")",
"bool",
"{",
"if",
"len",
"(",
"c",
")",
"!=",
"len",
"(",
"collection",
")",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"for",
"i",
",",
"g",
":=",
"range",
"c",
"{",
"if",
"!",
"Equal",
"(",
"g",
",",
"collection",
"[",
"i",
"]",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"true",
"\n",
"}"
] |
// Equal compares two collections. Returns true if lengths are the same
// and all the sub geometries are the same and in the same order.
|
[
"Equal",
"compares",
"two",
"collections",
".",
"Returns",
"true",
"if",
"lengths",
"are",
"the",
"same",
"and",
"all",
"the",
"sub",
"geometries",
"are",
"the",
"same",
"and",
"in",
"the",
"same",
"order",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/geometry.go#L120-L132
|
150,982 |
paulmach/orb
|
geometry.go
|
Clone
|
func (c Collection) Clone() Collection {
if c == nil {
return nil
}
nc := make(Collection, len(c))
for i, g := range c {
nc[i] = Clone(g)
}
return nc
}
|
go
|
func (c Collection) Clone() Collection {
if c == nil {
return nil
}
nc := make(Collection, len(c))
for i, g := range c {
nc[i] = Clone(g)
}
return nc
}
|
[
"func",
"(",
"c",
"Collection",
")",
"Clone",
"(",
")",
"Collection",
"{",
"if",
"c",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"nc",
":=",
"make",
"(",
"Collection",
",",
"len",
"(",
"c",
")",
")",
"\n",
"for",
"i",
",",
"g",
":=",
"range",
"c",
"{",
"nc",
"[",
"i",
"]",
"=",
"Clone",
"(",
"g",
")",
"\n",
"}",
"\n\n",
"return",
"nc",
"\n",
"}"
] |
// Clone returns a deep copy of the collection.
|
[
"Clone",
"returns",
"a",
"deep",
"copy",
"of",
"the",
"collection",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/geometry.go#L135-L146
|
150,983 |
paulmach/orb
|
simplify/radial.go
|
Radial
|
func Radial(df orb.DistanceFunc, threshold float64) *RadialSimplifier {
return &RadialSimplifier{
DistanceFunc: df,
Threshold: threshold,
}
}
|
go
|
func Radial(df orb.DistanceFunc, threshold float64) *RadialSimplifier {
return &RadialSimplifier{
DistanceFunc: df,
Threshold: threshold,
}
}
|
[
"func",
"Radial",
"(",
"df",
"orb",
".",
"DistanceFunc",
",",
"threshold",
"float64",
")",
"*",
"RadialSimplifier",
"{",
"return",
"&",
"RadialSimplifier",
"{",
"DistanceFunc",
":",
"df",
",",
"Threshold",
":",
"threshold",
",",
"}",
"\n",
"}"
] |
// Radial creates a new RadialSimplifier.
|
[
"Radial",
"creates",
"a",
"new",
"RadialSimplifier",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/simplify/radial.go#L16-L21
|
150,984 |
paulmach/orb
|
clip/smartclip/smart.go
|
Geometry
|
func Geometry(box orb.Bound, g orb.Geometry, o orb.Orientation) orb.Geometry {
if g == nil {
return nil
}
if g.Dimensions() != 2 {
return clip.Geometry(box, g)
}
var mp orb.MultiPolygon
switch g := g.(type) {
case orb.Ring:
mp = Ring(box, g, o)
case orb.Polygon:
mp = Polygon(box, g, o)
case orb.MultiPolygon:
mp = MultiPolygon(box, g, o)
case orb.Bound:
return clip.Geometry(box, g)
case orb.Collection:
var result orb.Collection
for _, c := range g {
c := Geometry(box, c, o)
if c != nil {
result = append(result, c)
}
}
if len(result) == 1 {
return result[0]
}
return result
default:
panic(fmt.Sprintf("geometry type not supported: %T", g))
}
if mp == nil {
return nil
}
if len(mp) == 1 {
return mp[0]
}
return mp
}
|
go
|
func Geometry(box orb.Bound, g orb.Geometry, o orb.Orientation) orb.Geometry {
if g == nil {
return nil
}
if g.Dimensions() != 2 {
return clip.Geometry(box, g)
}
var mp orb.MultiPolygon
switch g := g.(type) {
case orb.Ring:
mp = Ring(box, g, o)
case orb.Polygon:
mp = Polygon(box, g, o)
case orb.MultiPolygon:
mp = MultiPolygon(box, g, o)
case orb.Bound:
return clip.Geometry(box, g)
case orb.Collection:
var result orb.Collection
for _, c := range g {
c := Geometry(box, c, o)
if c != nil {
result = append(result, c)
}
}
if len(result) == 1 {
return result[0]
}
return result
default:
panic(fmt.Sprintf("geometry type not supported: %T", g))
}
if mp == nil {
return nil
}
if len(mp) == 1 {
return mp[0]
}
return mp
}
|
[
"func",
"Geometry",
"(",
"box",
"orb",
".",
"Bound",
",",
"g",
"orb",
".",
"Geometry",
",",
"o",
"orb",
".",
"Orientation",
")",
"orb",
".",
"Geometry",
"{",
"if",
"g",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"g",
".",
"Dimensions",
"(",
")",
"!=",
"2",
"{",
"return",
"clip",
".",
"Geometry",
"(",
"box",
",",
"g",
")",
"\n",
"}",
"\n\n",
"var",
"mp",
"orb",
".",
"MultiPolygon",
"\n",
"switch",
"g",
":=",
"g",
".",
"(",
"type",
")",
"{",
"case",
"orb",
".",
"Ring",
":",
"mp",
"=",
"Ring",
"(",
"box",
",",
"g",
",",
"o",
")",
"\n",
"case",
"orb",
".",
"Polygon",
":",
"mp",
"=",
"Polygon",
"(",
"box",
",",
"g",
",",
"o",
")",
"\n",
"case",
"orb",
".",
"MultiPolygon",
":",
"mp",
"=",
"MultiPolygon",
"(",
"box",
",",
"g",
",",
"o",
")",
"\n",
"case",
"orb",
".",
"Bound",
":",
"return",
"clip",
".",
"Geometry",
"(",
"box",
",",
"g",
")",
"\n",
"case",
"orb",
".",
"Collection",
":",
"var",
"result",
"orb",
".",
"Collection",
"\n",
"for",
"_",
",",
"c",
":=",
"range",
"g",
"{",
"c",
":=",
"Geometry",
"(",
"box",
",",
"c",
",",
"o",
")",
"\n",
"if",
"c",
"!=",
"nil",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"c",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"result",
")",
"==",
"1",
"{",
"return",
"result",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"g",
")",
")",
"\n",
"}",
"\n\n",
"if",
"mp",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"mp",
")",
"==",
"1",
"{",
"return",
"mp",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"mp",
"\n",
"}"
] |
// Geometry will do a smart more involved clipping and wrapping of the geometry.
// It will return simple OGC geometries. Rings that are NOT closed AND have an
// endpoint in the bound will be implicitly closed.
|
[
"Geometry",
"will",
"do",
"a",
"smart",
"more",
"involved",
"clipping",
"and",
"wrapping",
"of",
"the",
"geometry",
".",
"It",
"will",
"return",
"simple",
"OGC",
"geometries",
".",
"Rings",
"that",
"are",
"NOT",
"closed",
"AND",
"have",
"an",
"endpoint",
"in",
"the",
"bound",
"will",
"be",
"implicitly",
"closed",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L16-L62
|
150,985 |
paulmach/orb
|
clip/smartclip/smart.go
|
Ring
|
func Ring(box orb.Bound, r orb.Ring, o orb.Orientation) orb.MultiPolygon {
if len(r) == 0 {
return nil
}
open, closed := clipRings(box, []orb.Ring{r})
if len(open) == 0 {
// nothing was clipped
if len(closed) == 0 {
return nil // everything outside bound
}
return orb.MultiPolygon{{r}} // everything inside bound
}
// in a well defined ring there will be no closed sections
return smartWrap(box, open, o)
}
|
go
|
func Ring(box orb.Bound, r orb.Ring, o orb.Orientation) orb.MultiPolygon {
if len(r) == 0 {
return nil
}
open, closed := clipRings(box, []orb.Ring{r})
if len(open) == 0 {
// nothing was clipped
if len(closed) == 0 {
return nil // everything outside bound
}
return orb.MultiPolygon{{r}} // everything inside bound
}
// in a well defined ring there will be no closed sections
return smartWrap(box, open, o)
}
|
[
"func",
"Ring",
"(",
"box",
"orb",
".",
"Bound",
",",
"r",
"orb",
".",
"Ring",
",",
"o",
"orb",
".",
"Orientation",
")",
"orb",
".",
"MultiPolygon",
"{",
"if",
"len",
"(",
"r",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"open",
",",
"closed",
":=",
"clipRings",
"(",
"box",
",",
"[",
"]",
"orb",
".",
"Ring",
"{",
"r",
"}",
")",
"\n",
"if",
"len",
"(",
"open",
")",
"==",
"0",
"{",
"// nothing was clipped",
"if",
"len",
"(",
"closed",
")",
"==",
"0",
"{",
"return",
"nil",
"// everything outside bound",
"\n",
"}",
"\n\n",
"return",
"orb",
".",
"MultiPolygon",
"{",
"{",
"r",
"}",
"}",
"// everything inside bound",
"\n",
"}",
"\n\n",
"// in a well defined ring there will be no closed sections",
"return",
"smartWrap",
"(",
"box",
",",
"open",
",",
"o",
")",
"\n",
"}"
] |
// Ring will smart clip a ring to the boundary. This may result multiple rings so
// a multipolygon is possible. Rings that are NOT closed AND have an endpoint in
// the bound will be implicitly closed.
|
[
"Ring",
"will",
"smart",
"clip",
"a",
"ring",
"to",
"the",
"boundary",
".",
"This",
"may",
"result",
"multiple",
"rings",
"so",
"a",
"multipolygon",
"is",
"possible",
".",
"Rings",
"that",
"are",
"NOT",
"closed",
"AND",
"have",
"an",
"endpoint",
"in",
"the",
"bound",
"will",
"be",
"implicitly",
"closed",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L67-L84
|
150,986 |
paulmach/orb
|
clip/smartclip/smart.go
|
Polygon
|
func Polygon(box orb.Bound, p orb.Polygon, o orb.Orientation) orb.MultiPolygon {
if len(p) == 0 {
return nil
}
open, closed := clipRings(box, p)
if len(open) == 0 {
// nothing was clipped
if len(closed) == 0 {
return nil // everything outside bound
}
return orb.MultiPolygon{p} // everything inside bound
}
result := smartWrap(box, open, o)
if len(result) == 1 {
result[0] = append(result[0], closed...)
} else {
for _, i := range closed {
result = addToMultiPolygon(result, i)
}
}
return result
}
|
go
|
func Polygon(box orb.Bound, p orb.Polygon, o orb.Orientation) orb.MultiPolygon {
if len(p) == 0 {
return nil
}
open, closed := clipRings(box, p)
if len(open) == 0 {
// nothing was clipped
if len(closed) == 0 {
return nil // everything outside bound
}
return orb.MultiPolygon{p} // everything inside bound
}
result := smartWrap(box, open, o)
if len(result) == 1 {
result[0] = append(result[0], closed...)
} else {
for _, i := range closed {
result = addToMultiPolygon(result, i)
}
}
return result
}
|
[
"func",
"Polygon",
"(",
"box",
"orb",
".",
"Bound",
",",
"p",
"orb",
".",
"Polygon",
",",
"o",
"orb",
".",
"Orientation",
")",
"orb",
".",
"MultiPolygon",
"{",
"if",
"len",
"(",
"p",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"open",
",",
"closed",
":=",
"clipRings",
"(",
"box",
",",
"p",
")",
"\n",
"if",
"len",
"(",
"open",
")",
"==",
"0",
"{",
"// nothing was clipped",
"if",
"len",
"(",
"closed",
")",
"==",
"0",
"{",
"return",
"nil",
"// everything outside bound",
"\n",
"}",
"\n\n",
"return",
"orb",
".",
"MultiPolygon",
"{",
"p",
"}",
"// everything inside bound",
"\n",
"}",
"\n\n",
"result",
":=",
"smartWrap",
"(",
"box",
",",
"open",
",",
"o",
")",
"\n",
"if",
"len",
"(",
"result",
")",
"==",
"1",
"{",
"result",
"[",
"0",
"]",
"=",
"append",
"(",
"result",
"[",
"0",
"]",
",",
"closed",
"...",
")",
"\n",
"}",
"else",
"{",
"for",
"_",
",",
"i",
":=",
"range",
"closed",
"{",
"result",
"=",
"addToMultiPolygon",
"(",
"result",
",",
"i",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// Polygon will smart clip a polygon to the bound.
// Rings that are NOT closed AND have an endpoint in the bound will be
// implicitly closed.
|
[
"Polygon",
"will",
"smart",
"clip",
"a",
"polygon",
"to",
"the",
"bound",
".",
"Rings",
"that",
"are",
"NOT",
"closed",
"AND",
"have",
"an",
"endpoint",
"in",
"the",
"bound",
"will",
"be",
"implicitly",
"closed",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L89-L114
|
150,987 |
paulmach/orb
|
clip/smartclip/smart.go
|
MultiPolygon
|
func MultiPolygon(box orb.Bound, mp orb.MultiPolygon, o orb.Orientation) orb.MultiPolygon {
if len(mp) == 0 {
return nil
}
// outer rings
outerRings := make([]orb.Ring, 0, len(mp))
for _, p := range mp {
outerRings = append(outerRings, p[0])
}
outers, closedOuters := clipRings(box, outerRings)
if len(outers) == 0 {
// nothing was clipped
if len(closedOuters) == 0 {
return nil // everything outside bound
}
return mp // everything inside bound
}
// inner rings
var innerRings []orb.Ring
for _, p := range mp {
for _, r := range p[1:] {
innerRings = append(innerRings, r)
}
}
inners, closedInners := clipRings(box, innerRings)
// smart wrap everything that touches the edges
result := smartWrap(box, append(outers, inners...), o)
for _, o := range closedOuters {
result = append(result, orb.Polygon{o})
}
for _, i := range closedInners {
result = addToMultiPolygon(result, i)
}
return result
}
|
go
|
func MultiPolygon(box orb.Bound, mp orb.MultiPolygon, o orb.Orientation) orb.MultiPolygon {
if len(mp) == 0 {
return nil
}
// outer rings
outerRings := make([]orb.Ring, 0, len(mp))
for _, p := range mp {
outerRings = append(outerRings, p[0])
}
outers, closedOuters := clipRings(box, outerRings)
if len(outers) == 0 {
// nothing was clipped
if len(closedOuters) == 0 {
return nil // everything outside bound
}
return mp // everything inside bound
}
// inner rings
var innerRings []orb.Ring
for _, p := range mp {
for _, r := range p[1:] {
innerRings = append(innerRings, r)
}
}
inners, closedInners := clipRings(box, innerRings)
// smart wrap everything that touches the edges
result := smartWrap(box, append(outers, inners...), o)
for _, o := range closedOuters {
result = append(result, orb.Polygon{o})
}
for _, i := range closedInners {
result = addToMultiPolygon(result, i)
}
return result
}
|
[
"func",
"MultiPolygon",
"(",
"box",
"orb",
".",
"Bound",
",",
"mp",
"orb",
".",
"MultiPolygon",
",",
"o",
"orb",
".",
"Orientation",
")",
"orb",
".",
"MultiPolygon",
"{",
"if",
"len",
"(",
"mp",
")",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// outer rings",
"outerRings",
":=",
"make",
"(",
"[",
"]",
"orb",
".",
"Ring",
",",
"0",
",",
"len",
"(",
"mp",
")",
")",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"mp",
"{",
"outerRings",
"=",
"append",
"(",
"outerRings",
",",
"p",
"[",
"0",
"]",
")",
"\n",
"}",
"\n\n",
"outers",
",",
"closedOuters",
":=",
"clipRings",
"(",
"box",
",",
"outerRings",
")",
"\n",
"if",
"len",
"(",
"outers",
")",
"==",
"0",
"{",
"// nothing was clipped",
"if",
"len",
"(",
"closedOuters",
")",
"==",
"0",
"{",
"return",
"nil",
"// everything outside bound",
"\n",
"}",
"\n\n",
"return",
"mp",
"// everything inside bound",
"\n",
"}",
"\n\n",
"// inner rings",
"var",
"innerRings",
"[",
"]",
"orb",
".",
"Ring",
"\n",
"for",
"_",
",",
"p",
":=",
"range",
"mp",
"{",
"for",
"_",
",",
"r",
":=",
"range",
"p",
"[",
"1",
":",
"]",
"{",
"innerRings",
"=",
"append",
"(",
"innerRings",
",",
"r",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"inners",
",",
"closedInners",
":=",
"clipRings",
"(",
"box",
",",
"innerRings",
")",
"\n\n",
"// smart wrap everything that touches the edges",
"result",
":=",
"smartWrap",
"(",
"box",
",",
"append",
"(",
"outers",
",",
"inners",
"...",
")",
",",
"o",
")",
"\n",
"for",
"_",
",",
"o",
":=",
"range",
"closedOuters",
"{",
"result",
"=",
"append",
"(",
"result",
",",
"orb",
".",
"Polygon",
"{",
"o",
"}",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"i",
":=",
"range",
"closedInners",
"{",
"result",
"=",
"addToMultiPolygon",
"(",
"result",
",",
"i",
")",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// MultiPolygon will smart clip a multipolygon to the bound.
// Rings that are NOT closed AND have an endpoint in the bound will be
// implicitly closed.
|
[
"MultiPolygon",
"will",
"smart",
"clip",
"a",
"multipolygon",
"to",
"the",
"bound",
".",
"Rings",
"that",
"are",
"NOT",
"closed",
"AND",
"have",
"an",
"endpoint",
"in",
"the",
"bound",
"will",
"be",
"implicitly",
"closed",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L119-L161
|
150,988 |
paulmach/orb
|
clip/smartclip/smart.go
|
clipRings
|
func clipRings(box orb.Bound, rings []orb.Ring) (open []orb.LineString, closed []orb.Ring) {
var result []orb.LineString
for _, r := range rings {
if !r.Closed() && (box.Contains(r[0]) || box.Contains(r[len(r)-1])) {
r = append(r, r[0])
}
out := clip.LineString(box, orb.LineString(r), clip.OpenBound(true))
if len(out) == 0 {
continue // outside of bound
}
if r.Closed() {
// if the input was a closed ring where the endpoints were within the bound,
// then join the sections.
// This operation is O(n^2), however, n is the number of segments, not edges
// so I think it's manageable.
for i := 0; i < len(out); i++ {
end := out[i][len(out[i])-1]
if end[0] == box.Min[0] || box.Max[0] == end[0] ||
end[1] == box.Min[1] || box.Max[1] == end[1] {
// endpoint must be within the bound to try join
continue
}
for j := 0; j < len(out); j++ {
if i == j {
continue
}
if out[j][0] == end {
out[i] = append(out[i], out[j][1:]...)
i--
out[j] = out[len(out)-1]
out = out[:len(out)-1]
}
}
}
}
result = append(result, out...)
}
at := 0
for _, ls := range result {
// closed ring, so completely inside bound
// unless it touches a boundary
if ls[0] == ls[len(ls)-1] && pointSide(box, ls[0]) == notOnSide {
closed = append(closed, orb.Ring(ls))
} else {
result[at] = ls
at++
}
}
return result[:at], closed
}
|
go
|
func clipRings(box orb.Bound, rings []orb.Ring) (open []orb.LineString, closed []orb.Ring) {
var result []orb.LineString
for _, r := range rings {
if !r.Closed() && (box.Contains(r[0]) || box.Contains(r[len(r)-1])) {
r = append(r, r[0])
}
out := clip.LineString(box, orb.LineString(r), clip.OpenBound(true))
if len(out) == 0 {
continue // outside of bound
}
if r.Closed() {
// if the input was a closed ring where the endpoints were within the bound,
// then join the sections.
// This operation is O(n^2), however, n is the number of segments, not edges
// so I think it's manageable.
for i := 0; i < len(out); i++ {
end := out[i][len(out[i])-1]
if end[0] == box.Min[0] || box.Max[0] == end[0] ||
end[1] == box.Min[1] || box.Max[1] == end[1] {
// endpoint must be within the bound to try join
continue
}
for j := 0; j < len(out); j++ {
if i == j {
continue
}
if out[j][0] == end {
out[i] = append(out[i], out[j][1:]...)
i--
out[j] = out[len(out)-1]
out = out[:len(out)-1]
}
}
}
}
result = append(result, out...)
}
at := 0
for _, ls := range result {
// closed ring, so completely inside bound
// unless it touches a boundary
if ls[0] == ls[len(ls)-1] && pointSide(box, ls[0]) == notOnSide {
closed = append(closed, orb.Ring(ls))
} else {
result[at] = ls
at++
}
}
return result[:at], closed
}
|
[
"func",
"clipRings",
"(",
"box",
"orb",
".",
"Bound",
",",
"rings",
"[",
"]",
"orb",
".",
"Ring",
")",
"(",
"open",
"[",
"]",
"orb",
".",
"LineString",
",",
"closed",
"[",
"]",
"orb",
".",
"Ring",
")",
"{",
"var",
"result",
"[",
"]",
"orb",
".",
"LineString",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"rings",
"{",
"if",
"!",
"r",
".",
"Closed",
"(",
")",
"&&",
"(",
"box",
".",
"Contains",
"(",
"r",
"[",
"0",
"]",
")",
"||",
"box",
".",
"Contains",
"(",
"r",
"[",
"len",
"(",
"r",
")",
"-",
"1",
"]",
")",
")",
"{",
"r",
"=",
"append",
"(",
"r",
",",
"r",
"[",
"0",
"]",
")",
"\n",
"}",
"\n",
"out",
":=",
"clip",
".",
"LineString",
"(",
"box",
",",
"orb",
".",
"LineString",
"(",
"r",
")",
",",
"clip",
".",
"OpenBound",
"(",
"true",
")",
")",
"\n",
"if",
"len",
"(",
"out",
")",
"==",
"0",
"{",
"continue",
"// outside of bound",
"\n",
"}",
"\n\n",
"if",
"r",
".",
"Closed",
"(",
")",
"{",
"// if the input was a closed ring where the endpoints were within the bound,",
"// then join the sections.",
"// This operation is O(n^2), however, n is the number of segments, not edges",
"// so I think it's manageable.",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"out",
")",
";",
"i",
"++",
"{",
"end",
":=",
"out",
"[",
"i",
"]",
"[",
"len",
"(",
"out",
"[",
"i",
"]",
")",
"-",
"1",
"]",
"\n",
"if",
"end",
"[",
"0",
"]",
"==",
"box",
".",
"Min",
"[",
"0",
"]",
"||",
"box",
".",
"Max",
"[",
"0",
"]",
"==",
"end",
"[",
"0",
"]",
"||",
"end",
"[",
"1",
"]",
"==",
"box",
".",
"Min",
"[",
"1",
"]",
"||",
"box",
".",
"Max",
"[",
"1",
"]",
"==",
"end",
"[",
"1",
"]",
"{",
"// endpoint must be within the bound to try join",
"continue",
"\n",
"}",
"\n\n",
"for",
"j",
":=",
"0",
";",
"j",
"<",
"len",
"(",
"out",
")",
";",
"j",
"++",
"{",
"if",
"i",
"==",
"j",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"out",
"[",
"j",
"]",
"[",
"0",
"]",
"==",
"end",
"{",
"out",
"[",
"i",
"]",
"=",
"append",
"(",
"out",
"[",
"i",
"]",
",",
"out",
"[",
"j",
"]",
"[",
"1",
":",
"]",
"...",
")",
"\n",
"i",
"--",
"\n\n",
"out",
"[",
"j",
"]",
"=",
"out",
"[",
"len",
"(",
"out",
")",
"-",
"1",
"]",
"\n",
"out",
"=",
"out",
"[",
":",
"len",
"(",
"out",
")",
"-",
"1",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"result",
"=",
"append",
"(",
"result",
",",
"out",
"...",
")",
"\n",
"}",
"\n\n",
"at",
":=",
"0",
"\n",
"for",
"_",
",",
"ls",
":=",
"range",
"result",
"{",
"// closed ring, so completely inside bound",
"// unless it touches a boundary",
"if",
"ls",
"[",
"0",
"]",
"==",
"ls",
"[",
"len",
"(",
"ls",
")",
"-",
"1",
"]",
"&&",
"pointSide",
"(",
"box",
",",
"ls",
"[",
"0",
"]",
")",
"==",
"notOnSide",
"{",
"closed",
"=",
"append",
"(",
"closed",
",",
"orb",
".",
"Ring",
"(",
"ls",
")",
")",
"\n",
"}",
"else",
"{",
"result",
"[",
"at",
"]",
"=",
"ls",
"\n",
"at",
"++",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"[",
":",
"at",
"]",
",",
"closed",
"\n",
"}"
] |
// clipRings will take a set of rings and clip them to the boundary.
// It returns the open lineStrings with endpoints on the boundary and
// the closed interior rings.
|
[
"clipRings",
"will",
"take",
"a",
"set",
"of",
"rings",
"and",
"clip",
"them",
"to",
"the",
"boundary",
".",
"It",
"returns",
"the",
"open",
"lineStrings",
"with",
"endpoints",
"on",
"the",
"boundary",
"and",
"the",
"closed",
"interior",
"rings",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L166-L223
|
150,989 |
paulmach/orb
|
clip/smartclip/smart.go
|
smartWrap
|
func smartWrap(box orb.Bound, input []orb.LineString, o orb.Orientation) orb.MultiPolygon {
points := make([]*endpoint, 0, 2*len(input)+2)
for i, r := range input {
// start
points = append(points, &endpoint{
Point: r[0],
Start: true,
Side: pointSide(box, r[0]),
Index: i,
OtherEnd: 2*i + 1,
})
// end
points = append(points, &endpoint{
Point: r[len(r)-1],
Start: false,
Side: pointSide(box, r[len(r)-1]),
Index: i,
OtherEnd: 2 * i,
})
}
if o == orb.CCW {
sort.Sort(&sortableEndpoints{
mls: input,
eps: points,
})
} else {
sort.Sort(sort.Reverse(&sortableEndpoints{
mls: input,
eps: points,
}))
}
var (
result orb.MultiPolygon
current orb.Ring
)
// this operation is O(n^2). Technically we could use a linked list
// and remove points instead of marking them as "used".
// However since n is 2x the number of segements I think we're okay.
for i := 0; i < 2*len(points); i++ {
ep := points[i%len(points)]
if ep.Used {
continue
}
if !ep.Start {
if len(current) == 0 {
current = orb.Ring(input[ep.Index])
ep.Used = true
}
continue
}
if len(current) == 0 {
continue
}
ep.Used = true
// previous was end, connect to this start
var r orb.Ring
if ep.Point == current[len(current)-1] {
r = emptyTwoRing
} else {
r = aroundBound(box, orb.Ring{ep.Point, current[len(current)-1]}, o)
}
if ep.Point.Equal(current[0]) {
// loop complete!!
current = append(current, r[2:]...)
result = append(result, orb.Polygon{current})
current = nil
i = -1 // start over looking for unused endpoints
} else {
if len(r) > 2 {
current = append(current, r[2:len(r)-1]...)
}
current = append(current, input[ep.Index]...)
points[ep.OtherEnd].Used = true
i = ep.OtherEnd
}
}
return result
}
|
go
|
func smartWrap(box orb.Bound, input []orb.LineString, o orb.Orientation) orb.MultiPolygon {
points := make([]*endpoint, 0, 2*len(input)+2)
for i, r := range input {
// start
points = append(points, &endpoint{
Point: r[0],
Start: true,
Side: pointSide(box, r[0]),
Index: i,
OtherEnd: 2*i + 1,
})
// end
points = append(points, &endpoint{
Point: r[len(r)-1],
Start: false,
Side: pointSide(box, r[len(r)-1]),
Index: i,
OtherEnd: 2 * i,
})
}
if o == orb.CCW {
sort.Sort(&sortableEndpoints{
mls: input,
eps: points,
})
} else {
sort.Sort(sort.Reverse(&sortableEndpoints{
mls: input,
eps: points,
}))
}
var (
result orb.MultiPolygon
current orb.Ring
)
// this operation is O(n^2). Technically we could use a linked list
// and remove points instead of marking them as "used".
// However since n is 2x the number of segements I think we're okay.
for i := 0; i < 2*len(points); i++ {
ep := points[i%len(points)]
if ep.Used {
continue
}
if !ep.Start {
if len(current) == 0 {
current = orb.Ring(input[ep.Index])
ep.Used = true
}
continue
}
if len(current) == 0 {
continue
}
ep.Used = true
// previous was end, connect to this start
var r orb.Ring
if ep.Point == current[len(current)-1] {
r = emptyTwoRing
} else {
r = aroundBound(box, orb.Ring{ep.Point, current[len(current)-1]}, o)
}
if ep.Point.Equal(current[0]) {
// loop complete!!
current = append(current, r[2:]...)
result = append(result, orb.Polygon{current})
current = nil
i = -1 // start over looking for unused endpoints
} else {
if len(r) > 2 {
current = append(current, r[2:len(r)-1]...)
}
current = append(current, input[ep.Index]...)
points[ep.OtherEnd].Used = true
i = ep.OtherEnd
}
}
return result
}
|
[
"func",
"smartWrap",
"(",
"box",
"orb",
".",
"Bound",
",",
"input",
"[",
"]",
"orb",
".",
"LineString",
",",
"o",
"orb",
".",
"Orientation",
")",
"orb",
".",
"MultiPolygon",
"{",
"points",
":=",
"make",
"(",
"[",
"]",
"*",
"endpoint",
",",
"0",
",",
"2",
"*",
"len",
"(",
"input",
")",
"+",
"2",
")",
"\n\n",
"for",
"i",
",",
"r",
":=",
"range",
"input",
"{",
"// start",
"points",
"=",
"append",
"(",
"points",
",",
"&",
"endpoint",
"{",
"Point",
":",
"r",
"[",
"0",
"]",
",",
"Start",
":",
"true",
",",
"Side",
":",
"pointSide",
"(",
"box",
",",
"r",
"[",
"0",
"]",
")",
",",
"Index",
":",
"i",
",",
"OtherEnd",
":",
"2",
"*",
"i",
"+",
"1",
",",
"}",
")",
"\n\n",
"// end",
"points",
"=",
"append",
"(",
"points",
",",
"&",
"endpoint",
"{",
"Point",
":",
"r",
"[",
"len",
"(",
"r",
")",
"-",
"1",
"]",
",",
"Start",
":",
"false",
",",
"Side",
":",
"pointSide",
"(",
"box",
",",
"r",
"[",
"len",
"(",
"r",
")",
"-",
"1",
"]",
")",
",",
"Index",
":",
"i",
",",
"OtherEnd",
":",
"2",
"*",
"i",
",",
"}",
")",
"\n",
"}",
"\n\n",
"if",
"o",
"==",
"orb",
".",
"CCW",
"{",
"sort",
".",
"Sort",
"(",
"&",
"sortableEndpoints",
"{",
"mls",
":",
"input",
",",
"eps",
":",
"points",
",",
"}",
")",
"\n",
"}",
"else",
"{",
"sort",
".",
"Sort",
"(",
"sort",
".",
"Reverse",
"(",
"&",
"sortableEndpoints",
"{",
"mls",
":",
"input",
",",
"eps",
":",
"points",
",",
"}",
")",
")",
"\n",
"}",
"\n\n",
"var",
"(",
"result",
"orb",
".",
"MultiPolygon",
"\n",
"current",
"orb",
".",
"Ring",
"\n",
")",
"\n\n",
"// this operation is O(n^2). Technically we could use a linked list",
"// and remove points instead of marking them as \"used\".",
"// However since n is 2x the number of segements I think we're okay.",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"2",
"*",
"len",
"(",
"points",
")",
";",
"i",
"++",
"{",
"ep",
":=",
"points",
"[",
"i",
"%",
"len",
"(",
"points",
")",
"]",
"\n",
"if",
"ep",
".",
"Used",
"{",
"continue",
"\n",
"}",
"\n\n",
"if",
"!",
"ep",
".",
"Start",
"{",
"if",
"len",
"(",
"current",
")",
"==",
"0",
"{",
"current",
"=",
"orb",
".",
"Ring",
"(",
"input",
"[",
"ep",
".",
"Index",
"]",
")",
"\n",
"ep",
".",
"Used",
"=",
"true",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n\n",
"if",
"len",
"(",
"current",
")",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n",
"ep",
".",
"Used",
"=",
"true",
"\n\n",
"// previous was end, connect to this start",
"var",
"r",
"orb",
".",
"Ring",
"\n",
"if",
"ep",
".",
"Point",
"==",
"current",
"[",
"len",
"(",
"current",
")",
"-",
"1",
"]",
"{",
"r",
"=",
"emptyTwoRing",
"\n",
"}",
"else",
"{",
"r",
"=",
"aroundBound",
"(",
"box",
",",
"orb",
".",
"Ring",
"{",
"ep",
".",
"Point",
",",
"current",
"[",
"len",
"(",
"current",
")",
"-",
"1",
"]",
"}",
",",
"o",
")",
"\n",
"}",
"\n\n",
"if",
"ep",
".",
"Point",
".",
"Equal",
"(",
"current",
"[",
"0",
"]",
")",
"{",
"// loop complete!!",
"current",
"=",
"append",
"(",
"current",
",",
"r",
"[",
"2",
":",
"]",
"...",
")",
"\n",
"result",
"=",
"append",
"(",
"result",
",",
"orb",
".",
"Polygon",
"{",
"current",
"}",
")",
"\n",
"current",
"=",
"nil",
"\n\n",
"i",
"=",
"-",
"1",
"// start over looking for unused endpoints",
"\n",
"}",
"else",
"{",
"if",
"len",
"(",
"r",
")",
">",
"2",
"{",
"current",
"=",
"append",
"(",
"current",
",",
"r",
"[",
"2",
":",
"len",
"(",
"r",
")",
"-",
"1",
"]",
"...",
")",
"\n",
"}",
"\n",
"current",
"=",
"append",
"(",
"current",
",",
"input",
"[",
"ep",
".",
"Index",
"]",
"...",
")",
"\n\n",
"points",
"[",
"ep",
".",
"OtherEnd",
"]",
".",
"Used",
"=",
"true",
"\n",
"i",
"=",
"ep",
".",
"OtherEnd",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"result",
"\n",
"}"
] |
// smartWrap takes the open lineStrings with endpoints on the boundary and
// connects them correctly.
|
[
"smartWrap",
"takes",
"the",
"open",
"lineStrings",
"with",
"endpoints",
"on",
"the",
"boundary",
"and",
"connects",
"them",
"correctly",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L248-L337
|
150,990 |
paulmach/orb
|
clip/smartclip/smart.go
|
pointSide
|
func pointSide(b orb.Bound, p orb.Point) uint8 {
if p[1] == b.Max[1] {
return 4
} else if p[1] == b.Min[1] {
return 2
} else if p[0] == b.Max[0] {
return 3
} else if p[0] == b.Min[0] {
return 1
}
return notOnSide
}
|
go
|
func pointSide(b orb.Bound, p orb.Point) uint8 {
if p[1] == b.Max[1] {
return 4
} else if p[1] == b.Min[1] {
return 2
} else if p[0] == b.Max[0] {
return 3
} else if p[0] == b.Min[0] {
return 1
}
return notOnSide
}
|
[
"func",
"pointSide",
"(",
"b",
"orb",
".",
"Bound",
",",
"p",
"orb",
".",
"Point",
")",
"uint8",
"{",
"if",
"p",
"[",
"1",
"]",
"==",
"b",
".",
"Max",
"[",
"1",
"]",
"{",
"return",
"4",
"\n",
"}",
"else",
"if",
"p",
"[",
"1",
"]",
"==",
"b",
".",
"Min",
"[",
"1",
"]",
"{",
"return",
"2",
"\n",
"}",
"else",
"if",
"p",
"[",
"0",
"]",
"==",
"b",
".",
"Max",
"[",
"0",
"]",
"{",
"return",
"3",
"\n",
"}",
"else",
"if",
"p",
"[",
"0",
"]",
"==",
"b",
".",
"Min",
"[",
"0",
"]",
"{",
"return",
"1",
"\n",
"}",
"\n\n",
"return",
"notOnSide",
"\n",
"}"
] |
// 4
// +-+
// 1 | | 3
// +-+
// 2
|
[
"4",
"+",
"-",
"+",
"1",
"|",
"|",
"3",
"+",
"-",
"+",
"2"
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L346-L358
|
150,991 |
paulmach/orb
|
clip/smartclip/smart.go
|
Less
|
func (e *sortableEndpoints) Less(i, j int) bool {
if e.eps[i].Side != e.eps[j].Side {
return e.eps[i].Side < e.eps[j].Side
}
switch e.eps[i].Side {
case 1:
if e.eps[i].Point[1] != e.eps[j].Point[1] {
return e.eps[i].Point[1] >= e.eps[j].Point[1]
}
return e.eps[i].Before(e.mls)[1] >= e.eps[j].Before(e.mls)[1]
case 2:
if e.eps[i].Point[0] != e.eps[j].Point[0] {
return e.eps[i].Point[0] < e.eps[j].Point[0]
}
return e.eps[i].Before(e.mls)[0] < e.eps[j].Before(e.mls)[0]
case 3:
if e.eps[i].Point[1] != e.eps[j].Point[1] {
return e.eps[i].Point[1] < e.eps[j].Point[1]
}
return e.eps[i].Before(e.mls)[1] < e.eps[j].Before(e.mls)[1]
case 4:
if e.eps[i].Point[0] != e.eps[j].Point[0] {
return e.eps[i].Point[0] >= e.eps[j].Point[0]
}
return e.eps[i].Before(e.mls)[0] >= e.eps[j].Before(e.mls)[0]
}
panic("unreachable")
}
|
go
|
func (e *sortableEndpoints) Less(i, j int) bool {
if e.eps[i].Side != e.eps[j].Side {
return e.eps[i].Side < e.eps[j].Side
}
switch e.eps[i].Side {
case 1:
if e.eps[i].Point[1] != e.eps[j].Point[1] {
return e.eps[i].Point[1] >= e.eps[j].Point[1]
}
return e.eps[i].Before(e.mls)[1] >= e.eps[j].Before(e.mls)[1]
case 2:
if e.eps[i].Point[0] != e.eps[j].Point[0] {
return e.eps[i].Point[0] < e.eps[j].Point[0]
}
return e.eps[i].Before(e.mls)[0] < e.eps[j].Before(e.mls)[0]
case 3:
if e.eps[i].Point[1] != e.eps[j].Point[1] {
return e.eps[i].Point[1] < e.eps[j].Point[1]
}
return e.eps[i].Before(e.mls)[1] < e.eps[j].Before(e.mls)[1]
case 4:
if e.eps[i].Point[0] != e.eps[j].Point[0] {
return e.eps[i].Point[0] >= e.eps[j].Point[0]
}
return e.eps[i].Before(e.mls)[0] >= e.eps[j].Before(e.mls)[0]
}
panic("unreachable")
}
|
[
"func",
"(",
"e",
"*",
"sortableEndpoints",
")",
"Less",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"if",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Side",
"!=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Side",
"{",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Side",
"<",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Side",
"\n",
"}",
"\n\n",
"switch",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Side",
"{",
"case",
"1",
":",
"if",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"1",
"]",
"!=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"1",
"]",
"{",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"1",
"]",
">=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"1",
"]",
"\n",
"}",
"\n\n",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"1",
"]",
">=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"1",
"]",
"\n",
"case",
"2",
":",
"if",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"0",
"]",
"!=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"0",
"]",
"{",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"0",
"]",
"<",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"0",
"]",
"<",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"0",
"]",
"\n",
"case",
"3",
":",
"if",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"1",
"]",
"!=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"1",
"]",
"{",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"1",
"]",
"<",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"1",
"]",
"\n",
"}",
"\n",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"1",
"]",
"<",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"1",
"]",
"\n",
"case",
"4",
":",
"if",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"0",
"]",
"!=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"0",
"]",
"{",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Point",
"[",
"0",
"]",
">=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Point",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"return",
"e",
".",
"eps",
"[",
"i",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"0",
"]",
">=",
"e",
".",
"eps",
"[",
"j",
"]",
".",
"Before",
"(",
"e",
".",
"mls",
")",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}"
] |
// Less sorts the points around the bound.
// First comparing what side it's on and then the actual point to determine the order.
// If two points are the same, we sort by the edge attached to the point so lines that are
// "above" are shorted first.
|
[
"Less",
"sorts",
"the",
"points",
"around",
"the",
"bound",
".",
"First",
"comparing",
"what",
"side",
"it",
"s",
"on",
"and",
"then",
"the",
"actual",
"point",
"to",
"determine",
"the",
"order",
".",
"If",
"two",
"points",
"are",
"the",
"same",
"we",
"sort",
"by",
"the",
"edge",
"attached",
"to",
"the",
"point",
"so",
"lines",
"that",
"are",
"above",
"are",
"shorted",
"first",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L373-L405
|
150,992 |
paulmach/orb
|
clip/smartclip/smart.go
|
addToMultiPolygon
|
func addToMultiPolygon(mp orb.MultiPolygon, ring orb.Ring) orb.MultiPolygon {
for i := range mp {
if polygonContains(mp[i][0], ring) {
mp[i] = append(mp[i], ring)
return mp
}
}
// ring is not in any polygons?
// skip it, TODO: is this correct?
// If input is well formed, I think it is. If it isn't, ¯\_(ツ)_/¯
return mp
}
|
go
|
func addToMultiPolygon(mp orb.MultiPolygon, ring orb.Ring) orb.MultiPolygon {
for i := range mp {
if polygonContains(mp[i][0], ring) {
mp[i] = append(mp[i], ring)
return mp
}
}
// ring is not in any polygons?
// skip it, TODO: is this correct?
// If input is well formed, I think it is. If it isn't, ¯\_(ツ)_/¯
return mp
}
|
[
"func",
"addToMultiPolygon",
"(",
"mp",
"orb",
".",
"MultiPolygon",
",",
"ring",
"orb",
".",
"Ring",
")",
"orb",
".",
"MultiPolygon",
"{",
"for",
"i",
":=",
"range",
"mp",
"{",
"if",
"polygonContains",
"(",
"mp",
"[",
"i",
"]",
"[",
"0",
"]",
",",
"ring",
")",
"{",
"mp",
"[",
"i",
"]",
"=",
"append",
"(",
"mp",
"[",
"i",
"]",
",",
"ring",
")",
"\n",
"return",
"mp",
"\n",
"}",
"\n",
"}",
"\n\n",
"// ring is not in any polygons?",
"// skip it, TODO: is this correct?",
"// If input is well formed, I think it is. If it isn't, ¯\\_(ツ)_/¯",
"return",
"mp",
"\n",
"}"
] |
// addToMultiPolygon does a lookup to see which polygon the ring intersects.
// This should work fine if the input is well formed.
|
[
"addToMultiPolygon",
"does",
"a",
"lookup",
"to",
"see",
"which",
"polygon",
"the",
"ring",
"intersects",
".",
"This",
"should",
"work",
"fine",
"if",
"the",
"input",
"is",
"well",
"formed",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/clip/smartclip/smart.go#L414-L427
|
150,993 |
paulmach/orb
|
bound.go
|
ToRing
|
func (b Bound) ToRing() Ring {
return Ring{
b.Min,
Point{b.Max[0], b.Min[1]},
b.Max,
Point{b.Min[0], b.Max[1]},
b.Min,
}
}
|
go
|
func (b Bound) ToRing() Ring {
return Ring{
b.Min,
Point{b.Max[0], b.Min[1]},
b.Max,
Point{b.Min[0], b.Max[1]},
b.Min,
}
}
|
[
"func",
"(",
"b",
"Bound",
")",
"ToRing",
"(",
")",
"Ring",
"{",
"return",
"Ring",
"{",
"b",
".",
"Min",
",",
"Point",
"{",
"b",
".",
"Max",
"[",
"0",
"]",
",",
"b",
".",
"Min",
"[",
"1",
"]",
"}",
",",
"b",
".",
"Max",
",",
"Point",
"{",
"b",
".",
"Min",
"[",
"0",
"]",
",",
"b",
".",
"Max",
"[",
"1",
"]",
"}",
",",
"b",
".",
"Min",
",",
"}",
"\n",
"}"
] |
// ToRing converts the bound into a loop defined
// by the boundary of the box.
|
[
"ToRing",
"converts",
"the",
"bound",
"into",
"a",
"loop",
"defined",
"by",
"the",
"boundary",
"of",
"the",
"box",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L33-L41
|
150,994 |
paulmach/orb
|
bound.go
|
Union
|
func (b Bound) Union(other Bound) Bound {
if other.IsEmpty() {
return b
}
b = b.Extend(other.Min)
b = b.Extend(other.Max)
b = b.Extend(other.LeftTop())
b = b.Extend(other.RightBottom())
return b
}
|
go
|
func (b Bound) Union(other Bound) Bound {
if other.IsEmpty() {
return b
}
b = b.Extend(other.Min)
b = b.Extend(other.Max)
b = b.Extend(other.LeftTop())
b = b.Extend(other.RightBottom())
return b
}
|
[
"func",
"(",
"b",
"Bound",
")",
"Union",
"(",
"other",
"Bound",
")",
"Bound",
"{",
"if",
"other",
".",
"IsEmpty",
"(",
")",
"{",
"return",
"b",
"\n",
"}",
"\n\n",
"b",
"=",
"b",
".",
"Extend",
"(",
"other",
".",
"Min",
")",
"\n",
"b",
"=",
"b",
".",
"Extend",
"(",
"other",
".",
"Max",
")",
"\n",
"b",
"=",
"b",
".",
"Extend",
"(",
"other",
".",
"LeftTop",
"(",
")",
")",
"\n",
"b",
"=",
"b",
".",
"Extend",
"(",
"other",
".",
"RightBottom",
"(",
")",
")",
"\n\n",
"return",
"b",
"\n",
"}"
] |
// Union extends this bound to contain the union of this and the given bound.
|
[
"Union",
"extends",
"this",
"bound",
"to",
"contain",
"the",
"union",
"of",
"this",
"and",
"the",
"given",
"bound",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L63-L74
|
150,995 |
paulmach/orb
|
bound.go
|
Pad
|
func (b Bound) Pad(d float64) Bound {
b.Min[0] -= d
b.Min[1] -= d
b.Max[0] += d
b.Max[1] += d
return b
}
|
go
|
func (b Bound) Pad(d float64) Bound {
b.Min[0] -= d
b.Min[1] -= d
b.Max[0] += d
b.Max[1] += d
return b
}
|
[
"func",
"(",
"b",
"Bound",
")",
"Pad",
"(",
"d",
"float64",
")",
"Bound",
"{",
"b",
".",
"Min",
"[",
"0",
"]",
"-=",
"d",
"\n",
"b",
".",
"Min",
"[",
"1",
"]",
"-=",
"d",
"\n\n",
"b",
".",
"Max",
"[",
"0",
"]",
"+=",
"d",
"\n",
"b",
".",
"Max",
"[",
"1",
"]",
"+=",
"d",
"\n\n",
"return",
"b",
"\n",
"}"
] |
// Pad extends the bound in all directions by the given value.
|
[
"Pad",
"extends",
"the",
"bound",
"in",
"all",
"directions",
"by",
"the",
"given",
"value",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L104-L112
|
150,996 |
paulmach/orb
|
bound.go
|
Center
|
func (b Bound) Center() Point {
return Point{
(b.Min[0] + b.Max[0]) / 2.0,
(b.Min[1] + b.Max[1]) / 2.0,
}
}
|
go
|
func (b Bound) Center() Point {
return Point{
(b.Min[0] + b.Max[0]) / 2.0,
(b.Min[1] + b.Max[1]) / 2.0,
}
}
|
[
"func",
"(",
"b",
"Bound",
")",
"Center",
"(",
")",
"Point",
"{",
"return",
"Point",
"{",
"(",
"b",
".",
"Min",
"[",
"0",
"]",
"+",
"b",
".",
"Max",
"[",
"0",
"]",
")",
"/",
"2.0",
",",
"(",
"b",
".",
"Min",
"[",
"1",
"]",
"+",
"b",
".",
"Max",
"[",
"1",
"]",
")",
"/",
"2.0",
",",
"}",
"\n",
"}"
] |
// Center returns the center of the bounds by "averaging" the x and y coords.
|
[
"Center",
"returns",
"the",
"center",
"of",
"the",
"bounds",
"by",
"averaging",
"the",
"x",
"and",
"y",
"coords",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L115-L120
|
150,997 |
paulmach/orb
|
bound.go
|
IsEmpty
|
func (b Bound) IsEmpty() bool {
return b.Min[0] > b.Max[0] || b.Min[1] > b.Max[1]
}
|
go
|
func (b Bound) IsEmpty() bool {
return b.Min[0] > b.Max[0] || b.Min[1] > b.Max[1]
}
|
[
"func",
"(",
"b",
"Bound",
")",
"IsEmpty",
"(",
")",
"bool",
"{",
"return",
"b",
".",
"Min",
"[",
"0",
"]",
">",
"b",
".",
"Max",
"[",
"0",
"]",
"||",
"b",
".",
"Min",
"[",
"1",
"]",
">",
"b",
".",
"Max",
"[",
"1",
"]",
"\n",
"}"
] |
// IsEmpty returns true if it contains zero area or if
// it's in some malformed negative state where the left point is larger than the right.
// This can be caused by padding too much negative.
|
[
"IsEmpty",
"returns",
"true",
"if",
"it",
"contains",
"zero",
"area",
"or",
"if",
"it",
"s",
"in",
"some",
"malformed",
"negative",
"state",
"where",
"the",
"left",
"point",
"is",
"larger",
"than",
"the",
"right",
".",
"This",
"can",
"be",
"caused",
"by",
"padding",
"too",
"much",
"negative",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L155-L157
|
150,998 |
paulmach/orb
|
bound.go
|
IsZero
|
func (b Bound) IsZero() bool {
return b.Max == Point{} && b.Min == Point{}
}
|
go
|
func (b Bound) IsZero() bool {
return b.Max == Point{} && b.Min == Point{}
}
|
[
"func",
"(",
"b",
"Bound",
")",
"IsZero",
"(",
")",
"bool",
"{",
"return",
"b",
".",
"Max",
"==",
"Point",
"{",
"}",
"&&",
"b",
".",
"Min",
"==",
"Point",
"{",
"}",
"\n",
"}"
] |
// IsZero return true if the bound just includes just null island.
|
[
"IsZero",
"return",
"true",
"if",
"the",
"bound",
"just",
"includes",
"just",
"null",
"island",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L160-L162
|
150,999 |
paulmach/orb
|
bound.go
|
Equal
|
func (b Bound) Equal(c Bound) bool {
return b.Min == c.Min && b.Max == c.Max
}
|
go
|
func (b Bound) Equal(c Bound) bool {
return b.Min == c.Min && b.Max == c.Max
}
|
[
"func",
"(",
"b",
"Bound",
")",
"Equal",
"(",
"c",
"Bound",
")",
"bool",
"{",
"return",
"b",
".",
"Min",
"==",
"c",
".",
"Min",
"&&",
"b",
".",
"Max",
"==",
"c",
".",
"Max",
"\n",
"}"
] |
// Equal returns if two bounds are equal.
|
[
"Equal",
"returns",
"if",
"two",
"bounds",
"are",
"equal",
"."
] |
c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29
|
https://github.com/paulmach/orb/blob/c6e407b203494d3b1edb9fd5cae4cf34a4ae0f29/bound.go#L170-L172
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.