path: root/python-pydraw.spec

%global _empty_manifest_terminate_build 0
Name:		python-pydraw
Version:	2.1.1
Release:	1
Summary:	A package designed to make graphics with Python simple and easy!
License:	MIT License
URL:		https://github.com/pydraw/pydraw
Source0:	https://mirrors.aliyun.com/pypi/web/packages/b9/7a/e1e18fdabc9f67b1a2cb99716882383654a40be1dc37f649529f9cdc86e8/pydraw-2.1.1.tar.gz
BuildArch:	noarch

Requires:	python3-pillow

%description
After importing pydraw, you can write a basic skeleton program like so:
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')  # creates a screen to draw on
fps = 30
running = True
while running:
    screen.update()  # We want to update the screen if we make any changes!
    screen.sleep(1 / fps)  # Limit our updates by a certain time delay, in this case 30fps
                                       # The argument is the delay in milliseconds
screen.exit()  # Must be called at the end of a pydraw program
```
We can create our first object with just one new line:
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')
# Here we create a rectangle at x=50, y=50 that is 50 pixels wide and 50 pixels tall.
# It is top-left anchored. This means that the position is the location of the top left corner.
# It's important to know that pydraw's canvas has the origin in the top left, with
# positive-y at the bottom of the screen, and positive-x to the right of the screen.
box = Rectangle(screen, 50, 50, 50, 50) 
fps = 30
running = True
while running:
    screen.update()
    screen.sleep(1 / fps)
screen.exit()
```
And getting straight to the point, one of pydraw's primary features is incredibly easy user-input detection.
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')
box = Rectangle(screen, 50, 50, 50, 50) 
def mousedown(button, location):
  print(f'Wow, the {button}-button on the mouse!')
def mouseup(button, location):
  print('How un-impressive...')
def keydown(key):
  print(f'Keyboard input is {key} to creating interactive programs!')
def keyup(key):
  print('For when you really just gotta stop moving, keyup is here to save you.')
# All of the above methods must be defined above this statement (because Python):
screen.listen()
# -- As you can see, user input is as simple as defining methods and telling pydraw to listen!
#    This feature has been long overdue for teachers who want to teach Python to their students
#    by making really cool stuff but can't escape how ridiculously input has been handled in the past.
#    Now defining user input is easy to understand and use.
fps = 30
running = True
while running:
    screen.update()
    screen.sleep(1 / fps)
screen.exit()
```
This library supports many modifiers and methods for almost all objects:
```python
# ... code above
box = Rectangle(screen, 50, 50, 50, 50)  # Remember this is (x, y, width, height)!
box.x(box.y())  # set the box's x coordinate to its y coordinate
                # notice how you can access the coordinates or change them with methods.
box.location()  # We can get the Location like this!
box.move(-5, 100)  # move the box by -5 on the x-axis, 100 on the y.
box.moveto(screen.width() / 2, screen.height() / 2)  # move to near the center of the screen
box.width(box.height())  # set the box's width to its height
                         # again, it's important to notice the methods are dual-purpose
box.color(Color('red'))  # let's change the color to red
                         # it's helpful to know that the screen's color is white by default
                         # but, it can be changed with: "screen.color()"
box.border(Color('black'), fill=False)  # now we give the box a black border.
                                        # And we can make it a framed rectangle by setting fill=False
box.rotate(14)  # rotate our box by 14 degrees, clockwise
box.rotation(box.rotation() + 14)  # this is the same as the above line with the rotation method
box.visible(False)  # Hide our box. It is not visible
                    # We can also get the visibility-state by not passing anything
