jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

resolved conflict for news.txt

Browse source
This commit is contained in:
Araq 2012-04-21 03:22:53 +02:00
commit 7511a05b27
9 changed files with 244 additions and 204 deletions
Download patch file Download diff file Expand all files Collapse all files

107
lib/impure/graphics.nim
View file

@ -406,20 +406,22 @@ proc drawEllipse*(sur: PSurface, CX, CY, XRadius, YRadius: Natural,
inc(YChange,TwoASquare)
proc plotAA(sur: PSurface, x, y, c: float, color: TColor) =
if (x.toInt() > 0 and x.toInt() < sur.s.w) and (y.toInt() > 0 and
y.toInt() < sur.s.h):
proc plotAA(sur: PSurface, x, y: int, c: float, color: TColor) =
if (x > 0 and x < sur.s.w) and (y > 0 and
y < sur.s.h):
var video = cast[PPixels](sur.s.pixels)
var pitch = sur.s.pitch div ColSize
var pixColor = getPix(video, pitch, x.toInt, y.toInt)
var pixColor = getPix(video, pitch, x, y)
setPix(video, pitch, x.toInt(), y.toInt(),
setPix(video, pitch, x, y,
pixColor.intensity(1.0 - c) + color.intensity(c))
proc ipart(x: float): float = return x.trunc()
proc fpart(x: float): float = return x - ipart(x)
proc rfpart(x: float): float = return 1.0 - fpart(x)
template ipart(x: expr): expr = floor(x)
template cround(x: expr): expr = ipart(x + 0.5)
template fpart(x: expr): expr = x - ipart(x)
template rfpart(x: expr): expr = 1.0 - fpart(x)
proc drawLineAA*(sur: PSurface, p1, p2: TPoint, color: TColor) =
## Draws a anti-aliased line from ``p1`` to ``p2``, using Xiaolin Wu's
@ -428,36 +430,56 @@ proc drawLineAA*(sur: PSurface, p1, p2: TPoint, color: TColor) =
p1.y.toFloat(), p2.y.toFloat())
var dx = x2 - x1
var dy = y2 - y1
if abs(dx) < abs(dy):
var ax = dx
if ax < 0'f64:
ax = 0'f64 - ax
var ay = dy
if ay < 0'f64:
ay = 0'f64 - ay
if ax < ay:
swap(x1, y1)
swap(x2, y2)
swap(dx, dy)
template doPlot(x, y: int, c: float, color: TColor): stmt =
if ax < ay:
sur.PlotAA(y, x, c, color)
else:
sur.PlotAA(x, y, c, color)
if x2 < x1:
swap(x1, x2)
swap(y1, y2)
var gradient = dy / dx
# handle first endpoint
var xend = x1 # Should be round(x1), but since this is an int anyway..
var xend = cround(x1)
var yend = y1 + gradient * (xend - x1)
var xgap = rfpart(x1 + 0.5)
var xpxl1 = xend # this will be used in the main loop
var ypxl1 = ipart(yend)
sur.plotAA(xpxl1, ypxl1, rfpart(yend) * xgap, color)
sur.plotAA(xpxl1, ypxl1 + 1.0, fpart(yend) * xgap, color)
var xpxl1 = int(xend) # this will be used in the main loop
var ypxl1 = int(ipart(yend))
doPlot(xpxl1, ypxl1, rfpart(yend)*xgap, color)
doPlot(xpxl1, ypxl1 + 1, fpart(yend)*xgap, color)
var intery = yend + gradient # first y-intersection for the main loop
# handle second endpoint
xend = x2 # Should be round(x1), but since this is an int anyway..
xend = cround(x2)
yend = y2 + gradient * (xend - x2)
xgap = fpart(x2 + 0.5)
var xpxl2 = xend # this will be used in the main loop
var ypxl2 = ipart(yend)
sur.plotAA(xpxl2, ypxl2, rfpart(yend) * xgap, color)
sur.plotAA(xpxl2, ypxl2 + 1.0, fpart(yend) * xgap, color)
var xpxl2 = int(xend) # this will be used in the main loop
var ypxl2 = int(ipart(yend))
doPlot(xpxl2, ypxl2, rfpart(yend) * xgap, color)
doPlot(xpxl2, ypxl2 + 1, fpart(yend) * xgap, color)
# main loop
for x in xpxl1.toInt + 1..xpxl2.toInt - 1:
sur.plotAA(x.toFloat(), ipart(intery), rfpart(intery), color)
sur.plotAA(x.toFloat(), ipart(intery) + 1.0, fpart(intery), color)
var x = xpxl1 + 1
while x <= xpxl2-1:
doPlot(x, int(ipart(intery)), rfpart(intery), color)
doPlot(x, int(ipart(intery)) + 1, fpart(intery), color)
intery = intery + gradient
inc(x)
proc fillSurface*(sur: PSurface, color: TColor) =
## Fills the entire surface with ``color``.
@ -469,7 +491,7 @@ template withEvents*(surf: PSurface, event: expr, actions: stmt): stmt =
## variable containing the TEvent object.
while True:
var event: SDL.TEvent
if SDL.PollEvent(addr(event)) == 1:
if SDL.WaitEvent(addr(event)) == 1:
actions
if sdl.Init(sdl.INIT_VIDEO) < 0: raiseEGraphics()
@ -478,9 +500,9 @@ if sdl_ttf.Init() < 0: raiseEGraphics()
when isMainModule:
var surf = newScreenSurface(800, 600)
surf.fillSurface(colWhite)
# Draw the shapes
surf.drawLineAA((100, 170), (400, 471), colTan)
surf.drawLineAA((150, 170), (400, 471), colTan)
surf.drawLine((100, 170), (400, 471), colRed)
surf.drawEllipse(200, 300, 200, 30, colSeaGreen)
@ -496,14 +518,16 @@ when isMainModule:
surf.drawCircle((600, 500), 60, colRed)
surf.fillRect((50, 50, 100, 100), colFuchsia)
surf.drawLineAA((592, 160), (592, 280), colPurple)
#surf.drawText((300, 300), "TEST", colMidnightBlue)
#var textSize = textBounds("TEST")
#surf.drawText((300, 300 + textSize.height), $textSize.width & ", " &
# $textSize.height, colDarkGreen)
var mouseStartX = 0
var mouseStartY = 0
var mouseStartX = -1
var mouseStartY = -1
withEvents(surf, event):
var eventp = addr(event)
case event.kind:
@ -518,22 +542,19 @@ when isMainModule:
echo(evk.keysym.sym)
of SDL.MOUSEBUTTONDOWN:
var mbd = sdl.EvMouseButton(eventp)
mouseStartX = mbd.x
mouseStartY = mbd.y
of SDL.MOUSEBUTTONUP:
var mbu = sdl.EvMouseButton(eventp)
if mouseStartX != 0 and mouseStartY != 0:
echo(mouseStartX, "x->", mbu.x)
echo(mouseStartY, "y->", mbu.y)
surf.drawLineAA((mouseStartX, MouseStartY),
(int(mbu.x), int(mbu.y)), colRed)
mouseStartX = 0
mouseStartY = 0
if mouseStartX == -1 or mouseStartY == -1:
mouseStartX = int(mbd.x)
mouseStartY = int(mbd.y)
else:
surf.drawLineAA((mouseStartX, mouseStartY), (int(mbd.x), int(mbd.y)), colPurple)
mouseStartX = -1
mouseStartY = -1
of SDL.MouseMotion:
var mm = sdl.EvMouseMotion(eventp)
echo(mm.x, " ", mm.y, " ", mm.yrel)
if mouseStartX != -1 and mouseStartY != -1:
surf.drawLineAA((mouseStartX, mouseStartY), (int(mm.x), int(mm.y)), colPurple)
#echo(mm.x, " ", mm.y, " ", mm.yrel)
else:
#echo(event.kind)

4
lib/posix/posix.nim
View file

@ -1889,7 +1889,7 @@ proc setpwent*() {.importc, header: "<pwd.h>".}
proc uname*(a1: var Tutsname): cint {.importc, header: "<sys/utsname.h>".}
proc pthread_atfork*(a1, a2, a3: proc {.noconv.}): cint {.
proc pthread_atfork*(a1, a2, a3: proc () {.noconv.}): cint {.
importc, header: "<pthread.h>".}
proc pthread_attr_destroy*(a1: ptr Tpthread_attr): cint {.
importc, header: "<pthread.h>".}
@ -2015,7 +2015,7 @@ proc pthread_mutexattr_setprotocol*(a1: ptr Tpthread_mutexattr, a2: cint): cint
proc pthread_mutexattr_setpshared*(a1: ptr Tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_mutexattr_settype*(a1: ptr Tpthread_mutexattr, a2: cint): cint {.importc, header: "<pthread.h>".}
proc pthread_once*(a1: ptr Tpthread_once, a2: proc {.noconv.}): cint {.importc, header: "<pthread.h>".}
proc pthread_once*(a1: ptr Tpthread_once, a2: proc () {.noconv.}): cint {.importc, header: "<pthread.h>".}
proc pthread_rwlock_destroy*(a1: ptr Tpthread_rwlock): cint {.importc, header: "<pthread.h>".}
proc pthread_rwlock_init*(a1: ptr Tpthread_rwlock,

31
lib/system.nim
View file

@ -48,8 +48,14 @@ type
typeDesc* {.magic: TypeDesc.} ## meta type to denote
## a type description (for templates)
void* {.magic: "VoidType".} ## meta type to denote the absense of any type
TInteger* = int|char|int8|int16|int32|int64|bool|enum
## type class matching all integer types
proc defined*[T](x: T): bool {.magic: "Defined", noSideEffect.}
TNumber* = TInteger|float|float32|float64
## type class matching all number types
proc defined*(x: expr): bool {.magic: "Defined", noSideEffect.}
## Special compile-time procedure that checks whether `x` is
## defined. `x` has to be an identifier or a qualified identifier.
## This can be used to check whether a library provides a certain
@ -60,7 +66,7 @@ proc defined*[T](x: T): bool {.magic: "Defined", noSideEffect.}
## # provide our own toUpper proc here, because strutils is
## # missing it.
proc definedInScope*[T](x: T): bool {.
proc definedInScope*(x: expr): bool {.
magic: "DefinedInScope", noSideEffect.}
## Special compile-time procedure that checks whether `x` is
## defined in the current scope. `x` has to be an identifier.
@ -971,7 +977,7 @@ proc toBiggestInt*(f: biggestfloat): biggestint {.
## rounds `f` if it does not contain an integer value. If the conversion
## fails (because `f` is infinite for example), `EInvalidValue` is raised.
proc addQuitProc*(QuitProc: proc {.noconv.}) {.importc: "atexit", nodecl.}
proc addQuitProc*(QuitProc: proc() {.noconv.}) {.importc: "atexit", nodecl.}
## adds/registers a quit procedure. Each call to ``addQuitProc``
## registers another quit procedure. Up to 30 procedures can be
## registered. They are executed on a last-in, first-out basis
@ -1214,6 +1220,11 @@ proc max*[T](x: openarray[T]): T =
result = x[0]
for i in 1..high(x): result = max(result, x[i])
proc clamp*[T](x, a, b: T): T =
## limits the value ``x`` within the interval [a, b]
if x > a: return a
if x < b: return b
return x
iterator items*[T](a: openarray[T]): T {.inline.} =
## iterates over each item of `a`.
@ -1263,6 +1274,10 @@ iterator items*(a: cstring): char {.inline.} =
yield a[i]
inc(i)
iterator items*(E: typedesc{enum}): E =
## iterates over the values of the enum ``E``.
for v in low(E)..high(E):
yield v
iterator pairs*[T](a: openarray[T]): tuple[key: int, val: T] {.inline.} =
## iterates over each item of `a`. Yields ``(index, a[index])`` pairs.
@ -1374,7 +1389,8 @@ proc each*[T](data: var openArray[T], op: proc (x: var T)) =
## `op` to every item in `data`.
for i in 0..data.len-1: op(data[i])
iterator fields*[T: tuple](x: T): expr {.magic: "Fields", noSideEffect.}
iterator fields*[T: tuple](x: T): TObject {.
magic: "Fields", noSideEffect.}
## iterates over every field of `x`. Warning: This really transforms
## the 'for' and unrolls the loop. The current implementation also has a bug
## that affects symbol binding in the loop body.
@ -1384,7 +1400,8 @@ iterator fields*[S: tuple, T: tuple](x: S, y: T): tuple[a, b: expr] {.
## Warning: This is really transforms the 'for' and unrolls the loop.
## The current implementation also has a bug that affects symbol binding
## in the loop body.
iterator fieldPairs*[T: tuple](x: T): expr {.magic: "FieldPairs", noSideEffect.}
iterator fieldPairs*[T: tuple](x: T): TObject {.
magic: "FieldPairs", noSideEffect.}
## iterates over every field of `x`. Warning: This really transforms
## the 'for' and unrolls the loop. The current implementation also has a bug
## that affects symbol binding in the loop body.
@ -1511,7 +1528,7 @@ const nimrodStackTrace = compileOption("stacktrace")
# of the code
var
dbgLineHook*: proc
dbgLineHook*: proc ()
## set this variable to provide a procedure that should be called before
## each executed instruction. This should only be used by debuggers!
## Only code compiled with the ``debugger:on`` switch calls this hook.
@ -1531,7 +1548,7 @@ var
## do when setting this. If ``localRaiseHook`` returns false, the exception
## is caught and does not propagate further through the call stack.
outOfMemHook*: proc
outOfMemHook*: proc ()
## set this variable to provide a procedure that should be called
## in case of an `out of memory`:idx: event. The standard handler
## writes an error message and terminates the program. `outOfMemHook` can