box.remove()  # Just get rid of that old box. We can make a better one soon :)
# code below ...
```
Lastly we can create some other objects and interact with them:
(It's important to note that all the Renderables below can use the methods listed 
above (including `overlaps()` and `contains()`, which we see in the excerpt below) 
except the CustomRenderables: CustomPolygon and Image, which are only supported for
a few.)
```python
# ... code above
not_a_box = Oval(screen, 400, 50, 100, 100, Color('magenta'))  # now we have a beautiful oval
almost_a_box = Triangle(screen, 200, 450, 100, 50, Color('yellow'), rotation=30) # uno dos tres
# ^ Also note that we are setting the color, and also setting the rotation of the triangle,
# but the other parameters are still in the usual format: (x, y, width, height).
# IMPORTANT: Triangle's base is on the left, with the triangle's location as its top corner.
# We can create a regular polygon by specifying a number of sides before the location.
# The constructor is (screen, num_sides, x, y, width, height)!
schrodingers_box = Polygon(screen, 5, 250, 150, 50, 50, border=Color('red'))
# Polygon, like Triangle, will also try to put a vertex as close to the top left as possible,
# so usually you will end up with the base of the polygon at the top.
# We can create an evil polygon like this (we can pass in a list of locations or tuples):
weird_evil_box = CustomPolygon(screen, [(500, 50), (550, 50), (550, 100), (500, 50)])
# ^ The real term for these is "Irregular Polygons". But irregular is hard to type so here we are.
# We can interact with these objects with these methods:
not_a_box.overlaps(almost_a_box)  # Do these objects overlap?
weird_evil_box.contains(Location(525, 75))  # Is this point inside the shape?
schrodingers_box.distance(not_a_box)  # Gets the precise distance between the centers
# code below ...
```
### Text, Images, and Lines
pyDraw has specific APIs for Text, Images, and Lines that will sometimes deviate from the 
standard methods slightly.
#### Text
```python
# ... code above
text = Text(screen, 'Some Cool Text!', screen.width(), screen.height(), Color('purple'))
text.move(-text.width() / 2, -text.height() / 2)  # You can get the width and height to perfectly center
                                                  # any text easily!
text.font('Calibri')
text.rotate(45)  # You can still rotate text if you want :)
text.bold(True)
text.underline(True)
text.strikethrough(False)
# code below ...
```
#### Images
```python
# ... code above
image = Image(screen, 'image.png', screen.width() / 3, screen.height() / 3)
# ^ We can load an image like this, and it will display on teh screen
# Note that we cannot add a size or color without having PIL installed, which will be installed 
# on the system if pydraw is installed via 'pip install pydraw'. If you use the file version of 
# pydraw, 'pydraw.py', you must also install PIL onto the system in order to manipulate images via:
# 'pip install pillow' (Pillow is the fork of PIL, still maintained to this day).
# Now that we know we have PIL installed we can have some fun
image.width(150)
image.height(150)
image.rotate(5)
image.color(Color('red'), alpha=123)
# ^ This will tint the image with a red color, at an alpha level of 123 (default).
# If you increase the alpha, the image will become less visible and the tint-color more so,
# and vice versa.
# code below ...
```
#### Lines
```python
# ... code above
# Let's create a nice line that goes across the screen with a beautiful blue color.
line = Line(screen, 150, 150, screen.width() - 50, screen.height() - 50, color = Color('blue'))
# We can modify the line's thickness:
line.thickness(5)
# We can even rotate the line!
line.rotate(35, point=1)  # Note that here we are specifying which point to rotate AROUND!
# We can use a special feature of lines to make them point at stuff!
line.lookat(another_location)  # SUPER NIFTY!
# code below ...

%package -n python3-pydraw
Summary:	A package designed to make graphics with Python simple and easy!
Provides:	python-pydraw
BuildRequires:	python3-devel
BuildRequires:	python3-setuptools
BuildRequires:	python3-pip
%description -n python3-pydraw
After importing pydraw, you can write a basic skeleton program like so:
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')  # creates a screen to draw on
fps = 30
running = True
while running:
    screen.update()  # We want to update the screen if we make any changes!
    screen.sleep(1 / fps)  # Limit our updates by a certain time delay, in this case 30fps
                                       # The argument is the delay in milliseconds
screen.exit()  # Must be called at the end of a pydraw program
```
We can create our first object with just one new line:
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')
# Here we create a rectangle at x=50, y=50 that is 50 pixels wide and 50 pixels tall.
# It is top-left anchored. This means that the position is the location of the top left corner.
# It's important to know that pydraw's canvas has the origin in the top left, with
# positive-y at the bottom of the screen, and positive-x to the right of the screen.
box = Rectangle(screen, 50, 50, 50, 50) 
fps = 30
running = True
while running:
    screen.update()
    screen.sleep(1 / fps)
screen.exit()
```
And getting straight to the point, one of pydraw's primary features is incredibly easy user-input detection.
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')
box = Rectangle(screen, 50, 50, 50, 50) 
def mousedown(button, location):
  print(f'Wow, the {button}-button on the mouse!')
def mouseup(button, location):
  print('How un-impressive...')
def keydown(key):
  print(f'Keyboard input is {key} to creating interactive programs!')
def keyup(key):
  print('For when you really just gotta stop moving, keyup is here to save you.')
# All of the above methods must be defined above this statement (because Python):
screen.listen()
# -- As you can see, user input is as simple as defining methods and telling pydraw to listen!
#    This feature has been long overdue for teachers who want to teach Python to their students
#    by making really cool stuff but can't escape how ridiculously input has been handled in the past.
#    Now defining user input is easy to understand and use.
fps = 30
running = True
while running:
    screen.update()
    screen.sleep(1 / fps)
screen.exit()
```
This library supports many modifiers and methods for almost all objects:
```python
# ... code above
box = Rectangle(screen, 50, 50, 50, 50)  # Remember this is (x, y, width, height)!
box.x(box.y())  # set the box's x coordinate to its y coordinate
                # notice how you can access the coordinates or change them with methods.
box.location()  # We can get the Location like this!
box.move(-5, 100)  # move the box by -5 on the x-axis, 100 on the y.
box.moveto(screen.width() / 2, screen.height() / 2)  # move to near the center of the screen
box.width(box.height())  # set the box's width to its height
                         # again, it's important to notice the methods are dual-purpose
box.color(Color('red'))  # let's change the color to red
                         # it's helpful to know that the screen's color is white by default
                         # but, it can be changed with: "screen.color()"
box.border(Color('black'), fill=False)  # now we give the box a black border.
                                        # And we can make it a framed rectangle by setting fill=False
box.rotate(14)  # rotate our box by 14 degrees, clockwise
box.rotation(box.rotation() + 14)  # this is the same as the above line with the rotation method
box.visible(False)  # Hide our box. It is not visible
                    # We can also get the visibility-state by not passing anything
box.remove()  # Just get rid of that old box. We can make a better one soon :)
# code below ...
```
Lastly we can create some other objects and interact with them:
(It's important to note that all the Renderables below can use the methods listed 
above (including `overlaps()` and `contains()`, which we see in the excerpt below) 
except the CustomRenderables: CustomPolygon and Image, which are only supported for
a few.)
```python
# ... code above
not_a_box = Oval(screen, 400, 50, 100, 100, Color('magenta'))  # now we have a beautiful oval
almost_a_box = Triangle(screen, 200, 450, 100, 50, Color('yellow'), rotation=30) # uno dos tres
# ^ Also note that we are setting the color, and also setting the rotation of the triangle,
# but the other parameters are still in the usual format: (x, y, width, height).
# IMPORTANT: Triangle's base is on the left, with the triangle's location as its top corner.
# We can create a regular polygon by specifying a number of sides before the location.
# The constructor is (screen, num_sides, x, y, width, height)!
schrodingers_box = Polygon(screen, 5, 250, 150, 50, 50, border=Color('red'))
# Polygon, like Triangle, will also try to put a vertex as close to the top left as possible,
# so usually you will end up with the base of the polygon at the top.
# We can create an evil polygon like this (we can pass in a list of locations or tuples):
weird_evil_box = CustomPolygon(screen, [(500, 50), (550, 50), (550, 100), (500, 50)])
# ^ The real term for these is "Irregular Polygons". But irregular is hard to type so here we are.
# We can interact with these objects with these methods:
not_a_box.overlaps(almost_a_box)  # Do these objects overlap?
weird_evil_box.contains(Location(525, 75))  # Is this point inside the shape?
schrodingers_box.distance(not_a_box)  # Gets the precise distance between the centers
# code below ...
```
### Text, Images, and Lines
pyDraw has specific APIs for Text, Images, and Lines that will sometimes deviate from the 
standard methods slightly.
#### Text
```python
# ... code above
text = Text(screen, 'Some Cool Text!', screen.width(), screen.height(), Color('purple'))
text.move(-text.width() / 2, -text.height() / 2)  # You can get the width and height to perfectly center
                                                  # any text easily!
text.font('Calibri')
text.rotate(45)  # You can still rotate text if you want :)
text.bold(True)
text.underline(True)
text.strikethrough(False)
# code below ...
```
#### Images
```python
# ... code above
image = Image(screen, 'image.png', screen.width() / 3, screen.height() / 3)
# ^ We can load an image like this, and it will display on teh screen
# Note that we cannot add a size or color without having PIL installed, which will be installed 
# on the system if pydraw is installed via 'pip install pydraw'. If you use the file version of 
# pydraw, 'pydraw.py', you must also install PIL onto the system in order to manipulate images via:
# 'pip install pillow' (Pillow is the fork of PIL, still maintained to this day).
# Now that we know we have PIL installed we can have some fun
image.width(150)
image.height(150)
image.rotate(5)
image.color(Color('red'), alpha=123)
# ^ This will tint the image with a red color, at an alpha level of 123 (default).
# If you increase the alpha, the image will become less visible and the tint-color more so,
# and vice versa.
# code below ...
```
#### Lines
```python
# ... code above
# Let's create a nice line that goes across the screen with a beautiful blue color.
line = Line(screen, 150, 150, screen.width() - 50, screen.height() - 50, color = Color('blue'))
# We can modify the line's thickness:
line.thickness(5)
# We can even rotate the line!
line.rotate(35, point=1)  # Note that here we are specifying which point to rotate AROUND!
# We can use a special feature of lines to make them point at stuff!
line.lookat(another_location)  # SUPER NIFTY!
# code below ...

%package help
Summary:	Development documents and examples for pydraw
Provides:	python3-pydraw-doc
%description help
After importing pydraw, you can write a basic skeleton program like so:
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')  # creates a screen to draw on
fps = 30
running = True
while running:
    screen.update()  # We want to update the screen if we make any changes!
    screen.sleep(1 / fps)  # Limit our updates by a certain time delay, in this case 30fps
                                       # The argument is the delay in milliseconds
screen.exit()  # Must be called at the end of a pydraw program
```
We can create our first object with just one new line:
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')
# Here we create a rectangle at x=50, y=50 that is 50 pixels wide and 50 pixels tall.
# It is top-left anchored. This means that the position is the location of the top left corner.
# It's important to know that pydraw's canvas has the origin in the top left, with
# positive-y at the bottom of the screen, and positive-x to the right of the screen.
box = Rectangle(screen, 50, 50, 50, 50) 
fps = 30
running = True
while running:
    screen.update()
    screen.sleep(1 / fps)
screen.exit()
```
And getting straight to the point, one of pydraw's primary features is incredibly easy user-input detection.
```python
from pydraw import *
screen = Screen(800, 600, 'My First Project!')
box = Rectangle(screen, 50, 50, 50, 50) 
def mousedown(button, location):
  print(f'Wow, the {button}-button on the mouse!')
def mouseup(button, location):
  print('How un-impressive...')
def keydown(key):
  print(f'Keyboard input is {key} to creating interactive programs!')
def keyup(key):
  print('For when you really just gotta stop moving, keyup is here to save you.')
# All of the above methods must be defined above this statement (because Python):
screen.listen()
# -- As you can see, user input is as simple as defining methods and telling pydraw to listen!
#    This feature has been long overdue for teachers who want to teach Python to their students
#    by making really cool stuff but can't escape how ridiculously input has been handled in the past.
#    Now defining user input is easy to understand and use.
fps = 30
running = True
while running:
    screen.update()
    screen.sleep(1 / fps)
screen.exit()
```
This library supports many modifiers and methods for almost all objects:
```python
# ... code above
box = Rectangle(screen, 50, 50, 50, 50)  # Remember this is (x, y, width, height)!
box.x(box.y())  # set the box's x coordinate to its y coordinate
                # notice how you can access the coordinates or change them with methods.
box.location()  # We can get the Location like this!
box.move(-5, 100)  # move the box by -5 on the x-axis, 100 on the y.
box.moveto(screen.width() / 2, screen.height() / 2)  # move to near the center of the screen
box.width(box.height())  # set the box's width to its height
                         # again, it's important to notice the methods are dual-purpose
box.color(Color('red'))  # let's change the color to red
                         # it's helpful to know that the screen's color is white by default
                         # but, it can be changed with: "screen.color()"
box.border(Color('black'), fill=False)  # now we give the box a black border.
                                        # And we can make it a framed rectangle by setting fill=False
box.rotate(14)  # rotate our box by 14 degrees, clockwise
box.rotation(box.rotation() + 14)  # this is the same as the above line with the rotation method
box.visible(False)  # Hide our box. It is not visible
                    # We can also get the visibility-state by not passing anything
box.remove()  # Just get rid of that old box. We can make a better one soon :)
# code below ...
```
Lastly we can create some other objects and interact with them:
(It's important to note that all the Renderables below can use the methods listed 
above (including `overlaps()` and `contains()`, which we see in the excerpt below) 
except the CustomRenderables: CustomPolygon and Image, which are only supported for
a few.)
```python
# ... code above
not_a_box = Oval(screen, 400, 50, 100, 100, Color('magenta'))  # now we have a beautiful oval
almost_a_box = Triangle(screen, 200, 450, 100, 50, Color('yellow'), rotation=30) # uno dos tres
# ^ Also note that we are setting the color, and also setting the rotation of the triangle,
# but the other parameters are still in the usual format: (x, y, width, height).
# IMPORTANT: Triangle's base is on the left, with the triangle's location as its top corner.
# We can create a regular polygon by specifying a number of sides before the location.
# The constructor is (screen, num_sides, x, y, width, height)!
schrodingers_box = Polygon(screen, 5, 250, 150, 50, 50, border=Color('red'))
# Polygon, like Triangle, will also try to put a vertex as close to the top left as possible,
# so usually you will end up with the base of the polygon at the top.
# We can create an evil polygon like this (we can pass in a list of locations or tuples):
weird_evil_box = CustomPolygon(screen, [(500, 50), (550, 50), (550, 100), (500, 50)])
# ^ The real term for these is "Irregular Polygons". But irregular is hard to type so here we are.
# We can interact with these objects with these methods:
not_a_box.overlaps(almost_a_box)  # Do these objects overlap?
weird_evil_box.contains(Location(525, 75))  # Is this point inside the shape?
schrodingers_box.distance(not_a_box)  # Gets the precise distance between the centers
# code below ...
```
### Text, Images, and Lines
pyDraw has specific APIs for Text, Images, and Lines that will sometimes deviate from the 
standard methods slightly.
#### Text
```python
# ... code above
text = Text(screen, 'Some Cool Text!', screen.width(), screen.height(), Color('purple'))
text.move(-text.width() / 2, -text.height() / 2)  # You can get the width and height to perfectly center
                                                  # any text easily!
text.font('Calibri')
text.rotate(45)  # You can still rotate text if you want :)
text.bold(True)
text.underline(True)
text.strikethrough(False)
# code below ...
```
#### Images
```python
# ... code above
image = Image(screen, 'image.png', screen.width() / 3, screen.height() / 3)
# ^ We can load an image like this, and it will display on teh screen
# Note that we cannot add a size or color without having PIL installed, which will be installed 
# on the system if pydraw is installed via 'pip install pydraw'. If you use the file version of 
# pydraw, 'pydraw.py', you must also install PIL onto the system in order to manipulate images via:
# 'pip install pillow' (Pillow is the fork of PIL, still maintained to this day).
# Now that we know we have PIL installed we can have some fun
image.width(150)
image.height(150)
image.rotate(5)
image.color(Color('red'), alpha=123)
# ^ This will tint the image with a red color, at an alpha level of 123 (default).
# If you increase the alpha, the image will become less visible and the tint-color more so,
# and vice versa.
# code below ...
```
#### Lines
```python
# ... code above
# Let's create a nice line that goes across the screen with a beautiful blue color.
line = Line(screen, 150, 150, screen.width() - 50, screen.height() - 50, color = Color('blue'))
# We can modify the line's thickness:
line.thickness(5)
# We can even rotate the line!
line.rotate(35, point=1)  # Note that here we are specifying which point to rotate AROUND!
# We can use a special feature of lines to make them point at stuff!
line.lookat(another_location)  # SUPER NIFTY!
# code below ...

%prep
%autosetup -n pydraw-2.1.1

%build
%py3_build

%install
%py3_install
install -d -m755 %{buildroot}/%{_pkgdocdir}
if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
pushd %{buildroot}
if [ -d usr/lib ]; then
	find usr/lib -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/lib64 ]; then
	find usr/lib64 -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/bin ]; then
	find usr/bin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
if [ -d usr/sbin ]; then
	find usr/sbin -type f -printf "\"/%h/%f\"\n" >> filelist.lst
fi
touch doclist.lst
if [ -d usr/share/man ]; then
	find usr/share/man -type f -printf "\"/%h/%f.gz\"\n" >> doclist.lst
fi
popd
mv %{buildroot}/filelist.lst .
mv %{buildroot}/doclist.lst .

%files -n python3-pydraw -f filelist.lst
%dir %{python3_sitelib}/*

%files help -f doclist.lst
%{_docdir}/*

%changelog
* Thu Jun 08 2023 Python_Bot <Python_Bot@openeuler.org> - 2.1.1-1
- Package Spec generated