commit 52f99376eda97a871de4dc143e39879ed1c54ba7 Author: adam Date: Mon Apr 6 14:37:45 2020 +0200 First commit-Adam i grafika diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..73ffb59 --- /dev/null +++ b/.gitignore @@ -0,0 +1,112 @@ + +# Created by https://www.gitignore.io/api/python +# Edit at https://www.gitignore.io/?templates=python + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg + +/idea/workspace.xml +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# pyenv +.python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# Mr Developer +.mr.developer.cfg +.project +.pydevproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# End of https://www.gitignore.io/api/python \ No newline at end of file diff --git a/.idea/ProjektAI.iml b/.idea/ProjektAI.iml new file mode 100644 index 0000000..9c88284 --- /dev/null +++ b/.idea/ProjektAI.iml @@ -0,0 +1,11 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..ef004d1 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..fb0e061 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..9661ac7 --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml new file mode 100644 index 0000000..73e675e --- /dev/null +++ b/.idea/workspace.xml @@ -0,0 +1,59 @@ + + + + + + + + + + + + + + + + + + + + + + 1586110306480 + + + + + + + + + \ No newline at end of file diff --git a/Projekt “Automatyczny kelner ”.pdf b/Projekt “Automatyczny kelner ”.pdf new file mode 100644 index 0000000..d35dabd Binary files /dev/null and b/Projekt “Automatyczny kelner ”.pdf differ diff --git a/kelner/.idea/inspectionProfiles/profiles_settings.xml b/kelner/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/kelner/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/kelner/.idea/kelner.iml b/kelner/.idea/kelner.iml new file mode 100644 index 0000000..f79b4ad --- /dev/null +++ b/kelner/.idea/kelner.iml @@ -0,0 +1,11 @@ + + + + + + + + + + \ No newline at end of file diff --git a/kelner/.idea/misc.xml b/kelner/.idea/misc.xml new file mode 100644 index 0000000..53407e2 --- /dev/null +++ b/kelner/.idea/misc.xml @@ -0,0 +1,7 @@ + + + + + + \ No newline at end of file diff --git a/kelner/.idea/modules.xml b/kelner/.idea/modules.xml new file mode 100644 index 0000000..620b5e5 --- /dev/null +++ b/kelner/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/kelner/.idea/vcs.xml b/kelner/.idea/vcs.xml new file mode 100644 index 0000000..2e3f692 --- /dev/null +++ b/kelner/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/kelner/.idea/workspace.xml b/kelner/.idea/workspace.xml new file mode 100644 index 0000000..108f0f2 --- /dev/null +++ b/kelner/.idea/workspace.xml @@ -0,0 +1,216 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1584822897275 + + + 1584889744892 + + + 1584910332507 + + + 1584910685304 + + + 1585257603366 + + + 1585950875511 + + + + + + + + + + + + + + file://$PROJECT_DIR$/src/managers/DrawableCollection.py + 71 + + + + + + + + + + + + + + \ No newline at end of file diff --git a/kelner/images/Backgroud.png b/kelner/images/Backgroud.png new file mode 100644 index 0000000..91b5444 Binary files /dev/null and b/kelner/images/Backgroud.png differ diff --git a/kelner/images/Untitleda.png b/kelner/images/Untitleda.png new file mode 100644 index 0000000..f9f1991 Binary files /dev/null and b/kelner/images/Untitleda.png differ diff --git a/kelner/images/check.png b/kelner/images/check.png new file mode 100644 index 0000000..5058027 Binary files /dev/null and b/kelner/images/check.png differ diff --git a/kelner/images/drive-download-20200405T181945Z-001.zip b/kelner/images/drive-download-20200405T181945Z-001.zip new file mode 100644 index 0000000..72d8b64 Binary files /dev/null and b/kelner/images/drive-download-20200405T181945Z-001.zip differ diff --git a/kelner/images/kelner.png b/kelner/images/kelner.png new file mode 100644 index 0000000..6e0d499 Binary files /dev/null and b/kelner/images/kelner.png differ diff --git a/kelner/images/ksiazka.png b/kelner/images/ksiazka.png new file mode 100644 index 0000000..3cf2a19 Binary files /dev/null and b/kelner/images/ksiazka.png differ diff --git a/kelner/images/kurczak.png b/kelner/images/kurczak.png new file mode 100644 index 0000000..22af728 Binary files /dev/null and b/kelner/images/kurczak.png differ diff --git a/kelner/images/piwo.png b/kelner/images/piwo.png new file mode 100644 index 0000000..96a207f Binary files /dev/null and b/kelner/images/piwo.png differ diff --git a/kelner/images/plate.png b/kelner/images/plate.png new file mode 100644 index 0000000..6f5173c Binary files /dev/null and b/kelner/images/plate.png differ diff --git a/kelner/images/srcWaiter.png b/kelner/images/srcWaiter.png new file mode 100644 index 0000000..512d036 Binary files /dev/null and b/kelner/images/srcWaiter.png differ diff --git a/kelner/images/stol.png b/kelner/images/stol.png new file mode 100644 index 0000000..bc1e476 Binary files /dev/null and b/kelner/images/stol.png differ diff --git a/kelner/images/waiter.png b/kelner/images/waiter.png new file mode 100644 index 0000000..67722bb Binary files /dev/null and b/kelner/images/waiter.png differ diff --git a/kelner/images/wiking_blond.png b/kelner/images/wiking_blond.png new file mode 100644 index 0000000..ebc4b63 Binary files /dev/null and b/kelner/images/wiking_blond.png differ diff --git a/kelner/images/wiking_rudy.png b/kelner/images/wiking_rudy.png new file mode 100644 index 0000000..0c2e26c Binary files /dev/null and b/kelner/images/wiking_rudy.png differ diff --git a/kelner/images/wiking_rudy2.png b/kelner/images/wiking_rudy2.png new file mode 100644 index 0000000..702e5e8 Binary files /dev/null and b/kelner/images/wiking_rudy2.png differ diff --git a/kelner/main.py b/kelner/main.py new file mode 100644 index 0000000..255061b --- /dev/null +++ b/kelner/main.py @@ -0,0 +1,81 @@ +import pygame +from src.components.GridBoard import GridBoard +from src.managers.DrawableCollection import DrawableCollection +from src.managers.MenuManager import MenuManager +from src.components.Waiter import Waiter +from src.components.Table import Table +from src.managers.TaskManager import TaskManager + +#create screen consts +CellSize = 100 #pixel size of 1 square cell in the grid +GridCountX = 15 #number of columns in grid +GridCountY = 9 #number of rows in grid +ScreenWidth = CellSize * GridCountX #screen width in pixels +ScreenHeight = CellSize * GridCountY #screen height in pixels +Offset = 50 + +#initialize background +gridBoard = GridBoard(ScreenWidth+200, ScreenHeight+200, CellSize) + +#initialize drawable objects manager +drawableManager = DrawableCollection() + +#initialize menu manager +menuManager = MenuManager() + +#initialize waiter component +waiter = Waiter(0, 0, 0, GridCountX - 1, 0, GridCountY - 1, CellSize) + +#adds waiter to drawable collection +drawableManager.add(waiter) + +#initialize a number of tables given in range +for i in range(1, 20): + table = Table(0, GridCountX - 1, 0, GridCountY - 1, CellSize) + drawableManager.generatePosition(table) + drawableManager.add(table) + +#main loop + +#object that controlls repainting of changed objects +doRepaint = [True] + +#new thread +task = TaskManager(drawableManager, menuManager, doRepaint) +task.start() + +running = True +while running: + + for event in pygame.event.get(): + if event.type == pygame.QUIT: + running = False + + #handles keyboard events + if event.type == pygame.KEYDOWN: + if event.key == pygame.K_LEFT: + #checks if new waiter's position to the left is not occupied by other object + if drawableManager.isPositionAvailable(waiter.getX() - 1, waiter.getY()): + waiter.moveLeft() + if event.key == pygame.K_RIGHT: + # checks if new waiter's position to the right is not occupied by other object + if drawableManager.isPositionAvailable(waiter.getX() + 1, waiter.getY()): + waiter.moveRight() + if event.key == pygame.K_UP: + # checks if new waiter's position up is not occupied by other object + if drawableManager.isPositionAvailable(waiter.getX(), waiter.getY() - 1): + waiter.moveUp() + if event.key == pygame.K_DOWN: + # checks if new waiter's position down is not occupied by other object + if drawableManager.isPositionAvailable(waiter.getX(), waiter.getY() + 1): + waiter.moveDown() + doRepaint[0] = True + + # repaints all objects to the screen + # is set only on initial paint or after keyboard event + if doRepaint[0]: + gridBoard.reinitialize() + gridBoard.draw(drawableManager) + gridBoard.udpdate() + doRepaint[0] = False + drawableManager.collectOrders() \ No newline at end of file diff --git a/kelner/src/components/Drawable.py b/kelner/src/components/Drawable.py new file mode 100644 index 0000000..6af5eb9 --- /dev/null +++ b/kelner/src/components/Drawable.py @@ -0,0 +1,53 @@ +class Drawable: + + GREY = (128, 128, 128) + YELLOW = (255, 255, 0) + RED = (255, 0, 0) + GREEN = (0, 255, 0) + + def __init__(self, x, y, minX, maxX, minY, maxY, ratio): + self.__minX = minX + self.__maxX = maxX + self.__minY = minY + self.__maxY = maxY + self.setX(x) + self.setY(y) + self.__ratio = ratio #cell size + + def setX(self, x): + if (x < self.__minX or self.__maxX < x): + return False + else: + self.__x = x + return True + + def setY(self, y): + if (y < self.__minY or self.__maxY < y): + return False + else: + self.__y = y + return True + + def getX(self): + return self.__x + + def getY(self): + return self.__y + + def getMinX(self): + return self.__minX + + def getMaxX(self): + return self.__maxX + + def getMinY(self): + return self.__minY + + def getMaxY(self): + return self.__maxY + + def getRatio(self): + return self.__ratio + + def draw(self, screen): + pass \ No newline at end of file diff --git a/kelner/src/components/GridBoard.py b/kelner/src/components/GridBoard.py new file mode 100644 index 0000000..8f848fc --- /dev/null +++ b/kelner/src/components/GridBoard.py @@ -0,0 +1,28 @@ +import pygame + +class GridBoard: + + def __init__(self, width, height, cellSize): + pygame.init() #initialize the pygame + pygame.display.set_caption("Bardzo mądry kelner") #window caption + self.__width = width + self.__height = height + self.__cellSize = cellSize + self.__screen = pygame.display.set_mode((width, height)) # initialize screen + self.Offset = 50 + + #fills the screen with white and draws grid + def reinitialize(self): + self.__screen.fill((255, 255, 255)) + for x in range(0, self.__width, self.__cellSize): + pygame.draw.line(self.__screen, (0,0,0), (x,0), (x,(self.__height - 1))) + for y in range(0, self.__height, self.__cellSize): + pygame.draw.line(self.__screen, (0,0,0), (0,y), ((self.__width - 1),y)) + + #draws object on screen + def draw(self, component): + component.draw(self.__screen) + + #updates screen + def udpdate(self): + pygame.display.update() \ No newline at end of file diff --git a/kelner/src/components/Table.py b/kelner/src/components/Table.py new file mode 100644 index 0000000..0b6de38 --- /dev/null +++ b/kelner/src/components/Table.py @@ -0,0 +1,98 @@ +import pygame +from enum import Enum +from .Drawable import Drawable +import random + +class Table(Drawable): + + def __init__(self, minX, maxX, minY, maxY, ratio): + #call base class constructor + Drawable.__init__(self, 0, 0, minX, maxX, minY, maxY, ratio) + self.__order = [] + self.__status = Status.NotReady + self.ilosc_klientow = random.randint(1,3) + self.guest1 = self.getGuest() + self.guest2 = self.getGuest() + self.guest3 = self.getGuest() + self.ksiazka = self.__loadImg('./images/ksiazka.png') + self.stol = self.__loadImg('./images/stol.png') + self.check = self.__loadImg('./images/check.png') + self.plate = self.__loadImg('./images/plate.png') + self.Offset = 100 + + #sets table color based on it's status + def getColor(self): + color = None + if self.__status == Status.NotReady: + color = self.__loadImg('./images/stol.png') + elif self.__status == Status.Ready: + color = self.__loadImg('./images/kelner.png') + elif self.__status == Status.Waiting: + color = self.__loadImg('./images/kelner.png') + elif self.__status == Status.Served: + color = self.__loadImg('./images/kelner.png') + return color + + def getGuest(self): + guest = None + i = random.randint(1,3) + if i == 1: + guest = self.__loadImg('./images/wiking_blond.png') + elif i == 2: + guest = self.__loadImg('./images/wiking_rudy.png') + elif i == 3: + guest = self.__loadImg('./images/wiking_rudy2.png') + return guest + + def __loadImg(self, filePath): + return pygame.transform.scale((pygame.image.load(filePath)),(140,140)) + + def draw(self, screen): + screen.blit(self.stol, (self.getX() * 100-20+self.Offset, self.getY() * 100-20+self.Offset)) + if self.ilosc_klientow == 1: + screen.blit(self.guest1, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 60+self.Offset)) + elif self.ilosc_klientow == 2: + screen.blit(self.guest1, (self.getX() * 100 - 62+self.Offset, self.getY() * 100 - 60+self.Offset)) + screen.blit(self.guest2, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 60+self.Offset)) + elif self.ilosc_klientow == 3: + screen.blit(self.guest1, (self.getX() * 100 - 62+self.Offset, self.getY() * 100 - 60+self.Offset)) + screen.blit(self.guest2, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 60+self.Offset)) + screen.blit(self.guest3, (self.getX() * 100 + 22+self.Offset, self.getY() * 100 - 60+self.Offset)) + + if self.__status == Status.NotReady: + screen.blit(self.ksiazka, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 20+self.Offset)) + elif self.__status == Status.Ready: + screen.blit(self.check, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 20+self.Offset)) + elif self.__status == Status.Waiting: + if self.ilosc_klientow == 1: + screen.blit(self.plate, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 20+self.Offset)) + elif self.ilosc_klientow == 2: + screen.blit(self.plate, (self.getX() * 100 - 62+self.Offset, self.getY() * 100 - 20+self.Offset)) + screen.blit(self.plate, (self.getX() * 100 - 20+self.Offset, self.getY() * 100 - 20+self.Offset)) + elif self.ilosc_klientow == 3: + screen.blit(self.plate, (self.getX() * 100 - 62+self.Offset, self.getY() * 100 - 20+self.Offset)) + screen.blit(self.plate, (self.getX() * 100- 20+self.Offset, self.getY() * 100 - 20+self.Offset)) + screen.blit(self.plate, (self.getX() * 100+ 22+self.Offset, self.getY() * 100 - 20+self.Offset)) + + + def setOrder(self, order): + self.__order = order + + def getOrder(self): + return self.__order + + def delOrder(self): + self.setOrder([]) + + def isStatus(self, status): + return status == self.__status + + def setStatus(self, status): + self.__status = status + +#status of the table +class Status(Enum): + NotReady = 0 + Ready = 1 + Waiting = 2 + Served = 3 \ No newline at end of file diff --git a/kelner/src/components/Waiter.py b/kelner/src/components/Waiter.py new file mode 100644 index 0000000..9b64ed0 --- /dev/null +++ b/kelner/src/components/Waiter.py @@ -0,0 +1,50 @@ +import pygame +from .Drawable import Drawable + +class Waiter(Drawable): + + def __init__(self, x, y, minX, maxX, minY, maxY, ratio): + #call base class constructor + Drawable.__init__(self, x, y, minX, maxX, minY, maxY, ratio) + self.__image = self.__loadImg('./images/kelner.png') + self.__acceptedOrders = [] + self.Offset = 100 + + + def moveUp(self): + if self.getY() > self.getMinY(): + self.setY(self.getY() - 1) + return True + else: + return False + + def moveDown(self): + if self.getY() < self.getMaxY(): + self.setY(self.getY() + 1) + return True + else: + return False + + def moveLeft(self): + if self.getX() > self.getMinX(): + self.setX(self.getX() - 1) + return True + else: + return False + + def moveRight(self): + if self.getX() < self.getMaxX(): + self.setX(self.getX() + 1) + return True + else: + return False + + #accepts orders from the table and stores them in queue + def addOrder(self, table): + self.__acceptedOrders += [(table, table.getOrder())] + + def __loadImg(self, filePath): + return pygame.transform.scale((pygame.image.load(filePath)),(140,140)) + + def draw(self, screen): + screen.blit(self.__image, (self.getX()*100-20+self.Offset, self.getY()*100-20+self.Offset)) diff --git a/kelner/src/managers/DrawableCollection.py b/kelner/src/managers/DrawableCollection.py new file mode 100644 index 0000000..9848c68 --- /dev/null +++ b/kelner/src/managers/DrawableCollection.py @@ -0,0 +1,74 @@ +import random +from src.components.Table import Table, Status +from src.components.Waiter import Waiter +import pygame +#drawable objects manager +class DrawableCollection: + #const, minimal distance between objects + __MinDistance = 0 + + def __init__(self): + #collection that holds all drawable objects + self.__drawables = [] + self.image = pygame.transform.scale((pygame.image.load('./images/Backgroud.png')),(1700,1100)) + + #adds drawable objects to the collection + def add(self, drawable): + self.__drawables.append(drawable) + + #generates and sets random (x, y) and cheks if it's not occupied by other object + def generatePosition(self, drawable): + isPositionUnique = False + while not isPositionUnique: + x = random.randint(drawable.getMinX() + 1, drawable.getMaxX() - 1) + y = random.randint(drawable.getMinY() + 1, drawable.getMaxY() - 1) + isPositionUnique = True + for item in self.__drawables: + if abs(item.getX() - x) <= self.__MinDistance and abs(item.getY() - y) <= self.__MinDistance: + isPositionUnique = False + break + if isPositionUnique: + drawable.setX(x) + drawable.setY(y) + + #draws all objects stored in collection + def draw(self, screen): + screen.blit(self.image, (0, 0)) + for item in self.__drawables: + item.draw(screen) + + #checks if position (x,y) is not occupied by other object + def isPositionAvailable(self, x, y): + isPositionAvailable = True + for item in self.__drawables: + if item.getX() == x and item.getY() == y: + isPositionAvailable = False + break + return isPositionAvailable + + #gets all tables by status from collection + def getTables(self, status): + result = [] + for item in self.__drawables: + if isinstance(item, Table) and item.isStatus(status): + result += [item] + return result + + #gets all waiters from collection + def getWaites(self): + result = [] + for item in self.__drawables: + if isinstance(item, Waiter): + result += [item] + return result + + #waiter collects order from the nearest table + def collectOrders(self): + waiters = self.getWaites() + for waiter in waiters: + tables = self.getTables(Status.Ready) + for table in tables: + if (table.getX() == waiter.getX() and abs(table.getY() - waiter.getY()) == 1) or (table.getY() == waiter.getY() and abs(table.getX() - waiter.getX()) == 1): + table.setStatus(Status.Waiting) + waiter.addOrder(table) + table.delOrder() \ No newline at end of file diff --git a/kelner/src/managers/MenuManager.py b/kelner/src/managers/MenuManager.py new file mode 100644 index 0000000..7b9222b --- /dev/null +++ b/kelner/src/managers/MenuManager.py @@ -0,0 +1,33 @@ +import random + +#contains all dishes and generates random order for the table +class MenuManager: + + #consts, min and max dishes oredered by the people sitting by the same table + __MinDishes = 1 + __MaxDishes = 3 + + def __init__(self): + self.__menuCard = ["PORK", + "FRENCH FRIES", + "PIZZA", + "CHICKEN", + "RIBS", + "FISH", + "SPAGHETTI", + "BEEF", + "STEAK", + "SALAD", + "GRILLED VEGETABLES", + "VEAL", + "CHOPS", + "EMPTY PLATE", + "BEER", + "CAKE"] + #generator + def generateOrder(self): + count = random.randint(self.__MinDishes, self.__MaxDishes) + order = [] + for i in range(0, count): + order += [(self.__menuCard[random.randint(0, len(self.__menuCard) - 1)])] + return order \ No newline at end of file diff --git a/kelner/src/managers/TaskManager.py b/kelner/src/managers/TaskManager.py new file mode 100644 index 0000000..686937c --- /dev/null +++ b/kelner/src/managers/TaskManager.py @@ -0,0 +1,25 @@ +import threading +import time +import random +from src.components.Table import Status + +#creates new threads +class TaskManager (threading.Thread): + + def __init__(self, drawableManager, menuManager, doRepaintObject): + threading.Thread.__init__(self) + self.__drawableManager = drawableManager + self.__menuManager = menuManager + self.__doRepaintObject = doRepaintObject + + #changes the status of a random table from NotReady to Ready + def run(self): + while True: + time.sleep(3) + tables = self.__drawableManager.getTables(Status.NotReady) + if tables != []: + tableIndex = random.randint(0, len(tables) - 1) + table = tables[tableIndex] + table.setStatus(Status.Ready) + table.setOrder(self.__menuManager.generateOrder()) + self.__doRepaintObject[0] = True \ No newline at end of file diff --git a/kelner/venv/Include/site/python3.7/pygame/_camera.h b/kelner/venv/Include/site/python3.7/pygame/_camera.h new file mode 100644 index 0000000..68ae989 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/_camera.h @@ -0,0 +1,27 @@ +/* + pygame - Python Game Library + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +#ifndef _CAMERA_H +#define _CAMERA_H + +#include "_pygame.h" +#include "camera.h" + +#endif + diff --git a/kelner/venv/Include/site/python3.7/pygame/_pygame.h b/kelner/venv/Include/site/python3.7/pygame/_pygame.h new file mode 100644 index 0000000..68962fc --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/_pygame.h @@ -0,0 +1,864 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef _PYGAME_H +#define _PYGAME_H + +/** This header file includes all the definitions for the + ** base pygame extensions. This header only requires + ** SDL and Python includes. The reason for functions + ** prototyped with #define's is to allow for maximum + ** python portability. It also uses python as the + ** runtime linker, which allows for late binding. For more + ** information on this style of development, read the Python + ** docs on this subject. + ** http://www.python.org/doc/current/ext/using-cobjects.html + ** + ** If using this to build your own derived extensions, + ** you'll see that the functions available here are mainly + ** used to help convert between python objects and SDL objects. + ** Since this library doesn't add a lot of functionality to + ** the SDL libarary, it doesn't need to offer a lot either. + ** + ** When initializing your extension module, you must manually + ** import the modules you want to use. (this is the part about + ** using python as the runtime linker). Each module has its + ** own import_xxx() routine. You need to perform this import + ** after you have initialized your own module, and before + ** you call any routines from that module. Since every module + ** in pygame does this, there are plenty of examples. + ** + ** The base module does include some useful conversion routines + ** that you are free to use in your own extension. + ** + ** When making changes, it is very important to keep the + ** FIRSTSLOT and NUMSLOT constants up to date for each + ** section. Also be sure not to overlap any of the slots. + ** When you do make a mistake with this, it will result + ** is a dereferenced NULL pointer that is easier to diagnose + ** than it could be :] + **/ +#if defined(HAVE_SNPRINTF) /* defined in python.h (pyerrors.h) and SDL.h \ + (SDL_config.h) */ +#undef HAVE_SNPRINTF /* remove GCC redefine warning */ +#endif + +// This must be before all else +#if defined(__SYMBIAN32__) && defined(OPENC) +#include + +#if defined(__WINS__) +void * +_alloca(size_t size); +#define alloca _alloca +#endif +#endif + +#define PG_STRINGIZE_HELPER(x) #x +#define PG_STRINGIZE(x) PG_STRINGIZE_HELPER(x) +#define PG_WARN(desc) message(__FILE__ "(" PG_STRINGIZE(__LINE__) "): WARNING: " #desc) + +/* This is unconditionally defined in Python.h */ +#if defined(_POSIX_C_SOURCE) +#undef _POSIX_C_SOURCE +#endif + +#include + +/* the version macros are defined since version 1.9.5 */ +#define PG_MAJOR_VERSION 1 +#define PG_MINOR_VERSION 9 +#define PG_PATCH_VERSION 6 +#define PG_VERSIONNUM(MAJOR, MINOR, PATCH) (1000*(MAJOR) + 100*(MINOR) + (PATCH)) +#define PG_VERSION_ATLEAST(MAJOR, MINOR, PATCH) \ + (PG_VERSIONNUM(PG_MAJOR_VERSION, PG_MINOR_VERSION, PG_PATCH_VERSION) >= \ + PG_VERSIONNUM(MAJOR, MINOR, PATCH)) + +/* Cobjects vanish in Python 3.2; so we will code as though we use capsules */ +#if defined(Py_CAPSULE_H) +#define PG_HAVE_CAPSULE 1 +#else +#define PG_HAVE_CAPSULE 0 +#endif +#if defined(Py_COBJECT_H) +#define PG_HAVE_COBJECT 1 +#else +#define PG_HAVE_COBJECT 0 +#endif +#if !PG_HAVE_CAPSULE +#define PyCapsule_New(ptr, n, dfn) PyCObject_FromVoidPtr(ptr, dfn) +#define PyCapsule_GetPointer(obj, n) PyCObject_AsVoidPtr(obj) +#define PyCapsule_CheckExact(obj) PyCObject_Check(obj) +#endif + +/* Pygame uses Py_buffer (PEP 3118) to exchange array information internally; + * define here as needed. + */ +#if !defined(PyBUF_SIMPLE) +typedef struct bufferinfo { + void *buf; + PyObject *obj; + Py_ssize_t len; + Py_ssize_t itemsize; + int readonly; + int ndim; + char *format; + Py_ssize_t *shape; + Py_ssize_t *strides; + Py_ssize_t *suboffsets; + void *internal; +} Py_buffer; + +/* Flags for getting buffers */ +#define PyBUF_SIMPLE 0 +#define PyBUF_WRITABLE 0x0001 +/* we used to include an E, backwards compatible alias */ +#define PyBUF_WRITEABLE PyBUF_WRITABLE +#define PyBUF_FORMAT 0x0004 +#define PyBUF_ND 0x0008 +#define PyBUF_STRIDES (0x0010 | PyBUF_ND) +#define PyBUF_C_CONTIGUOUS (0x0020 | PyBUF_STRIDES) +#define PyBUF_F_CONTIGUOUS (0x0040 | PyBUF_STRIDES) +#define PyBUF_ANY_CONTIGUOUS (0x0080 | PyBUF_STRIDES) +#define PyBUF_INDIRECT (0x0100 | PyBUF_STRIDES) + +#define PyBUF_CONTIG (PyBUF_ND | PyBUF_WRITABLE) +#define PyBUF_CONTIG_RO (PyBUF_ND) + +#define PyBUF_STRIDED (PyBUF_STRIDES | PyBUF_WRITABLE) +#define PyBUF_STRIDED_RO (PyBUF_STRIDES) + +#define PyBUF_RECORDS (PyBUF_STRIDES | PyBUF_WRITABLE | PyBUF_FORMAT) +#define PyBUF_RECORDS_RO (PyBUF_STRIDES | PyBUF_FORMAT) + +#define PyBUF_FULL (PyBUF_INDIRECT | PyBUF_WRITABLE | PyBUF_FORMAT) +#define PyBUF_FULL_RO (PyBUF_INDIRECT | PyBUF_FORMAT) + +#define PyBUF_READ 0x100 +#define PyBUF_WRITE 0x200 +#define PyBUF_SHADOW 0x400 + +typedef int (*getbufferproc)(PyObject *, Py_buffer *, int); +typedef void (*releasebufferproc)(Py_buffer *); +#endif /* #if !defined(PyBUF_SIMPLE) */ + +/* Flag indicating a pg_buffer; used for assertions within callbacks */ +#ifndef NDEBUG +#define PyBUF_PYGAME 0x4000 +#endif + +#define PyBUF_HAS_FLAG(f, F) (((f) & (F)) == (F)) + +/* Array information exchange struct C type; inherits from Py_buffer + * + * Pygame uses its own Py_buffer derived C struct as an internal representation + * of an imported array buffer. The extended Py_buffer allows for a + * per-instance release callback, + */ +typedef void (*pybuffer_releaseproc)(Py_buffer *); + +typedef struct pg_bufferinfo_s { + Py_buffer view; + PyObject *consumer; /* Input: Borrowed reference */ + pybuffer_releaseproc release_buffer; +} pg_buffer; + +/* Operating system specific adjustments + */ +// No signal() +#if defined(__SYMBIAN32__) && defined(HAVE_SIGNAL_H) +#undef HAVE_SIGNAL_H +#endif + +#if defined(HAVE_SNPRINTF) +#undef HAVE_SNPRINTF +#endif + +#ifdef MS_WIN32 /*Python gives us MS_WIN32, SDL needs just WIN32*/ +#ifndef WIN32 +#define WIN32 +#endif +#endif + +/// Prefix when initializing module +#define MODPREFIX "" +/// Prefix when importing module +#define IMPPREFIX "pygame." + +#ifdef __SYMBIAN32__ +#undef MODPREFIX +#undef IMPPREFIX +// On Symbian there is no pygame package. The extensions are built-in or in +// sys\bin. +#define MODPREFIX "pygame_" +#define IMPPREFIX "pygame_" +#endif + +#include + +/* Pygame's SDL version macros: + * IS_SDLv1 is 1 if SDL 1.x.x, 0 otherwise + * IS_SDLv2 is 1 if at least SDL 2.0.0, 0 otherwise + */ +#if (SDL_VERSION_ATLEAST(2, 0, 0)) +#define IS_SDLv1 0 +#define IS_SDLv2 1 +#else +#define IS_SDLv1 1 +#define IS_SDLv2 0 +#endif + +/*#if IS_SDLv1 && PG_MAJOR_VERSION >= 2 +#error pygame 2 requires SDL 2 +#endif*/ + +#if IS_SDLv2 +/* SDL 1.2 constants removed from SDL 2 */ +typedef enum { + SDL_HWSURFACE = 0, + SDL_RESIZABLE = SDL_WINDOW_RESIZABLE, + SDL_ASYNCBLIT = 0, + SDL_OPENGL = SDL_WINDOW_OPENGL, + SDL_OPENGLBLIT = 0, + SDL_ANYFORMAT = 0, + SDL_HWPALETTE = 0, + SDL_DOUBLEBUF = 0, + SDL_FULLSCREEN = SDL_WINDOW_FULLSCREEN, + SDL_HWACCEL = 0, + SDL_SRCCOLORKEY = 0, + SDL_RLEACCELOK = 0, + SDL_SRCALPHA = 0, + SDL_NOFRAME = SDL_WINDOW_BORDERLESS, + SDL_GL_SWAP_CONTROL = 0, + TIMER_RESOLUTION = 0 +} PygameVideoFlags; + +/* the wheel button constants were removed from SDL 2 */ +typedef enum { + PGM_BUTTON_LEFT = SDL_BUTTON_LEFT, + PGM_BUTTON_RIGHT = SDL_BUTTON_RIGHT, + PGM_BUTTON_MIDDLE = SDL_BUTTON_MIDDLE, + PGM_BUTTON_WHEELUP = 4, + PGM_BUTTON_WHEELDOWN = 5, + PGM_BUTTON_X1 = SDL_BUTTON_X1 + 2, + PGM_BUTTON_X2 = SDL_BUTTON_X2 + 2, + PGM_BUTTON_KEEP = 0x80 +} PygameMouseFlags; + +typedef enum { + SDL_NOEVENT = 0, + /* SDL 1.2 allowed for 8 user defined events. */ + SDL_NUMEVENTS = SDL_USEREVENT + 8, + SDL_ACTIVEEVENT = SDL_NUMEVENTS, + PGE_EVENTBEGIN = SDL_NUMEVENTS, + SDL_VIDEORESIZE, + SDL_VIDEOEXPOSE, + PGE_KEYREPEAT, + PGE_EVENTEND +} PygameEventCode; + +#define PGE_NUMEVENTS (PGE_EVENTEND - PGE_EVENTBEGIN) + +typedef enum { + SDL_APPFOCUSMOUSE, + SDL_APPINPUTFOCUS, + SDL_APPACTIVE +} PygameAppCode; + +/* Surface flags: based on SDL 1.2 flags */ +typedef enum { + PGS_SWSURFACE = 0x00000000, + PGS_HWSURFACE = 0x00000001, + PGS_ASYNCBLIT = 0x00000004, + + PGS_ANYFORMAT = 0x10000000, + PGS_HWPALETTE = 0x20000000, + PGS_DOUBLEBUF = 0x40000000, + PGS_FULLSCREEN = 0x80000000, + PGS_OPENGL = 0x00000002, + PGS_OPENGLBLIT = 0x0000000A, + PGS_RESIZABLE = 0x00000010, + PGS_NOFRAME = 0x00000020, + PGS_SHOWN = 0x00000040, /* Added from SDL 2 */ + PGS_HIDDEN = 0x00000080, /* Added from SDL 2 */ + + PGS_HWACCEL = 0x00000100, + PGS_SRCCOLORKEY = 0x00001000, + PGS_RLEACCELOK = 0x00002000, + PGS_RLEACCEL = 0x00004000, + PGS_SRCALPHA = 0x00010000, + PGS_PREALLOC = 0x01000000 +} PygameSurfaceFlags; + +typedef struct { + Uint32 hw_available:1; + Uint32 wm_available:1; + Uint32 blit_hw:1; + Uint32 blit_hw_CC:1; + Uint32 blit_hw_A:1; + Uint32 blit_sw:1; + Uint32 blit_sw_CC:1; + Uint32 blit_sw_A:1; + Uint32 blit_fill:1; + Uint32 video_mem; + SDL_PixelFormat *vfmt; + SDL_PixelFormat vfmt_data; + int current_w; + int current_h; +} pg_VideoInfo; + +#endif /* IS_SDLv2 */ +/* macros used throughout the source */ +#define RAISE(x, y) (PyErr_SetString((x), (y)), (PyObject *)NULL) + +#ifdef WITH_THREAD +#define PG_CHECK_THREADS() (1) +#else /* ~WITH_THREAD */ +#define PG_CHECK_THREADS() \ + (RAISE(PyExc_NotImplementedError, \ + "Python built without thread support")) +#endif /* ~WITH_THREAD */ + +#define PyType_Init(x) (((x).ob_type) = &PyType_Type) +#define PYGAMEAPI_LOCAL_ENTRY "_PYGAME_C_API" + +#ifndef MIN +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +#endif + +#ifndef MAX +#define MAX(a, b) ((a) > (b) ? (a) : (b)) +#endif + +#ifndef ABS +#define ABS(a) (((a) < 0) ? -(a) : (a)) +#endif + +/* test sdl initializations */ +#define VIDEO_INIT_CHECK() \ + if (!SDL_WasInit(SDL_INIT_VIDEO)) \ + return RAISE(pgExc_SDLError, "video system not initialized") + +#define CDROM_INIT_CHECK() \ + if (!SDL_WasInit(SDL_INIT_CDROM)) \ + return RAISE(pgExc_SDLError, "cdrom system not initialized") + +#define JOYSTICK_INIT_CHECK() \ + if (!SDL_WasInit(SDL_INIT_JOYSTICK)) \ + return RAISE(pgExc_SDLError, "joystick system not initialized") + +/* BASE */ +#define VIEW_CONTIGUOUS 1 +#define VIEW_C_ORDER 2 +#define VIEW_F_ORDER 4 + +#define PYGAMEAPI_BASE_FIRSTSLOT 0 +#if IS_SDLv1 +#define PYGAMEAPI_BASE_NUMSLOTS 19 +#else /* IS_SDLv2 */ +#define PYGAMEAPI_BASE_NUMSLOTS 23 +#endif /* IS_SDLv2 */ +#ifndef PYGAMEAPI_BASE_INTERNAL +#define pgExc_SDLError ((PyObject *)PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT]) + +#define pg_RegisterQuit \ + (*(void (*)(void (*)(void)))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 1]) + +#define pg_IntFromObj \ + (*(int (*)(PyObject *, int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 2]) + +#define pg_IntFromObjIndex \ + (*(int (*)(PyObject *, int, \ + int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 3]) + +#define pg_TwoIntsFromObj \ + (*(int (*)(PyObject *, int *, \ + int *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 4]) + +#define pg_FloatFromObj \ + (*(int (*)(PyObject *, float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 5]) + +#define pg_FloatFromObjIndex \ + (*(int (*)(PyObject *, int, \ + float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 6]) + +#define pg_TwoFloatsFromObj \ + (*(int (*)(PyObject *, float *, \ + float *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 7]) + +#define pg_UintFromObj \ + (*(int (*)(PyObject *, \ + Uint32 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 8]) + +#define pg_UintFromObjIndex \ + (*(int (*)(PyObject *, int, \ + Uint32 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 9]) + +#define pgVideo_AutoQuit \ + (*(void (*)(void))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 10]) + +#define pgVideo_AutoInit \ + (*(int (*)(void))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 11]) + +#define pg_RGBAFromObj \ + (*(int (*)(PyObject *, \ + Uint8 *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 12]) + +#define pgBuffer_AsArrayInterface \ + (*(PyObject * (*)(Py_buffer *)) \ + PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 13]) + +#define pgBuffer_AsArrayStruct \ + (*(PyObject * (*)(Py_buffer *)) \ + PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 14]) + +#define pgObject_GetBuffer \ + (*(int (*)(PyObject *, pg_buffer *, \ + int))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 15]) + +#define pgBuffer_Release \ + (*(void (*)(pg_buffer *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 16]) + +#define pgDict_AsBuffer \ + (*(int (*)(pg_buffer *, PyObject *, \ + int))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 17]) + +#define pgExc_BufferError \ + ((PyObject *)PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 18]) + +#if IS_SDLv2 +#define pg_GetDefaultWindow \ + (*(SDL_Window * (*)(void)) PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 19]) + +#define pg_SetDefaultWindow \ + (*(void (*)(SDL_Window *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 20]) + +#define pg_GetDefaultWindowSurface \ + (*(PyObject * (*)(void)) PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 21]) + +#define pg_SetDefaultWindowSurface \ + (*(void (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_BASE_FIRSTSLOT + 22]) + +#endif /* IS_SDLv2 */ + +#define import_pygame_base() IMPORT_PYGAME_MODULE(base, BASE) +#endif + +/* RECT */ +#define PYGAMEAPI_RECT_FIRSTSLOT \ + (PYGAMEAPI_BASE_FIRSTSLOT + PYGAMEAPI_BASE_NUMSLOTS) +#define PYGAMEAPI_RECT_NUMSLOTS 4 + +#if IS_SDLv1 +typedef struct { + int x, y; + int w, h; +} GAME_Rect; +#else +typedef SDL_Rect GAME_Rect; +#endif + +typedef struct { + PyObject_HEAD GAME_Rect r; + PyObject *weakreflist; +} pgRectObject; + +#define pgRect_AsRect(x) (((pgRectObject *)x)->r) +#ifndef PYGAMEAPI_RECT_INTERNAL +#define pgRect_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 0]) +#define pgRect_Type \ + (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 0]) +#define pgRect_New \ + (*(PyObject * (*)(SDL_Rect *)) PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 1]) +#define pgRect_New4 \ + (*(PyObject * (*)(int, int, int, int)) \ + PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 2]) +#define pgRect_FromObject \ + (*(GAME_Rect * (*)(PyObject *, GAME_Rect *)) \ + PyGAME_C_API[PYGAMEAPI_RECT_FIRSTSLOT + 3]) + +#define import_pygame_rect() IMPORT_PYGAME_MODULE(rect, RECT) +#endif + +/* CDROM */ +#define PYGAMEAPI_CDROM_FIRSTSLOT \ + (PYGAMEAPI_RECT_FIRSTSLOT + PYGAMEAPI_RECT_NUMSLOTS) +#define PYGAMEAPI_CDROM_NUMSLOTS 2 + +typedef struct { + PyObject_HEAD int id; +} pgCDObject; + +#define pgCD_AsID(x) (((pgCDObject *)x)->id) +#ifndef PYGAMEAPI_CDROM_INTERNAL +#define pgCD_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 0]) +#define pgCD_Type \ + (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 0]) +#define pgCD_New \ + (*(PyObject * (*)(int)) PyGAME_C_API[PYGAMEAPI_CDROM_FIRSTSLOT + 1]) + +#define import_pygame_cd() IMPORT_PYGAME_MODULE(cdrom, CDROM) +#endif + +/* JOYSTICK */ +#define PYGAMEAPI_JOYSTICK_FIRSTSLOT \ + (PYGAMEAPI_CDROM_FIRSTSLOT + PYGAMEAPI_CDROM_NUMSLOTS) +#define PYGAMEAPI_JOYSTICK_NUMSLOTS 2 + +typedef struct { + PyObject_HEAD int id; +} pgJoystickObject; + +#define pgJoystick_AsID(x) (((pgJoystickObject *)x)->id) + +#ifndef PYGAMEAPI_JOYSTICK_INTERNAL +#define pgJoystick_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 0]) + +#define pgJoystick_Type \ + (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 0]) +#define pgJoystick_New \ + (*(PyObject * (*)(int)) PyGAME_C_API[PYGAMEAPI_JOYSTICK_FIRSTSLOT + 1]) + +#define import_pygame_joystick() IMPORT_PYGAME_MODULE(joystick, JOYSTICK) +#endif + +/* DISPLAY */ +#define PYGAMEAPI_DISPLAY_FIRSTSLOT \ + (PYGAMEAPI_JOYSTICK_FIRSTSLOT + PYGAMEAPI_JOYSTICK_NUMSLOTS) +#define PYGAMEAPI_DISPLAY_NUMSLOTS 2 + +typedef struct { +#if IS_SDLv1 + PyObject_HEAD SDL_VideoInfo info; +#else + PyObject_HEAD pg_VideoInfo info; +#endif +} pgVidInfoObject; + +#define pgVidInfo_AsVidInfo(x) (((pgVidInfoObject *)x)->info) +#ifndef PYGAMEAPI_DISPLAY_INTERNAL +#define pgVidInfo_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 0]) + +#define pgVidInfo_Type \ + (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 0]) + +#if IS_SDLv1 +#define pgVidInfo_New \ + (*(PyObject * (*)(SDL_VideoInfo *)) \ + PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 1]) +#else +#define pgVidInfo_New \ + (*(PyObject * (*)(pg_VideoInfo *)) \ + PyGAME_C_API[PYGAMEAPI_DISPLAY_FIRSTSLOT + 1]) +#endif + +#define import_pygame_display() IMPORT_PYGAME_MODULE(display, DISPLAY) +#endif + +/* SURFACE */ +#define PYGAMEAPI_SURFACE_FIRSTSLOT \ + (PYGAMEAPI_DISPLAY_FIRSTSLOT + PYGAMEAPI_DISPLAY_NUMSLOTS) +#define PYGAMEAPI_SURFACE_NUMSLOTS 3 +typedef struct { + PyObject_HEAD SDL_Surface *surf; +#if IS_SDLv2 + int owner; +#endif /* IS_SDLv2 */ + struct pgSubSurface_Data *subsurface; /*ptr to subsurface data (if a + * subsurface)*/ + PyObject *weakreflist; + PyObject *locklist; + PyObject *dependency; +} pgSurfaceObject; +#define pgSurface_AsSurface(x) (((pgSurfaceObject *)x)->surf) +#ifndef PYGAMEAPI_SURFACE_INTERNAL +#define pgSurface_Check(x) \ + (PyObject_IsInstance((x), \ + (PyObject *)PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 0])) +#define pgSurface_Type \ + (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 0]) +#if IS_SDLv1 +#define pgSurface_New \ + (*(PyObject * (*)(SDL_Surface *)) \ + PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 1]) +#else /* IS_SDLv2 */ +#define pgSurface_New2 \ + (*(PyObject * (*)(SDL_Surface *, int)) \ + PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 1]) +#endif /* IS_SDLv2 */ +#define pgSurface_Blit \ + (*(int (*)(PyObject *, PyObject *, SDL_Rect *, SDL_Rect *, \ + int))PyGAME_C_API[PYGAMEAPI_SURFACE_FIRSTSLOT + 2]) + +#define import_pygame_surface() \ + do { \ + IMPORT_PYGAME_MODULE(surface, SURFACE); \ + if (PyErr_Occurred() != NULL) \ + break; \ + IMPORT_PYGAME_MODULE(surflock, SURFLOCK); \ + } while (0) + +#if IS_SDLv2 +#define pgSurface_New(surface) pgSurface_New2((surface), 1) +#define pgSurface_NewNoOwn(surface) pgSurface_New2((surface), 0) +#endif /* IS_SDLv2 */ + +#endif + +/* SURFLOCK */ /*auto import/init by surface*/ +#define PYGAMEAPI_SURFLOCK_FIRSTSLOT \ + (PYGAMEAPI_SURFACE_FIRSTSLOT + PYGAMEAPI_SURFACE_NUMSLOTS) +#define PYGAMEAPI_SURFLOCK_NUMSLOTS 8 +struct pgSubSurface_Data { + PyObject *owner; + int pixeloffset; + int offsetx, offsety; +}; + +typedef struct { + PyObject_HEAD PyObject *surface; + PyObject *lockobj; + PyObject *weakrefs; +} pgLifetimeLockObject; + +#ifndef PYGAMEAPI_SURFLOCK_INTERNAL +#define pgLifetimeLock_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 0]) +#define pgSurface_Prep(x) \ + if (((pgSurfaceObject *)x)->subsurface) \ + (*(*(void (*)( \ + PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 1]))(x) + +#define pgSurface_Unprep(x) \ + if (((pgSurfaceObject *)x)->subsurface) \ + (*(*(void (*)( \ + PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 2]))(x) + +#define pgSurface_Lock \ + (*(int (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 3]) +#define pgSurface_Unlock \ + (*(int (*)(PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 4]) +#define pgSurface_LockBy \ + (*(int (*)(PyObject *, \ + PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 5]) +#define pgSurface_UnlockBy \ + (*(int (*)(PyObject *, \ + PyObject *))PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 6]) +#define pgSurface_LockLifetime \ + (*(PyObject * (*)(PyObject *, PyObject *)) \ + PyGAME_C_API[PYGAMEAPI_SURFLOCK_FIRSTSLOT + 7]) +#endif + +/* EVENT */ +#define PYGAMEAPI_EVENT_FIRSTSLOT \ + (PYGAMEAPI_SURFLOCK_FIRSTSLOT + PYGAMEAPI_SURFLOCK_NUMSLOTS) +#if IS_SDLv1 +#define PYGAMEAPI_EVENT_NUMSLOTS 4 +#else /* IS_SDLv2 */ +#define PYGAMEAPI_EVENT_NUMSLOTS 6 +#endif /* IS_SDLv2 */ + +typedef struct { + PyObject_HEAD int type; + PyObject *dict; +} pgEventObject; + +#ifndef PYGAMEAPI_EVENT_INTERNAL +#define pgEvent_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 0]) +#define pgEvent_Type \ + (*(PyTypeObject *)PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 0]) +#define pgEvent_New \ + (*(PyObject * (*)(SDL_Event *)) \ + PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 1]) +#define pgEvent_New2 \ + (*(PyObject * (*)(int, PyObject *)) \ + PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 2]) +#define pgEvent_FillUserEvent \ + (*(int (*)(pgEventObject *, \ + SDL_Event *))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 3]) +#if IS_SDLv2 +#define pg_EnableKeyRepeat \ + (*(int (*)(int, int))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 4]) +#define pg_GetKeyRepeat \ + (*(void (*)(int *, int *))PyGAME_C_API[PYGAMEAPI_EVENT_FIRSTSLOT + 5]) +#endif /* IS_SDLv2 */ +#define import_pygame_event() IMPORT_PYGAME_MODULE(event, EVENT) +#endif + +/* RWOBJECT */ +/*the rwobject are only needed for C side work, not accessable from python*/ +#define PYGAMEAPI_RWOBJECT_FIRSTSLOT \ + (PYGAMEAPI_EVENT_FIRSTSLOT + PYGAMEAPI_EVENT_NUMSLOTS) +#define PYGAMEAPI_RWOBJECT_NUMSLOTS 6 +#ifndef PYGAMEAPI_RWOBJECT_INTERNAL +#define pgRWops_FromObject \ + (*(SDL_RWops * (*)(PyObject *)) \ + PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 0]) +#define pgRWops_IsFileObject \ + (*(int (*)(SDL_RWops *))PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 1]) +#define pg_EncodeFilePath \ + (*(PyObject * (*)(PyObject *, PyObject *)) \ + PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 2]) +#define pg_EncodeString \ + (*(PyObject * (*)(PyObject *, const char *, const char *, PyObject *)) \ + PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 3]) +#define pgRWops_FromFileObject \ + (*(SDL_RWops * (*)(PyObject *)) \ + PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 4]) +#define pgRWops_ReleaseObject \ + (*(int (*)(SDL_RWops *)) \ + PyGAME_C_API[PYGAMEAPI_RWOBJECT_FIRSTSLOT + 5]) +#define import_pygame_rwobject() IMPORT_PYGAME_MODULE(rwobject, RWOBJECT) + +#endif + +/* PixelArray */ +#define PYGAMEAPI_PIXELARRAY_FIRSTSLOT \ + (PYGAMEAPI_RWOBJECT_FIRSTSLOT + PYGAMEAPI_RWOBJECT_NUMSLOTS) +#define PYGAMEAPI_PIXELARRAY_NUMSLOTS 2 +#ifndef PYGAMEAPI_PIXELARRAY_INTERNAL +#define PyPixelArray_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_PIXELARRAY_FIRSTSLOT + 0]) +#define PyPixelArray_New \ + (*(PyObject * (*)) PyGAME_C_API[PYGAMEAPI_PIXELARRAY_FIRSTSLOT + 1]) +#define import_pygame_pixelarray() IMPORT_PYGAME_MODULE(pixelarray, PIXELARRAY) +#endif /* PYGAMEAPI_PIXELARRAY_INTERNAL */ + +/* Color */ +#define PYGAMEAPI_COLOR_FIRSTSLOT \ + (PYGAMEAPI_PIXELARRAY_FIRSTSLOT + PYGAMEAPI_PIXELARRAY_NUMSLOTS) +#define PYGAMEAPI_COLOR_NUMSLOTS 4 +#ifndef PYGAMEAPI_COLOR_INTERNAL +#define pgColor_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 0]) +#define pgColor_Type (*(PyObject *)PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT]) +#define pgColor_New \ + (*(PyObject * (*)(Uint8 *)) PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 1]) +#define pgColor_NewLength \ + (*(PyObject * (*)(Uint8 *, Uint8)) \ + PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 3]) + +#define pg_RGBAFromColorObj \ + (*(int (*)(PyObject *, \ + Uint8 *))PyGAME_C_API[PYGAMEAPI_COLOR_FIRSTSLOT + 2]) +#define import_pygame_color() IMPORT_PYGAME_MODULE(color, COLOR) +#endif /* PYGAMEAPI_COLOR_INTERNAL */ + +/* Math */ +#define PYGAMEAPI_MATH_FIRSTSLOT \ + (PYGAMEAPI_COLOR_FIRSTSLOT + PYGAMEAPI_COLOR_NUMSLOTS) +#define PYGAMEAPI_MATH_NUMSLOTS 2 +#ifndef PYGAMEAPI_MATH_INTERNAL +#define pgVector2_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 0]) +#define pgVector3_Check(x) \ + ((x)->ob_type == \ + (PyTypeObject *)PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 1]) +/* +#define pgVector2_New \ + (*(PyObject*(*)) PyGAME_C_API[PYGAMEAPI_MATH_FIRSTSLOT + 1]) +*/ +#define import_pygame_math() IMPORT_PYGAME_MODULE(math, MATH) +#endif /* PYGAMEAPI_MATH_INTERNAL */ + +#define PG_CAPSULE_NAME(m) (IMPPREFIX m "." PYGAMEAPI_LOCAL_ENTRY) + +#define _IMPORT_PYGAME_MODULE(module, MODULE, api_root) \ + { \ + PyObject *_module = PyImport_ImportModule(IMPPREFIX #module); \ + \ + if (_module != NULL) { \ + PyObject *_c_api = \ + PyObject_GetAttrString(_module, PYGAMEAPI_LOCAL_ENTRY); \ + \ + Py_DECREF(_module); \ + if (_c_api != NULL && PyCapsule_CheckExact(_c_api)) { \ + void **localptr = (void **)PyCapsule_GetPointer( \ + _c_api, PG_CAPSULE_NAME(#module)); \ + \ + if (localptr != NULL) { \ + memcpy(api_root + PYGAMEAPI_##MODULE##_FIRSTSLOT, \ + localptr, \ + sizeof(void **) * PYGAMEAPI_##MODULE##_NUMSLOTS); \ + } \ + } \ + Py_XDECREF(_c_api); \ + } \ + } + +#ifndef NO_PYGAME_C_API +#define IMPORT_PYGAME_MODULE(module, MODULE) \ + _IMPORT_PYGAME_MODULE(module, MODULE, PyGAME_C_API) +#define PYGAMEAPI_TOTALSLOTS \ + (PYGAMEAPI_MATH_FIRSTSLOT + PYGAMEAPI_MATH_NUMSLOTS) + +#ifdef PYGAME_H +void *PyGAME_C_API[PYGAMEAPI_TOTALSLOTS] = {NULL}; +#else +extern void *PyGAME_C_API[PYGAMEAPI_TOTALSLOTS]; +#endif +#endif + +#if PG_HAVE_CAPSULE +#define encapsulate_api(ptr, module) \ + PyCapsule_New(ptr, PG_CAPSULE_NAME(module), NULL) +#else +#define encapsulate_api(ptr, module) PyCObject_FromVoidPtr(ptr, NULL) +#endif + +#ifndef PG_INLINE +#if defined(__clang__) +#define PG_INLINE __inline__ __attribute__((__unused__)) +#elif defined(__GNUC__) +#define PG_INLINE __inline__ +#elif defined(_MSC_VER) +#define PG_INLINE __inline +#elif defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +#define PG_INLINE inline +#else +#define PG_INLINE +#endif +#endif + +/*last platform compiler stuff*/ +#if defined(macintosh) && defined(__MWERKS__) || defined(__SYMBIAN32__) +#define PYGAME_EXPORT __declspec(export) +#else +#define PYGAME_EXPORT +#endif + + +#endif /* PYGAME_H */ diff --git a/kelner/venv/Include/site/python3.7/pygame/_surface.h b/kelner/venv/Include/site/python3.7/pygame/_surface.h new file mode 100644 index 0000000..016aac0 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/_surface.h @@ -0,0 +1,31 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + Copyright (C) 2007 Marcus von Appen + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef _SURFACE_H +#define _SURFACE_H + +#include "_pygame.h" +#include "surface.h" + +#endif + diff --git a/kelner/venv/Include/site/python3.7/pygame/bitmask.h b/kelner/venv/Include/site/python3.7/pygame/bitmask.h new file mode 100644 index 0000000..1230497 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/bitmask.h @@ -0,0 +1,146 @@ +/* + Bitmask 1.7 - A pixel-perfect collision detection library. + + Copyright (C) 2002-2005 Ulf Ekstrom except for the bitcount + function which is copyright (C) Donald W. Gillies, 1992. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + */ +#ifndef BITMASK_H +#define BITMASK_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +/* Define INLINE for different compilers. If your compiler does not + support inlining then there might be a performance hit in + bitmask_overlap_area(). +*/ +#ifndef INLINE +# ifdef __GNUC__ +# define INLINE inline +# else +# ifdef _MSC_VER +# define INLINE __inline +# else +# define INLINE +# endif +# endif +#endif + +#define BITMASK_W unsigned long int +#define BITMASK_W_LEN (sizeof(BITMASK_W)*CHAR_BIT) +#define BITMASK_W_MASK (BITMASK_W_LEN - 1) +#define BITMASK_N(n) ((BITMASK_W)1 << (n)) + +typedef struct bitmask +{ + int w,h; + BITMASK_W bits[1]; +} bitmask_t; + +/* Creates a bitmask of width w and height h, where + w and h must both be greater than or equal to 0. + The mask is automatically cleared when created. + */ +bitmask_t *bitmask_create(int w, int h); + +/* Frees all the memory allocated by bitmask_create for m. */ +void bitmask_free(bitmask_t *m); + +/* Clears all bits in the mask */ +void bitmask_clear(bitmask_t *m); + +/* Sets all bits in the mask */ +void bitmask_fill(bitmask_t *m); + +/* Flips all bits in the mask */ +void bitmask_invert(bitmask_t *m); + +/* Counts the bits in the mask */ +unsigned int bitmask_count(bitmask_t *m); + +/* Returns nonzero if the bit at (x,y) is set. Coordinates start at + (0,0) */ +static INLINE int bitmask_getbit(const bitmask_t *m, int x, int y) +{ + return (m->bits[x/BITMASK_W_LEN*m->h + y] & BITMASK_N(x & BITMASK_W_MASK)) != 0; +} + +/* Sets the bit at (x,y) */ +static INLINE void bitmask_setbit(bitmask_t *m, int x, int y) +{ + m->bits[x/BITMASK_W_LEN*m->h + y] |= BITMASK_N(x & BITMASK_W_MASK); +} + +/* Clears the bit at (x,y) */ +static INLINE void bitmask_clearbit(bitmask_t *m, int x, int y) +{ + m->bits[x/BITMASK_W_LEN*m->h + y] &= ~BITMASK_N(x & BITMASK_W_MASK); +} + +/* Returns nonzero if the masks overlap with the given offset. + The overlap tests uses the following offsets (which may be negative): + + +----+----------.. + |A | yoffset + | +-+----------.. + +--|B + |xoffset + | | + : : +*/ +int bitmask_overlap(const bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset); + +/* Like bitmask_overlap(), but will also give a point of intersection. + x and y are given in the coordinates of mask a, and are untouched + if there is no overlap. */ +int bitmask_overlap_pos(const bitmask_t *a, const bitmask_t *b, + int xoffset, int yoffset, int *x, int *y); + +/* Returns the number of overlapping 'pixels' */ +int bitmask_overlap_area(const bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset); + +/* Fills a mask with the overlap of two other masks. A bitwise AND. */ +void bitmask_overlap_mask (const bitmask_t *a, const bitmask_t *b, bitmask_t *c, int xoffset, int yoffset); + +/* Draws mask b onto mask a (bitwise OR). Can be used to compose large + (game background?) mask from several submasks, which may speed up + the testing. */ + +void bitmask_draw(bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset); + +void bitmask_erase(bitmask_t *a, const bitmask_t *b, int xoffset, int yoffset); + +/* Return a new scaled bitmask, with dimensions w*h. The quality of the + scaling may not be perfect for all circumstances, but it should + be reasonable. If either w or h is 0 a clear 1x1 mask is returned. */ +bitmask_t *bitmask_scale(const bitmask_t *m, int w, int h); + +/* Convolve b into a, drawing the output into o, shifted by offset. If offset + * is 0, then the (x,y) bit will be set if and only if + * bitmask_overlap(a, b, x - b->w - 1, y - b->h - 1) returns true. + * + * Modifies bits o[xoffset ... xoffset + a->w + b->w - 1) + * [yoffset ... yoffset + a->h + b->h - 1). */ +void bitmask_convolve(const bitmask_t *a, const bitmask_t *b, bitmask_t *o, int xoffset, int yoffset); + +#ifdef __cplusplus +} /* End of extern "C" { */ +#endif + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/camera.h b/kelner/venv/Include/site/python3.7/pygame/camera.h new file mode 100644 index 0000000..46d2beb --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/camera.h @@ -0,0 +1,201 @@ +/* + pygame - Python Game Library + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ + +#include "pygame.h" +#include "doc/camera_doc.h" + +#if defined(__unix__) + #include + #include + #include + #include + #include + + #include /* low-level i/o */ + #include + #include + #include + #include + #include + #include + #include + + /* on freebsd there is no asm/types */ + #ifdef linux + #include /* for videodev2.h */ + #endif + + #include +#elif defined(__APPLE__) + #include + /* We support OSX 10.6 and below. */ + #if __MAC_OS_X_VERSION_MAX_ALLOWED <= 1060 + #define PYGAME_MAC_CAMERA_OLD 1 + #endif +#endif + +#if defined(PYGAME_MAC_CAMERA_OLD) + #include + #include + #include +#endif + +/* some constants used which are not defined on non-v4l machines. */ +#ifndef V4L2_PIX_FMT_RGB24 + #define V4L2_PIX_FMT_RGB24 'RGB3' +#endif +#ifndef V4L2_PIX_FMT_RGB444 + #define V4L2_PIX_FMT_RGB444 'R444' +#endif +#ifndef V4L2_PIX_FMT_YUYV + #define V4L2_PIX_FMT_YUYV 'YUYV' +#endif + +#define CLEAR(x) memset (&(x), 0, sizeof (x)) +#define SAT(c) if (c & (~255)) { if (c < 0) c = 0; else c = 255; } +#define SAT2(c) ((c) & (~255) ? ((c) < 0 ? 0 : 255) : (c)) +#define DEFAULT_WIDTH 640 +#define DEFAULT_HEIGHT 480 +#define RGB_OUT 1 +#define YUV_OUT 2 +#define HSV_OUT 4 +#define CAM_V4L 1 /* deprecated. the incomplete support in pygame was removed */ +#define CAM_V4L2 2 + +struct buffer { + void * start; + size_t length; +}; + +#if defined(__unix__) +typedef struct pgCameraObject { + PyObject_HEAD + char* device_name; + int camera_type; + unsigned long pixelformat; + unsigned int color_out; + struct buffer* buffers; + unsigned int n_buffers; + int width; + int height; + int size; + int hflip; + int vflip; + int brightness; + int fd; +} pgCameraObject; +#elif defined(PYGAME_MAC_CAMERA_OLD) +typedef struct pgCameraObject { + PyObject_HEAD + char* device_name; /* unieke name of the device */ + OSType pixelformat; + unsigned int color_out; + SeqGrabComponent component; /* A type used by the Sequence Grabber API */ + SGChannel channel; /* Channel of the Sequence Grabber */ + GWorldPtr gworld; /* Pointer to the struct that holds the data of the captured image */ + Rect boundsRect; /* bounds of the image frame */ + long size; /* size of the image in our buffer to draw */ + int hflip; + int vflip; + short depth; + struct buffer pixels; + //struct buffer tmp_pixels /* place where the flipped image in temporarly stored if hflip or vflip is true.*/ +} pgCameraObject; + +#else +/* generic definition. +*/ + +typedef struct pgCameraObject { + PyObject_HEAD + char* device_name; + int camera_type; + unsigned long pixelformat; + unsigned int color_out; + struct buffer* buffers; + unsigned int n_buffers; + int width; + int height; + int size; + int hflip; + int vflip; + int brightness; + int fd; +} pgCameraObject; +#endif + +/* internal functions for colorspace conversion */ +void colorspace (SDL_Surface *src, SDL_Surface *dst, int cspace); +void rgb24_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format); +void rgb444_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format); +void rgb_to_yuv (const void* src, void* dst, int length, + unsigned long source, SDL_PixelFormat* format); +void rgb_to_hsv (const void* src, void* dst, int length, + unsigned long source, SDL_PixelFormat* format); +void yuyv_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format); +void yuyv_to_yuv (const void* src, void* dst, int length, SDL_PixelFormat* format); +void uyvy_to_rgb (const void* src, void* dst, int length, SDL_PixelFormat* format); +void uyvy_to_yuv (const void* src, void* dst, int length, SDL_PixelFormat* format); +void sbggr8_to_rgb (const void* src, void* dst, int width, int height, + SDL_PixelFormat* format); +void yuv420_to_rgb (const void* src, void* dst, int width, int height, + SDL_PixelFormat* format); +void yuv420_to_yuv (const void* src, void* dst, int width, int height, + SDL_PixelFormat* format); + +#if defined(__unix__) +/* internal functions specific to v4l2 */ +char** v4l2_list_cameras (int* num_devices); +int v4l2_get_control (int fd, int id, int *value); +int v4l2_set_control (int fd, int id, int value); +PyObject* v4l2_read_raw (pgCameraObject* self); +int v4l2_xioctl (int fd, int request, void *arg); +int v4l2_process_image (pgCameraObject* self, const void *image, + unsigned int buffer_size, SDL_Surface* surf); +int v4l2_query_buffer (pgCameraObject* self); +int v4l2_read_frame (pgCameraObject* self, SDL_Surface* surf); +int v4l2_stop_capturing (pgCameraObject* self); +int v4l2_start_capturing (pgCameraObject* self); +int v4l2_uninit_device (pgCameraObject* self); +int v4l2_init_mmap (pgCameraObject* self); +int v4l2_init_device (pgCameraObject* self); +int v4l2_close_device (pgCameraObject* self); +int v4l2_open_device (pgCameraObject* self); + +#elif defined(PYGAME_MAC_CAMERA_OLD) +/* internal functions specific to mac */ +char** mac_list_cameras(int* num_devices); +int mac_open_device (pgCameraObject* self); +int mac_init_device(pgCameraObject* self); +int mac_close_device (pgCameraObject* self); +int mac_start_capturing(pgCameraObject* self); +int mac_stop_capturing (pgCameraObject* self); + +int mac_get_control(pgCameraObject* self, int id, int* value); +int mac_set_control(pgCameraObject* self, int id, int value); + +PyObject* mac_read_raw(pgCameraObject *self); +int mac_read_frame(pgCameraObject* self, SDL_Surface* surf); +int mac_camera_idle(pgCameraObject* self); +int mac_copy_gworld_to_surface(pgCameraObject* self, SDL_Surface* surf); + +void flip_image(const void* image, void* flipped_image, int width, int height, + short depth, int hflip, int vflip); + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/fastevents.h b/kelner/venv/Include/site/python3.7/pygame/fastevents.h new file mode 100644 index 0000000..04098c3 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/fastevents.h @@ -0,0 +1,48 @@ +#ifndef _FASTEVENTS_H_ +#define _FASTEVENTS_H_ +/* + NET2 is a threaded, event based, network IO library for SDL. + Copyright (C) 2002 Bob Pendleton + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public License + as published by the Free Software Foundation; either version 2.1 + of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free + Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA + 02111-1307 USA + + If you do not wish to comply with the terms of the LGPL please + contact the author as other terms are available for a fee. + + Bob Pendleton + Bob@Pendleton.com +*/ + +#include "SDL.h" + +#ifdef __cplusplus +extern "C" { +#endif + + int FE_Init(void); // Initialize FE + void FE_Quit(void); // shutdown FE + + void FE_PumpEvents(void); // replacement for SDL_PumpEvents + int FE_PollEvent(SDL_Event *event); // replacement for SDL_PollEvent + int FE_WaitEvent(SDL_Event *event); // replacement for SDL_WaitEvent + int FE_PushEvent(SDL_Event *event); // replacement for SDL_PushEvent + + char *FE_GetError(void); // get the last error +#ifdef __cplusplus +} +#endif + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/font.h b/kelner/venv/Include/site/python3.7/pygame/font.h new file mode 100644 index 0000000..b861a29 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/font.h @@ -0,0 +1,57 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#include +#if defined(HAVE_SNPRINTF) /* also defined in SDL_ttf (SDL.h) */ +#undef HAVE_SNPRINTF /* remove GCC macro redefine warning */ +#endif +#include + + +/* test font initialization */ +#define FONT_INIT_CHECK() \ + if(!(*(int*)PyFONT_C_API[2])) \ + return RAISE(pgExc_SDLError, "font system not initialized") + + + +#define PYGAMEAPI_FONT_FIRSTSLOT 0 +#define PYGAMEAPI_FONT_NUMSLOTS 3 +typedef struct { + PyObject_HEAD + TTF_Font* font; + PyObject* weakreflist; +} PyFontObject; +#define PyFont_AsFont(x) (((PyFontObject*)x)->font) + +#ifndef PYGAMEAPI_FONT_INTERNAL +#define PyFont_Check(x) ((x)->ob_type == (PyTypeObject*)PyFONT_C_API[0]) +#define PyFont_Type (*(PyTypeObject*)PyFONT_C_API[0]) +#define PyFont_New (*(PyObject*(*)(TTF_Font*))PyFONT_C_API[1]) +/*slot 2 taken by FONT_INIT_CHECK*/ + +#define import_pygame_font() \ + _IMPORT_PYGAME_MODULE(font, FONT, PyFONT_C_API) + +static void* PyFONT_C_API[PYGAMEAPI_FONT_NUMSLOTS] = {NULL}; +#endif + diff --git a/kelner/venv/Include/site/python3.7/pygame/freetype.h b/kelner/venv/Include/site/python3.7/pygame/freetype.h new file mode 100644 index 0000000..fda7226 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/freetype.h @@ -0,0 +1,137 @@ +/* + pygame - Python Game Library + Copyright (C) 2009 Vicent Marti + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + +*/ +#ifndef _PYGAME_FREETYPE_H_ +#define _PYGAME_FREETYPE_H_ + +#define PGFT_PYGAME1_COMPAT +#define HAVE_PYGAME_SDL_VIDEO +#define HAVE_PYGAME_SDL_RWOPS + +#include "pygame.h" +#include "pgcompat.h" + +#if PY3 +# define IS_PYTHON_3 +#endif + +#include +#include FT_FREETYPE_H +#include FT_CACHE_H +#include FT_XFREE86_H +#include FT_TRIGONOMETRY_H + +/********************************************************** + * Global module constants + **********************************************************/ + +/* Render styles */ +#define FT_STYLE_NORMAL 0x00 +#define FT_STYLE_STRONG 0x01 +#define FT_STYLE_OBLIQUE 0x02 +#define FT_STYLE_UNDERLINE 0x04 +#define FT_STYLE_WIDE 0x08 +#define FT_STYLE_DEFAULT 0xFF + +/* Bounding box modes */ +#define FT_BBOX_EXACT FT_GLYPH_BBOX_SUBPIXELS +#define FT_BBOX_EXACT_GRIDFIT FT_GLYPH_BBOX_GRIDFIT +#define FT_BBOX_PIXEL FT_GLYPH_BBOX_TRUNCATE +#define FT_BBOX_PIXEL_GRIDFIT FT_GLYPH_BBOX_PIXELS + +/* Rendering flags */ +#define FT_RFLAG_NONE (0) +#define FT_RFLAG_ANTIALIAS (1 << 0) +#define FT_RFLAG_AUTOHINT (1 << 1) +#define FT_RFLAG_VERTICAL (1 << 2) +#define FT_RFLAG_HINTED (1 << 3) +#define FT_RFLAG_KERNING (1 << 4) +#define FT_RFLAG_TRANSFORM (1 << 5) +#define FT_RFLAG_PAD (1 << 6) +#define FT_RFLAG_ORIGIN (1 << 7) +#define FT_RFLAG_UCS4 (1 << 8) +#define FT_RFLAG_USE_BITMAP_STRIKES (1 << 9) +#define FT_RFLAG_DEFAULTS (FT_RFLAG_HINTED | \ + FT_RFLAG_USE_BITMAP_STRIKES | \ + FT_RFLAG_ANTIALIAS) + + +#define FT_RENDER_NEWBYTEARRAY 0x0 +#define FT_RENDER_NEWSURFACE 0x1 +#define FT_RENDER_EXISTINGSURFACE 0x2 + +/********************************************************** + * Global module types + **********************************************************/ + +typedef struct _scale_s { + FT_UInt x, y; +} Scale_t; +typedef FT_Angle Angle_t; + +struct fontinternals_; +struct freetypeinstance_; + +typedef struct { + FT_Long font_index; + FT_Open_Args open_args; +} pgFontId; + +typedef struct { + PyObject_HEAD + pgFontId id; + PyObject *path; + int is_scalable; + + Scale_t face_size; + FT_Int16 style; + FT_Int16 render_flags; + double strength; + double underline_adjustment; + FT_UInt resolution; + Angle_t rotation; + FT_Matrix transform; + FT_Byte fgcolor[4]; + + struct freetypeinstance_ *freetype; /* Personal reference */ + struct fontinternals_ *_internals; +} pgFontObject; + +#define pgFont_IS_ALIVE(o) \ + (((pgFontObject *)(o))->_internals != 0) + +/********************************************************** + * Module declaration + **********************************************************/ +#define PYGAMEAPI_FREETYPE_FIRSTSLOT 0 +#define PYGAMEAPI_FREETYPE_NUMSLOTS 2 + +#ifndef PYGAME_FREETYPE_INTERNAL + +#define pgFont_Check(x) ((x)->ob_type == (PyTypeObject*)PgFREETYPE_C_API[0]) +#define pgFont_Type (*(PyTypeObject*)PgFREETYPE_C_API[1]) +#define pgFont_New (*(PyObject*(*)(const char*, long))PgFREETYPE_C_API[1]) + +#define import_pygame_freetype() \ + _IMPORT_PYGAME_MODULE(freetype, FREETYPE, PgFREETYPE_C_API) + +static void *PgFREETYPE_C_API[PYGAMEAPI_FREETYPE_NUMSLOTS] = {0}; +#endif /* PYGAME_FREETYPE_INTERNAL */ + +#endif /* _PYGAME_FREETYPE_H_ */ diff --git a/kelner/venv/Include/site/python3.7/pygame/mask.h b/kelner/venv/Include/site/python3.7/pygame/mask.h new file mode 100644 index 0000000..b151dd4 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/mask.h @@ -0,0 +1,25 @@ +#include +#include "bitmask.h" + +#define PYGAMEAPI_MASK_FIRSTSLOT 0 +#define PYGAMEAPI_MASK_NUMSLOTS 1 +#define PYGAMEAPI_LOCAL_ENTRY "_PYGAME_C_API" + +typedef struct { + PyObject_HEAD + bitmask_t *mask; +} pgMaskObject; + +#define pgMask_AsBitmap(x) (((pgMaskObject*)x)->mask) + +#ifndef PYGAMEAPI_MASK_INTERNAL + +#define pgMask_Type (*(PyTypeObject*)PyMASK_C_API[0]) +#define pgMask_Check(x) ((x)->ob_type == &pgMask_Type) + +#define import_pygame_mask() \ + _IMPORT_PYGAME_MODULE(mask, MASK, PyMASK_C_API) + +static void* PyMASK_C_API[PYGAMEAPI_MASK_NUMSLOTS] = {NULL}; +#endif /* #ifndef PYGAMEAPI_MASK_INTERNAL */ + diff --git a/kelner/venv/Include/site/python3.7/pygame/mixer.h b/kelner/venv/Include/site/python3.7/pygame/mixer.h new file mode 100644 index 0000000..36d57f3 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/mixer.h @@ -0,0 +1,65 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#include +#include +#include + + +/* test mixer initializations */ +#define MIXER_INIT_CHECK() \ + if(!SDL_WasInit(SDL_INIT_AUDIO)) \ + return RAISE(pgExc_SDLError, "mixer not initialized") + + +#define PYGAMEAPI_MIXER_FIRSTSLOT 0 +#define PYGAMEAPI_MIXER_NUMSLOTS 7 +typedef struct { + PyObject_HEAD + Mix_Chunk *chunk; + Uint8 *mem; + PyObject *weakreflist; +} pgSoundObject; +typedef struct { + PyObject_HEAD + int chan; +} pgChannelObject; +#define pgSound_AsChunk(x) (((pgSoundObject*)x)->chunk) +#define pgChannel_AsInt(x) (((pgChannelObject*)x)->chan) + +#ifndef PYGAMEAPI_MIXER_INTERNAL +#define pgSound_Check(x) ((x)->ob_type == (PyTypeObject*)pgMIXER_C_API[0]) +#define pgSound_Type (*(PyTypeObject*)pgMIXER_C_API[0]) +#define pgSound_New (*(PyObject*(*)(Mix_Chunk*))pgMIXER_C_API[1]) +#define pgSound_Play (*(PyObject*(*)(PyObject*, PyObject*))pgMIXER_C_API[2]) +#define pgChannel_Check(x) ((x)->ob_type == (PyTypeObject*)pgMIXER_C_API[3]) +#define pgChannel_Type (*(PyTypeObject*)pgMIXER_C_API[3]) +#define pgChannel_New (*(PyObject*(*)(int))pgMIXER_C_API[4]) +#define pgMixer_AutoInit (*(PyObject*(*)(PyObject*, PyObject*))pgMIXER_C_API[5]) +#define pgMixer_AutoQuit (*(void(*)(void))pgMIXER_C_API[6]) + +#define import_pygame_mixer() \ + _IMPORT_PYGAME_MODULE(mixer, MIXER, pgMIXER_C_API) + +static void* pgMIXER_C_API[PYGAMEAPI_MIXER_NUMSLOTS] = {NULL}; +#endif + diff --git a/kelner/venv/Include/site/python3.7/pygame/palette.h b/kelner/venv/Include/site/python3.7/pygame/palette.h new file mode 100644 index 0000000..1ae4cf6 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/palette.h @@ -0,0 +1,123 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef PALETTE_H +#define PALETTE_H + +#include + +/* SDL 2 does not assign a default palette color scheme to a new 8 bit + * surface. Instead, the palette is set all white. This defines the SDL 1.2 + * default palette. + */ +static const SDL_Color default_palette_colors[] = { + {0, 0, 0, 255}, {0, 0, 85, 255}, {0, 0, 170, 255}, + {0, 0, 255, 255}, {0, 36, 0, 255}, {0, 36, 85, 255}, + {0, 36, 170, 255}, {0, 36, 255, 255}, {0, 73, 0, 255}, + {0, 73, 85, 255}, {0, 73, 170, 255}, {0, 73, 255, 255}, + {0, 109, 0, 255}, {0, 109, 85, 255}, {0, 109, 170, 255}, + {0, 109, 255, 255}, {0, 146, 0, 255}, {0, 146, 85, 255}, + {0, 146, 170, 255}, {0, 146, 255, 255}, {0, 182, 0, 255}, + {0, 182, 85, 255}, {0, 182, 170, 255}, {0, 182, 255, 255}, + {0, 219, 0, 255}, {0, 219, 85, 255}, {0, 219, 170, 255}, + {0, 219, 255, 255}, {0, 255, 0, 255}, {0, 255, 85, 255}, + {0, 255, 170, 255}, {0, 255, 255, 255}, {85, 0, 0, 255}, + {85, 0, 85, 255}, {85, 0, 170, 255}, {85, 0, 255, 255}, + {85, 36, 0, 255}, {85, 36, 85, 255}, {85, 36, 170, 255}, + {85, 36, 255, 255}, {85, 73, 0, 255}, {85, 73, 85, 255}, + {85, 73, 170, 255}, {85, 73, 255, 255}, {85, 109, 0, 255}, + {85, 109, 85, 255}, {85, 109, 170, 255}, {85, 109, 255, 255}, + {85, 146, 0, 255}, {85, 146, 85, 255}, {85, 146, 170, 255}, + {85, 146, 255, 255}, {85, 182, 0, 255}, {85, 182, 85, 255}, + {85, 182, 170, 255}, {85, 182, 255, 255}, {85, 219, 0, 255}, + {85, 219, 85, 255}, {85, 219, 170, 255}, {85, 219, 255, 255}, + {85, 255, 0, 255}, {85, 255, 85, 255}, {85, 255, 170, 255}, + {85, 255, 255, 255}, {170, 0, 0, 255}, {170, 0, 85, 255}, + {170, 0, 170, 255}, {170, 0, 255, 255}, {170, 36, 0, 255}, + {170, 36, 85, 255}, {170, 36, 170, 255}, {170, 36, 255, 255}, + {170, 73, 0, 255}, {170, 73, 85, 255}, {170, 73, 170, 255}, + {170, 73, 255, 255}, {170, 109, 0, 255}, {170, 109, 85, 255}, + {170, 109, 170, 255}, {170, 109, 255, 255}, {170, 146, 0, 255}, + {170, 146, 85, 255}, {170, 146, 170, 255}, {170, 146, 255, 255}, + {170, 182, 0, 255}, {170, 182, 85, 255}, {170, 182, 170, 255}, + {170, 182, 255, 255}, {170, 219, 0, 255}, {170, 219, 85, 255}, + {170, 219, 170, 255}, {170, 219, 255, 255}, {170, 255, 0, 255}, + {170, 255, 85, 255}, {170, 255, 170, 255}, {170, 255, 255, 255}, + {255, 0, 0, 255}, {255, 0, 85, 255}, {255, 0, 170, 255}, + {255, 0, 255, 255}, {255, 36, 0, 255}, {255, 36, 85, 255}, + {255, 36, 170, 255}, {255, 36, 255, 255}, {255, 73, 0, 255}, + {255, 73, 85, 255}, {255, 73, 170, 255}, {255, 73, 255, 255}, + {255, 109, 0, 255}, {255, 109, 85, 255}, {255, 109, 170, 255}, + {255, 109, 255, 255}, {255, 146, 0, 255}, {255, 146, 85, 255}, + {255, 146, 170, 255}, {255, 146, 255, 255}, {255, 182, 0, 255}, + {255, 182, 85, 255}, {255, 182, 170, 255}, {255, 182, 255, 255}, + {255, 219, 0, 255}, {255, 219, 85, 255}, {255, 219, 170, 255}, + {255, 219, 255, 255}, {255, 255, 0, 255}, {255, 255, 85, 255}, + {255, 255, 170, 255}, {255, 255, 255, 255}, {0, 0, 0, 255}, + {0, 0, 85, 255}, {0, 0, 170, 255}, {0, 0, 255, 255}, + {0, 36, 0, 255}, {0, 36, 85, 255}, {0, 36, 170, 255}, + {0, 36, 255, 255}, {0, 73, 0, 255}, {0, 73, 85, 255}, + {0, 73, 170, 255}, {0, 73, 255, 255}, {0, 109, 0, 255}, + {0, 109, 85, 255}, {0, 109, 170, 255}, {0, 109, 255, 255}, + {0, 146, 0, 255}, {0, 146, 85, 255}, {0, 146, 170, 255}, + {0, 146, 255, 255}, {0, 182, 0, 255}, {0, 182, 85, 255}, + {0, 182, 170, 255}, {0, 182, 255, 255}, {0, 219, 0, 255}, + {0, 219, 85, 255}, {0, 219, 170, 255}, {0, 219, 255, 255}, + {0, 255, 0, 255}, {0, 255, 85, 255}, {0, 255, 170, 255}, + {0, 255, 255, 255}, {85, 0, 0, 255}, {85, 0, 85, 255}, + {85, 0, 170, 255}, {85, 0, 255, 255}, {85, 36, 0, 255}, + {85, 36, 85, 255}, {85, 36, 170, 255}, {85, 36, 255, 255}, + {85, 73, 0, 255}, {85, 73, 85, 255}, {85, 73, 170, 255}, + {85, 73, 255, 255}, {85, 109, 0, 255}, {85, 109, 85, 255}, + {85, 109, 170, 255}, {85, 109, 255, 255}, {85, 146, 0, 255}, + {85, 146, 85, 255}, {85, 146, 170, 255}, {85, 146, 255, 255}, + {85, 182, 0, 255}, {85, 182, 85, 255}, {85, 182, 170, 255}, + {85, 182, 255, 255}, {85, 219, 0, 255}, {85, 219, 85, 255}, + {85, 219, 170, 255}, {85, 219, 255, 255}, {85, 255, 0, 255}, + {85, 255, 85, 255}, {85, 255, 170, 255}, {85, 255, 255, 255}, + {170, 0, 0, 255}, {170, 0, 85, 255}, {170, 0, 170, 255}, + {170, 0, 255, 255}, {170, 36, 0, 255}, {170, 36, 85, 255}, + {170, 36, 170, 255}, {170, 36, 255, 255}, {170, 73, 0, 255}, + {170, 73, 85, 255}, {170, 73, 170, 255}, {170, 73, 255, 255}, + {170, 109, 0, 255}, {170, 109, 85, 255}, {170, 109, 170, 255}, + {170, 109, 255, 255}, {170, 146, 0, 255}, {170, 146, 85, 255}, + {170, 146, 170, 255}, {170, 146, 255, 255}, {170, 182, 0, 255}, + {170, 182, 85, 255}, {170, 182, 170, 255}, {170, 182, 255, 255}, + {170, 219, 0, 255}, {170, 219, 85, 255}, {170, 219, 170, 255}, + {170, 219, 255, 255}, {170, 255, 0, 255}, {170, 255, 85, 255}, + {170, 255, 170, 255}, {170, 255, 255, 255}, {255, 0, 0, 255}, + {255, 0, 85, 255}, {255, 0, 170, 255}, {255, 0, 255, 255}, + {255, 36, 0, 255}, {255, 36, 85, 255}, {255, 36, 170, 255}, + {255, 36, 255, 255}, {255, 73, 0, 255}, {255, 73, 85, 255}, + {255, 73, 170, 255}, {255, 73, 255, 255}, {255, 109, 0, 255}, + {255, 109, 85, 255}, {255, 109, 170, 255}, {255, 109, 255, 255}, + {255, 146, 0, 255}, {255, 146, 85, 255}, {255, 146, 170, 255}, + {255, 146, 255, 255}, {255, 182, 0, 255}, {255, 182, 85, 255}, + {255, 182, 170, 255}, {255, 182, 255, 255}, {255, 219, 0, 255}, + {255, 219, 85, 255}, {255, 219, 170, 255}, {255, 219, 255, 255}, + {255, 255, 0, 255}, {255, 255, 85, 255}, {255, 255, 170, 255}, + {255, 255, 255, 255}}; + +static const int default_palette_size = + (int)(sizeof(default_palette_colors) / sizeof(SDL_Color)); + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/pgarrinter.h b/kelner/venv/Include/site/python3.7/pygame/pgarrinter.h new file mode 100644 index 0000000..5ba096b --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/pgarrinter.h @@ -0,0 +1,26 @@ +/* array structure interface version 3 declarations */ + +#if !defined(PG_ARRAYINTER_HEADER) +#define PG_ARRAYINTER_HEADER + +static const int PAI_CONTIGUOUS = 0x01; +static const int PAI_FORTRAN = 0x02; +static const int PAI_ALIGNED = 0x100; +static const int PAI_NOTSWAPPED = 0x200; +static const int PAI_WRITEABLE = 0x400; +static const int PAI_ARR_HAS_DESCR = 0x800; + +typedef struct { + int two; /* contains the integer 2 -- simple sanity check */ + int nd; /* number of dimensions */ + char typekind; /* kind in array -- character code of typestr */ + int itemsize; /* size of each element */ + int flags; /* flags indicating how the data should be */ + /* interpreted */ + Py_intptr_t *shape; /* A length-nd array of shape information */ + Py_intptr_t *strides; /* A length-nd array of stride information */ + void *data; /* A pointer to the first element of the array */ + PyObject *descr; /* NULL or a data-description */ +} PyArrayInterface; + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/pgbufferproxy.h b/kelner/venv/Include/site/python3.7/pygame/pgbufferproxy.h new file mode 100644 index 0000000..92dc2f0 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/pgbufferproxy.h @@ -0,0 +1,52 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + Copyright (C) 2007 Rene Dudfield, Richard Goedeken + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +/* Bufferproxy module C api. + Depends on pygame.h being included first. + */ +#if !defined(PG_BUFPROXY_HEADER) + +#define PYGAMEAPI_BUFPROXY_NUMSLOTS 4 +#define PYGAMEAPI_BUFPROXY_FIRSTSLOT 0 + +#if !(defined(PYGAMEAPI_BUFPROXY_INTERNAL) || defined(NO_PYGAME_C_API)) +static void *PgBUFPROXY_C_API[PYGAMEAPI_BUFPROXY_NUMSLOTS]; + +typedef PyObject *(*_pgbufproxy_new_t)(PyObject *, getbufferproc); +typedef PyObject *(*_pgbufproxy_get_obj_t)(PyObject *); +typedef int (*_pgbufproxy_trip_t)(PyObject *); + +#define pgBufproxy_Type (*(PyTypeObject*)PgBUFPROXY_C_API[0]) +#define pgBufproxy_New (*(_pgbufproxy_new_t)PgBUFPROXY_C_API[1]) +#define pgBufproxy_GetParent \ + (*(_pgbufproxy_get_obj_t)PgBUFPROXY_C_API[2]) +#define pgBufproxy_Trip (*(_pgbufproxy_trip_t)PgBUFPROXY_C_API[3]) +#define pgBufproxy_Check(x) ((x)->ob_type == (pgBufproxy_Type)) +#define import_pygame_bufferproxy() \ + _IMPORT_PYGAME_MODULE(bufferproxy, BUFPROXY, PgBUFPROXY_C_API) + +#endif /* #if !(defined(PYGAMEAPI_BUFPROXY_INTERNAL) || ... */ + +#define PG_BUFPROXY_HEADER + +#endif /* #if !defined(PG_BUFPROXY_HEADER) */ diff --git a/kelner/venv/Include/site/python3.7/pygame/pgcompat.h b/kelner/venv/Include/site/python3.7/pygame/pgcompat.h new file mode 100644 index 0000000..9eb1b88 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/pgcompat.h @@ -0,0 +1,195 @@ +/* Python 2.x/3.x compitibility tools + */ + +#if !defined(PGCOMPAT_H) +#define PGCOMPAT_H + +#if PY_MAJOR_VERSION >= 3 + +#define PY3 1 + +/* Define some aliases for the removed PyInt_* functions */ +#define PyInt_Check(op) PyLong_Check(op) +#define PyInt_FromString PyLong_FromString +#define PyInt_FromUnicode PyLong_FromUnicode +#define PyInt_FromLong PyLong_FromLong +#define PyInt_FromSize_t PyLong_FromSize_t +#define PyInt_FromSsize_t PyLong_FromSsize_t +#define PyInt_AsLong PyLong_AsLong +#define PyInt_AsSsize_t PyLong_AsSsize_t +#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask +#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask +#define PyInt_AS_LONG PyLong_AS_LONG +#define PyNumber_Int PyNumber_Long + +/* Weakrefs flags changed in 3.x */ +#define Py_TPFLAGS_HAVE_WEAKREFS 0 + +/* Module init function returns new module instance. */ +#define MODINIT_RETURN(x) return x +#define MODINIT_DEFINE(mod_name) PyMODINIT_FUNC PyInit_##mod_name (void) +#define DECREF_MOD(mod) Py_DECREF (mod) + +/* Type header differs. */ +#define TYPE_HEAD(x,y) PyVarObject_HEAD_INIT(x,y) + +/* Text interface. Use unicode strings. */ +#define Text_Type PyUnicode_Type +#define Text_Check PyUnicode_Check + +#ifndef PYPY_VERSION +#define Text_FromLocale(s) PyUnicode_DecodeLocale((s), "strict") +#else /* PYPY_VERSION */ +/* workaround: missing function for pypy */ +#define Text_FromLocale PyUnicode_FromString +#endif /* PYPY_VERSION */ + +#define Text_FromUTF8 PyUnicode_FromString +#define Text_FromUTF8AndSize PyUnicode_FromStringAndSize +#define Text_FromFormat PyUnicode_FromFormat +#define Text_GetSize PyUnicode_GetSize +#define Text_GET_SIZE PyUnicode_GET_SIZE + +/* Binary interface. Use bytes. */ +#define Bytes_Type PyBytes_Type +#define Bytes_Check PyBytes_Check +#define Bytes_Size PyBytes_Size +#define Bytes_AsString PyBytes_AsString +#define Bytes_AsStringAndSize PyBytes_AsStringAndSize +#define Bytes_FromStringAndSize PyBytes_FromStringAndSize +#define Bytes_FromFormat PyBytes_FromFormat +#define Bytes_AS_STRING PyBytes_AS_STRING +#define Bytes_GET_SIZE PyBytes_GET_SIZE +#define Bytes_AsDecodeObject PyBytes_AsDecodedObject + +#define Object_Unicode PyObject_Str + +#define IsTextObj(x) (PyUnicode_Check(x) || PyBytes_Check(x)) + +/* Renamed builtins */ +#define BUILTINS_MODULE "builtins" +#define BUILTINS_UNICODE "str" +#define BUILTINS_UNICHR "chr" + +/* Defaults for unicode file path encoding */ +#define UNICODE_DEF_FS_CODEC Py_FileSystemDefaultEncoding +#if defined(MS_WIN32) +#define UNICODE_DEF_FS_ERROR "replace" +#else +#define UNICODE_DEF_FS_ERROR "surrogateescape" +#endif + +#else /* #if PY_MAJOR_VERSION >= 3 */ + +#define PY3 0 + +/* Module init function returns nothing. */ +#define MODINIT_RETURN(x) return +#define MODINIT_DEFINE(mod_name) PyMODINIT_FUNC init##mod_name (void) +#define DECREF_MOD(mod) + +/* Type header differs. */ +#define TYPE_HEAD(x,y) \ + PyObject_HEAD_INIT(x) \ + 0, + +/* Text interface. Use ascii strings. */ +#define Text_Type PyString_Type +#define Text_Check PyString_Check +#define Text_FromLocale PyString_FromString +#define Text_FromUTF8 PyString_FromString +#define Text_FromUTF8AndSize PyString_FromStringAndSize +#define Text_FromFormat PyString_FromFormat +#define Text_GetSize PyString_GetSize +#define Text_GET_SIZE PyString_GET_SIZE + +/* Binary interface. Use ascii strings. */ +#define Bytes_Type PyString_Type +#define Bytes_Check PyString_Check +#define Bytes_Size PyString_Size +#define Bytes_AsString PyString_AsString +#define Bytes_AsStringAndSize PyString_AsStringAndSize +#define Bytes_FromStringAndSize PyString_FromStringAndSize +#define Bytes_FromFormat PyString_FromFormat +#define Bytes_AS_STRING PyString_AS_STRING +#define Bytes_GET_SIZE PyString_GET_SIZE +#define Bytes_AsDecodedObject PyString_AsDecodedObject + +#define Object_Unicode PyObject_Unicode + +/* Renamed builtins */ +#define BUILTINS_MODULE "__builtin__" +#define BUILTINS_UNICODE "unicode" +#define BUILTINS_UNICHR "unichr" + +/* Defaults for unicode file path encoding */ +#define UNICODE_DEF_FS_CODEC Py_FileSystemDefaultEncoding +#define UNICODE_DEF_FS_ERROR "strict" + +#endif /* #if PY_MAJOR_VERSION >= 3 */ + +#define PY2 (!PY3) + +#define MODINIT_ERROR MODINIT_RETURN (NULL) + +/* Module state. These macros are used to define per-module macros. + * v - global state variable (Python 2.x) + * s - global state structure (Python 3.x) + */ +#define PY2_GETSTATE(v) (&(v)) +#define PY3_GETSTATE(s, m) ((struct s *) PyModule_GetState (m)) + +/* Pep 3123: Making PyObject_HEAD conform to standard C */ +#if !defined(Py_TYPE) +#define Py_TYPE(o) (((PyObject *)(o))->ob_type) +#define Py_REFCNT(o) (((PyObject *)(o))->ob_refcnt) +#define Py_SIZE(o) (((PyVarObject *)(o))->ob_size) +#endif + +/* Encode a unicode file path */ +#define Unicode_AsEncodedPath(u) \ + PyUnicode_AsEncodedString ((u), UNICODE_DEF_FS_CODEC, UNICODE_DEF_FS_ERROR) + +#define RELATIVE_MODULE(m) ("." m) + +#define HAVE_OLD_BUFPROTO PY2 + +#if !defined(PG_ENABLE_OLDBUF) /* allow for command line override */ +#if HAVE_OLD_BUFPROTO +#define PG_ENABLE_OLDBUF 1 +#else +#define PG_ENABLE_OLDBUF 0 +#endif +#endif + +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER +#define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif + +#ifndef Py_TPFLAGS_HAVE_CLASS +#define Py_TPFLAGS_HAVE_CLASS 0 +#endif + +#ifndef Py_TPFLAGS_CHECKTYPES +#define Py_TPFLAGS_CHECKTYPES 0 +#endif + +#if PY_VERSION_HEX >= 0x03020000 +#define Slice_GET_INDICES_EX(slice, length, start, stop, step, slicelength) \ + PySlice_GetIndicesEx(slice, length, start, stop, step, slicelength) +#else +#define Slice_GET_INDICES_EX(slice, length, start, stop, step, slicelength) \ + PySlice_GetIndicesEx((PySliceObject *)(slice), length, \ + start, stop, step, slicelength) +#endif + +/* Support new buffer protocol? */ +#if !defined(PG_ENABLE_NEWBUF) /* allow for command line override */ +#if !defined(PYPY_VERSION) +#define PG_ENABLE_NEWBUF 1 +#else +#define PG_ENABLE_NEWBUF 0 +#endif +#endif + +#endif /* #if !defined(PGCOMPAT_H) */ diff --git a/kelner/venv/Include/site/python3.7/pygame/pgopengl.h b/kelner/venv/Include/site/python3.7/pygame/pgopengl.h new file mode 100644 index 0000000..3c80dca --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/pgopengl.h @@ -0,0 +1,16 @@ +#if !defined(PGOPENGL_H) +#define PGOPENGL_H + +/** This header includes definitions of Opengl functions as pointer types for + ** use with the SDL function SDL_GL_GetProcAddress. + **/ + +#if defined(_WIN32) +#define GL_APIENTRY __stdcall +#else +#define GL_APIENTRY +#endif + +typedef void (GL_APIENTRY *GL_glReadPixels_Func)(int, int, int, int, unsigned int, unsigned int, void*); + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/pygame.h b/kelner/venv/Include/site/python3.7/pygame/pygame.h new file mode 100644 index 0000000..bcbf1d9 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/pygame.h @@ -0,0 +1,34 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +/* To allow the Pygame C api to be globally shared by all code within an + * extension module built from multiple C files, only include the pygame.h + * header within the top level C file, the one which calls the + * 'import_pygame_*' macros. All other C source files of the module should + * include _pygame.h instead. + */ +#ifndef PYGAME_H +#define PYGAME_H + +#include "_pygame.h" + +#endif diff --git a/kelner/venv/Include/site/python3.7/pygame/scrap.h b/kelner/venv/Include/site/python3.7/pygame/scrap.h new file mode 100644 index 0000000..b1b3856 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/scrap.h @@ -0,0 +1,143 @@ +/* + pygame - Python Game Library + Copyright (C) 2006, 2007 Rene Dudfield, Marcus von Appen + + Originally put in the public domain by Sam Lantinga. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +/* This is unconditionally defined in Python.h */ +#if defined(_POSIX_C_SOURCE) +#undef _POSIX_C_SOURCE +#endif + +#include + +/* Handle clipboard text and data in arbitrary formats */ + +/** + * Predefined supported pygame scrap types. + */ +#define PYGAME_SCRAP_TEXT "text/plain" +#define PYGAME_SCRAP_BMP "image/bmp" +#define PYGAME_SCRAP_PPM "image/ppm" +#define PYGAME_SCRAP_PBM "image/pbm" + +/** + * The supported scrap clipboard types. + * + * This is only relevant in a X11 environment, which supports mouse + * selections as well. For Win32 and MacOS environments the default + * clipboard is used, no matter what value is passed. + */ +typedef enum +{ + SCRAP_CLIPBOARD, + SCRAP_SELECTION /* only supported in X11 environments. */ +} ScrapClipType; + +/** + * Macro for initialization checks. + */ +#define PYGAME_SCRAP_INIT_CHECK() \ + if(!pygame_scrap_initialized()) \ + return (PyErr_SetString (pgExc_SDLError, \ + "scrap system not initialized."), NULL) + +/** + * \brief Checks, whether the pygame scrap module was initialized. + * + * \return 1 if the modules was initialized, 0 otherwise. + */ +extern int +pygame_scrap_initialized (void); + +/** + * \brief Initializes the pygame scrap module internals. Call this before any + * other method. + * + * \return 1 on successful initialization, 0 otherwise. + */ +extern int +pygame_scrap_init (void); + +/** + * \brief Checks, whether the pygame window lost the clipboard focus or not. + * + * \return 1 if the window lost the focus, 0 otherwise. + */ +extern int +pygame_scrap_lost (void); + +/** + * \brief Places content of a specific type into the clipboard. + * + * \note For X11 the following notes are important: The following types + * are reserved for internal usage and thus will throw an error on + * setting them: "TIMESTAMP", "TARGETS", "SDL_SELECTION". + * Setting PYGAME_SCRAP_TEXT ("text/plain") will also automatically + * set the X11 types "STRING" (XA_STRING), "TEXT" and "UTF8_STRING". + * + * For Win32 the following notes are important: Setting + * PYGAME_SCRAP_TEXT ("text/plain") will also automatically set + * the Win32 type "TEXT" (CF_TEXT). + * + * For QNX the following notes are important: Setting + * PYGAME_SCRAP_TEXT ("text/plain") will also automatically set + * the QNX type "TEXT" (Ph_CL_TEXT). + * + * \param type The type of the content. + * \param srclen The length of the content. + * \param src The NULL terminated content. + * \return 1, if the content could be successfully pasted into the clipboard, + * 0 otherwise. + */ +extern int +pygame_scrap_put (char *type, int srclen, char *src); + +/** + * \brief Gets the current content from the clipboard. + * + * \note The received content does not need to be the content previously + * placed in the clipboard using pygame_put_scrap(). See the + * pygame_put_scrap() notes for more details. + * + * \param type The type of the content to receive. + * \param count The size of the returned content. + * \return The content or NULL in case of an error or if no content of the + * specified type was available. + */ +extern char* +pygame_scrap_get (char *type, unsigned long *count); + +/** + * \brief Gets the currently available content types from the clipboard. + * + * \return The different available content types or NULL in case of an + * error or if no content type is available. + */ +extern char** +pygame_scrap_get_types (void); + +/** + * \brief Checks whether content for the specified scrap type is currently + * available in the clipboard. + * + * \param type The type to check for. + * \return 1, if there is content and 0 otherwise. + */ +extern int +pygame_scrap_contains (char *type); diff --git a/kelner/venv/Include/site/python3.7/pygame/surface.h b/kelner/venv/Include/site/python3.7/pygame/surface.h new file mode 100644 index 0000000..cc5f071 --- /dev/null +++ b/kelner/venv/Include/site/python3.7/pygame/surface.h @@ -0,0 +1,383 @@ +/* + pygame - Python Game Library + Copyright (C) 2000-2001 Pete Shinners + Copyright (C) 2007 Marcus von Appen + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. + + You should have received a copy of the GNU Library General Public + License along with this library; if not, write to the Free + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + Pete Shinners + pete@shinners.org +*/ + +#ifndef SURFACE_H +#define SURFACE_H + +/* This is defined in SDL.h */ +#if defined(_POSIX_C_SOURCE) +#undef _POSIX_C_SOURCE +#endif + +#include +#include "pygame.h" + +/* Blend modes */ +#define PYGAME_BLEND_ADD 0x1 +#define PYGAME_BLEND_SUB 0x2 +#define PYGAME_BLEND_MULT 0x3 +#define PYGAME_BLEND_MIN 0x4 +#define PYGAME_BLEND_MAX 0x5 + +#define PYGAME_BLEND_RGB_ADD 0x1 +#define PYGAME_BLEND_RGB_SUB 0x2 +#define PYGAME_BLEND_RGB_MULT 0x3 +#define PYGAME_BLEND_RGB_MIN 0x4 +#define PYGAME_BLEND_RGB_MAX 0x5 + +#define PYGAME_BLEND_RGBA_ADD 0x6 +#define PYGAME_BLEND_RGBA_SUB 0x7 +#define PYGAME_BLEND_RGBA_MULT 0x8 +#define PYGAME_BLEND_RGBA_MIN 0x9 +#define PYGAME_BLEND_RGBA_MAX 0x10 +#define PYGAME_BLEND_PREMULTIPLIED 0x11 + + + + + +#if SDL_BYTEORDER == SDL_LIL_ENDIAN +#define GET_PIXEL_24(b) (b[0] + (b[1] << 8) + (b[2] << 16)) +#else +#define GET_PIXEL_24(b) (b[2] + (b[1] << 8) + (b[0] << 16)) +#endif + +#define GET_PIXEL(pxl, bpp, source) \ + switch (bpp) \ + { \ + case 2: \ + pxl = *((Uint16 *) (source)); \ + break; \ + case 4: \ + pxl = *((Uint32 *) (source)); \ + break; \ + default: \ + { \ + Uint8 *b = (Uint8 *) source; \ + pxl = GET_PIXEL_24(b); \ + } \ + break; \ + } + +#if IS_SDLv1 +#define GET_PIXELVALS(_sR, _sG, _sB, _sA, px, fmt, ppa) \ + _sR = ((px & fmt->Rmask) >> fmt->Rshift); \ + _sR = (_sR << fmt->Rloss) + (_sR >> (8 - (fmt->Rloss << 1))); \ + _sG = ((px & fmt->Gmask) >> fmt->Gshift); \ + _sG = (_sG << fmt->Gloss) + (_sG >> (8 - (fmt->Gloss << 1))); \ + _sB = ((px & fmt->Bmask) >> fmt->Bshift); \ + _sB = (_sB << fmt->Bloss) + (_sB >> (8 - (fmt->Bloss << 1))); \ + if (ppa) \ + { \ + _sA = ((px & fmt->Amask) >> fmt->Ashift); \ + _sA = (_sA << fmt->Aloss) + (_sA >> (8 - (fmt->Aloss << 1))); \ + } \ + else \ + { \ + _sA = 255; \ + } + +#define GET_PIXELVALS_1(sr, sg, sb, sa, _src, _fmt) \ + sr = _fmt->palette->colors[*((Uint8 *) (_src))].r; \ + sg = _fmt->palette->colors[*((Uint8 *) (_src))].g; \ + sb = _fmt->palette->colors[*((Uint8 *) (_src))].b; \ + sa = 255; + +/* For 1 byte palette pixels */ +#define SET_PIXELVAL(px, fmt, _dR, _dG, _dB, _dA) \ + *(px) = (Uint8) SDL_MapRGB(fmt, _dR, _dG, _dB) +#else /* IS_SDLv2 */ +#define GET_PIXELVALS(_sR, _sG, _sB, _sA, px, fmt, ppa) \ + SDL_GetRGBA(px, fmt, &(_sR), &(_sG), &(_sB), &(_sA)); \ + if (!ppa) { \ + _sA = 255; \ + } + +#define GET_PIXELVALS_1(sr, sg, sb, sa, _src, _fmt) \ + sr = _fmt->palette->colors[*((Uint8 *) (_src))].r; \ + sg = _fmt->palette->colors[*((Uint8 *) (_src))].g; \ + sb = _fmt->palette->colors[*((Uint8 *) (_src))].b; \ + sa = 255; + +/* For 1 byte palette pixels */ +#define SET_PIXELVAL(px, fmt, _dR, _dG, _dB, _dA) \ + *(px) = (Uint8) SDL_MapRGBA(fmt, _dR, _dG, _dB, _dA) +#endif /* IS_SDLv2 */ + + + + + + + + +#if SDL_BYTEORDER == SDL_LIL_ENDIAN +#define SET_OFFSETS_24(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 0 : \ + fmt->Rshift == 8 ? 1 : \ + 2 ); \ + og = (fmt->Gshift == 0 ? 0 : \ + fmt->Gshift == 8 ? 1 : \ + 2 ); \ + ob = (fmt->Bshift == 0 ? 0 : \ + fmt->Bshift == 8 ? 1 : \ + 2 ); \ + } + +#define SET_OFFSETS_32(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 0 : \ + fmt->Rshift == 8 ? 1 : \ + fmt->Rshift == 16 ? 2 : \ + 3 ); \ + og = (fmt->Gshift == 0 ? 0 : \ + fmt->Gshift == 8 ? 1 : \ + fmt->Gshift == 16 ? 2 : \ + 3 ); \ + ob = (fmt->Bshift == 0 ? 0 : \ + fmt->Bshift == 8 ? 1 : \ + fmt->Bshift == 16 ? 2 : \ + 3 ); \ + } +#else +#define SET_OFFSETS_24(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 2 : \ + fmt->Rshift == 8 ? 1 : \ + 0 ); \ + og = (fmt->Gshift == 0 ? 2 : \ + fmt->Gshift == 8 ? 1 : \ + 0 ); \ + ob = (fmt->Bshift == 0 ? 2 : \ + fmt->Bshift == 8 ? 1 : \ + 0 ); \ + } + +#define SET_OFFSETS_32(or, og, ob, fmt) \ + { \ + or = (fmt->Rshift == 0 ? 3 : \ + fmt->Rshift == 8 ? 2 : \ + fmt->Rshift == 16 ? 1 : \ + 0 ); \ + og = (fmt->Gshift == 0 ? 3 : \ + fmt->Gshift == 8 ? 2 : \ + fmt->Gshift == 16 ? 1 : \ + 0 ); \ + ob = (fmt->Bshift == 0 ? 3 : \ + fmt->Bshift == 8 ? 2 : \ + fmt->Bshift == 16 ? 1 : \ + 0 ); \ + } +#endif + + +#define CREATE_PIXEL(buf, r, g, b, a, bp, ft) \ + switch (bp) \ + { \ + case 2: \ + *((Uint16 *) (buf)) = \ + ((r >> ft->Rloss) << ft->Rshift) | \ + ((g >> ft->Gloss) << ft->Gshift) | \ + ((b >> ft->Bloss) << ft->Bshift) | \ + ((a >> ft->Aloss) << ft->Ashift); \ + break; \ + case 4: \ + *((Uint32 *) (buf)) = \ + ((r >> ft->Rloss) << ft->Rshift) | \ + ((g >> ft->Gloss) << ft->Gshift) | \ + ((b >> ft->Bloss) << ft->Bshift) | \ + ((a >> ft->Aloss) << ft->Ashift); \ + break; \ + } + +/* Pretty good idea from Tom Duff :-). */ +#define LOOP_UNROLLED4(code, n, width) \ + n = (width + 3) / 4; \ + switch (width & 3) \ + { \ + case 0: do { code; \ + case 3: code; \ + case 2: code; \ + case 1: code; \ + } while (--n > 0); \ + } + +/* Used in the srcbpp == dstbpp == 1 blend functions */ +#define REPEAT_3(code) \ + code; \ + code; \ + code; + +#define REPEAT_4(code) \ + code; \ + code; \ + code; \ + code; + + +#define BLEND_ADD(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR + sR; dR = (tmp <= 255 ? tmp : 255); \ + tmp = dG + sG; dG = (tmp <= 255 ? tmp : 255); \ + tmp = dB + sB; dB = (tmp <= 255 ? tmp : 255); + +#define BLEND_SUB(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR - sR; dR = (tmp >= 0 ? tmp : 0); \ + tmp = dG - sG; dG = (tmp >= 0 ? tmp : 0); \ + tmp = dB - sB; dB = (tmp >= 0 ? tmp : 0); + +#define BLEND_MULT(sR, sG, sB, sA, dR, dG, dB, dA) \ + dR = (dR && sR) ? (dR * sR) >> 8 : 0; \ + dG = (dG && sG) ? (dG * sG) >> 8 : 0; \ + dB = (dB && sB) ? (dB * sB) >> 8 : 0; + +#define BLEND_MIN(sR, sG, sB, sA, dR, dG, dB, dA) \ + if(sR < dR) { dR = sR; } \ + if(sG < dG) { dG = sG; } \ + if(sB < dB) { dB = sB; } + +#define BLEND_MAX(sR, sG, sB, sA, dR, dG, dB, dA) \ + if(sR > dR) { dR = sR; } \ + if(sG > dG) { dG = sG; } \ + if(sB > dB) { dB = sB; } + + + + + + +#define BLEND_RGBA_ADD(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR + sR; dR = (tmp <= 255 ? tmp : 255); \ + tmp = dG + sG; dG = (tmp <= 255 ? tmp : 255); \ + tmp = dB + sB; dB = (tmp <= 255 ? tmp : 255); \ + tmp = dA + sA; dA = (tmp <= 255 ? tmp : 255); + +#define BLEND_RGBA_SUB(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + tmp = dR - sR; dR = (tmp >= 0 ? tmp : 0); \ + tmp = dG - sG; dG = (tmp >= 0 ? tmp : 0); \ + tmp = dB - sB; dB = (tmp >= 0 ? tmp : 0); \ + tmp = dA - sA; dA = (tmp >= 0 ? tmp : 0); + +#define BLEND_RGBA_MULT(sR, sG, sB, sA, dR, dG, dB, dA) \ + dR = (dR && sR) ? (dR * sR) >> 8 : 0; \ + dG = (dG && sG) ? (dG * sG) >> 8 : 0; \ + dB = (dB && sB) ? (dB * sB) >> 8 : 0; \ + dA = (dA && sA) ? (dA * sA) >> 8 : 0; + +#define BLEND_RGBA_MIN(sR, sG, sB, sA, dR, dG, dB, dA) \ + if(sR < dR) { dR = sR; } \ + if(sG < dG) { dG = sG; } \ + if(sB < dB) { dB = sB; } \ + if(sA < dA) { dA = sA; } + +#define BLEND_RGBA_MAX(sR, sG, sB, sA, dR, dG, dB, dA) \ + if(sR > dR) { dR = sR; } \ + if(sG > dG) { dG = sG; } \ + if(sB > dB) { dB = sB; } \ + if(sA > dA) { dA = sA; } + + + + + + + + + + + +#if 1 +/* Choose an alpha blend equation. If the sign is preserved on a right shift + * then use a specialized, faster, equation. Otherwise a more general form, + * where all additions are done before the shift, is needed. +*/ +#if (-1 >> 1) < 0 +#define ALPHA_BLEND_COMP(sC, dC, sA) ((((sC - dC) * sA + sC) >> 8) + dC) +#else +#define ALPHA_BLEND_COMP(sC, dC, sA) (((dC << 8) + (sC - dC) * sA + sC) >> 8) +#endif + +#define ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB, dA) \ + do { \ + if (dA) \ + { \ + dR = ALPHA_BLEND_COMP(sR, dR, sA); \ + dG = ALPHA_BLEND_COMP(sG, dG, sA); \ + dB = ALPHA_BLEND_COMP(sB, dB, sA); \ + dA = sA + dA - ((sA * dA) / 255); \ + } \ + else \ + { \ + dR = sR; \ + dG = sG; \ + dB = sB; \ + dA = sA; \ + } \ + } while(0) + +#define ALPHA_BLEND_PREMULTIPLIED_COMP(sC, dC, sA) (sC + dC - ((dC * sA) >> 8)) + +#define ALPHA_BLEND_PREMULTIPLIED(tmp, sR, sG, sB, sA, dR, dG, dB, dA) \ + do { \ + tmp = ALPHA_BLEND_PREMULTIPLIED_COMP(sR, dR, sA); dR = (tmp > 255 ? 255 : tmp); \ + tmp = ALPHA_BLEND_PREMULTIPLIED_COMP(sG, dG, sA); dG = (tmp > 255 ? 255 : tmp); \ + tmp = ALPHA_BLEND_PREMULTIPLIED_COMP(sB, dB, sA); dB = (tmp > 255 ? 255 : tmp); \ + dA = sA + dA - ((sA * dA) / 255); \ + } while(0) +#elif 0 + +#define ALPHA_BLEND(sR, sG, sB, sA, dR, dG, dB, dA) \ + do { \ + if(sA){ \ + if(dA && sA < 255){ \ + int dContrib = dA*(255 - sA)/255; \ + dA = sA+dA - ((sA*dA)/255); \ + dR = (dR*dContrib + sR*sA)/dA; \ + dG = (dG*dContrib + sG*sA)/dA; \ + dB = (dB*dContrib + sB*sA)/dA; \ + }else{ \ + dR = sR; \ + dG = sG; \ + dB = sB; \ + dA = sA; \ + } \ + } \ + } while(0) +#endif + +int +surface_fill_blend (SDL_Surface *surface, SDL_Rect *rect, Uint32 color, + int blendargs); + +void +surface_respect_clip_rect (SDL_Surface *surface, SDL_Rect *rect); + +int +pygame_AlphaBlit (SDL_Surface * src, SDL_Rect * srcrect, + SDL_Surface * dst, SDL_Rect * dstrect, int the_args); + +int +pygame_Blit (SDL_Surface * src, SDL_Rect * srcrect, + SDL_Surface * dst, SDL_Rect * dstrect, int the_args); + +#endif /* SURFACE_H */ diff --git a/kelner/venv/Scripts/Activate.ps1 b/kelner/venv/Scripts/Activate.ps1 new file mode 100644 index 0000000..13546af --- /dev/null +++ b/kelner/venv/Scripts/Activate.ps1 @@ -0,0 +1,51 @@ +function global:deactivate ([switch]$NonDestructive) { + # Revert to original values + if (Test-Path function:_OLD_VIRTUAL_PROMPT) { + copy-item function:_OLD_VIRTUAL_PROMPT function:prompt + remove-item function:_OLD_VIRTUAL_PROMPT + } + + if (Test-Path env:_OLD_VIRTUAL_PYTHONHOME) { + copy-item env:_OLD_VIRTUAL_PYTHONHOME env:PYTHONHOME + remove-item env:_OLD_VIRTUAL_PYTHONHOME + } + + if (Test-Path env:_OLD_VIRTUAL_PATH) { + copy-item env:_OLD_VIRTUAL_PATH env:PATH + remove-item env:_OLD_VIRTUAL_PATH + } + + if (Test-Path env:VIRTUAL_ENV) { + remove-item env:VIRTUAL_ENV + } + + if (!$NonDestructive) { + # Self destruct! + remove-item function:deactivate + } +} + +deactivate -nondestructive + +$env:VIRTUAL_ENV="J:\PycharmProjects\kelner\venv" + +if (! $env:VIRTUAL_ENV_DISABLE_PROMPT) { + # Set the prompt to include the env name + # Make sure _OLD_VIRTUAL_PROMPT is global + function global:_OLD_VIRTUAL_PROMPT {""} + copy-item function:prompt function:_OLD_VIRTUAL_PROMPT + function global:prompt { + Write-Host -NoNewline -ForegroundColor Green '(venv) ' + _OLD_VIRTUAL_PROMPT + } +} + +# Clear PYTHONHOME +if (Test-Path env:PYTHONHOME) { + copy-item env:PYTHONHOME env:_OLD_VIRTUAL_PYTHONHOME + remove-item env:PYTHONHOME +} + +# Add the venv to the PATH +copy-item env:PATH env:_OLD_VIRTUAL_PATH +$env:PATH = "$env:VIRTUAL_ENV\Scripts;$env:PATH" diff --git a/kelner/venv/Scripts/activate b/kelner/venv/Scripts/activate new file mode 100644 index 0000000..0081656 --- /dev/null +++ b/kelner/venv/Scripts/activate @@ -0,0 +1,76 @@ +# This file must be used with "source bin/activate" *from bash* +# you cannot run it directly + +deactivate () { + # reset old environment variables + if [ -n "${_OLD_VIRTUAL_PATH:-}" ] ; then + PATH="${_OLD_VIRTUAL_PATH:-}" + export PATH + unset _OLD_VIRTUAL_PATH + fi + if [ -n "${_OLD_VIRTUAL_PYTHONHOME:-}" ] ; then + PYTHONHOME="${_OLD_VIRTUAL_PYTHONHOME:-}" + export PYTHONHOME + unset _OLD_VIRTUAL_PYTHONHOME + fi + + # This should detect bash and zsh, which have a hash command that must + # be called to get it to forget past commands. Without forgetting + # past commands the $PATH changes we made may not be respected + if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r + fi + + if [ -n "${_OLD_VIRTUAL_PS1:-}" ] ; then + PS1="${_OLD_VIRTUAL_PS1:-}" + export PS1 + unset _OLD_VIRTUAL_PS1 + fi + + unset VIRTUAL_ENV + if [ ! "$1" = "nondestructive" ] ; then + # Self destruct! + unset -f deactivate + fi +} + +# unset irrelevant variables +deactivate nondestructive + +VIRTUAL_ENV="J:\PycharmProjects\kelner\venv" +export VIRTUAL_ENV + +_OLD_VIRTUAL_PATH="$PATH" +PATH="$VIRTUAL_ENV/Scripts:$PATH" +export PATH + +# unset PYTHONHOME if set +# this will fail if PYTHONHOME is set to the empty string (which is bad anyway) +# could use `if (set -u; : $PYTHONHOME) ;` in bash +if [ -n "${PYTHONHOME:-}" ] ; then + _OLD_VIRTUAL_PYTHONHOME="${PYTHONHOME:-}" + unset PYTHONHOME +fi + +if [ -z "${VIRTUAL_ENV_DISABLE_PROMPT:-}" ] ; then + _OLD_VIRTUAL_PS1="${PS1:-}" + if [ "x(venv) " != x ] ; then + PS1="(venv) ${PS1:-}" + else + if [ "`basename \"$VIRTUAL_ENV\"`" = "__" ] ; then + # special case for Aspen magic directories + # see http://www.zetadev.com/software/aspen/ + PS1="[`basename \`dirname \"$VIRTUAL_ENV\"\``] $PS1" + else + PS1="(`basename \"$VIRTUAL_ENV\"`)$PS1" + fi + fi + export PS1 +fi + +# This should detect bash and zsh, which have a hash command that must +# be called to get it to forget past commands. Without forgetting +# past commands the $PATH changes we made may not be respected +if [ -n "${BASH:-}" -o -n "${ZSH_VERSION:-}" ] ; then + hash -r +fi diff --git a/kelner/venv/Scripts/activate.bat b/kelner/venv/Scripts/activate.bat new file mode 100644 index 0000000..9198ab3 --- /dev/null +++ b/kelner/venv/Scripts/activate.bat @@ -0,0 +1,45 @@ +@echo off + +rem This file is UTF-8 encoded, so we need to update the current code page while executing it +for /f "tokens=2 delims=:" %%a in ('"%SystemRoot%\System32\chcp.com"') do ( + set "_OLD_CODEPAGE=%%a" +) +if defined _OLD_CODEPAGE ( + "%SystemRoot%\System32\chcp.com" 65001 > nul +) + +set "VIRTUAL_ENV=J:\PycharmProjects\kelner\venv" + +if not defined PROMPT ( + set "PROMPT=$P$G" +) + +if defined _OLD_VIRTUAL_PROMPT ( + set "PROMPT=%_OLD_VIRTUAL_PROMPT%" +) + +if defined _OLD_VIRTUAL_PYTHONHOME ( + set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%" +) + +set "_OLD_VIRTUAL_PROMPT=%PROMPT%" +set "PROMPT=(venv) %PROMPT%" + +if defined PYTHONHOME ( + set "_OLD_VIRTUAL_PYTHONHOME=%PYTHONHOME%" + set PYTHONHOME= +) + +if defined _OLD_VIRTUAL_PATH ( + set "PATH=%_OLD_VIRTUAL_PATH%" +) else ( + set "_OLD_VIRTUAL_PATH=%PATH%" +) + +set "PATH=%VIRTUAL_ENV%\Scripts;%PATH%" + +:END +if defined _OLD_CODEPAGE ( + "%SystemRoot%\System32\chcp.com" %_OLD_CODEPAGE% > nul + set "_OLD_CODEPAGE=" +) diff --git a/kelner/venv/Scripts/deactivate.bat b/kelner/venv/Scripts/deactivate.bat new file mode 100644 index 0000000..313c079 --- /dev/null +++ b/kelner/venv/Scripts/deactivate.bat @@ -0,0 +1,21 @@ +@echo off + +if defined _OLD_VIRTUAL_PROMPT ( + set "PROMPT=%_OLD_VIRTUAL_PROMPT%" +) +set _OLD_VIRTUAL_PROMPT= + +if defined _OLD_VIRTUAL_PYTHONHOME ( + set "PYTHONHOME=%_OLD_VIRTUAL_PYTHONHOME%" + set _OLD_VIRTUAL_PYTHONHOME= +) + +if defined _OLD_VIRTUAL_PATH ( + set "PATH=%_OLD_VIRTUAL_PATH%" +) + +set _OLD_VIRTUAL_PATH= + +set VIRTUAL_ENV= + +:END diff --git a/kelner/venv/Scripts/easy_install-3.7-script.py b/kelner/venv/Scripts/easy_install-3.7-script.py new file mode 100644 index 0000000..9a7ce5e --- /dev/null +++ b/kelner/venv/Scripts/easy_install-3.7-script.py @@ -0,0 +1,12 @@ +#!J:\PycharmProjects\kelner\venv\Scripts\python.exe +# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==40.8.0','console_scripts','easy_install-3.7' +__requires__ = 'setuptools==40.8.0' +import re +import sys +from pkg_resources import load_entry_point + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit( + load_entry_point('setuptools==40.8.0', 'console_scripts', 'easy_install-3.7')() + ) diff --git a/kelner/venv/Scripts/easy_install-3.7.exe b/kelner/venv/Scripts/easy_install-3.7.exe new file mode 100644 index 0000000..675e6bf Binary files /dev/null and b/kelner/venv/Scripts/easy_install-3.7.exe differ diff --git a/kelner/venv/Scripts/easy_install-script.py b/kelner/venv/Scripts/easy_install-script.py new file mode 100644 index 0000000..bf9c535 --- /dev/null +++ b/kelner/venv/Scripts/easy_install-script.py @@ -0,0 +1,12 @@ +#!J:\PycharmProjects\kelner\venv\Scripts\python.exe +# EASY-INSTALL-ENTRY-SCRIPT: 'setuptools==40.8.0','console_scripts','easy_install' +__requires__ = 'setuptools==40.8.0' +import re +import sys +from pkg_resources import load_entry_point + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit( + load_entry_point('setuptools==40.8.0', 'console_scripts', 'easy_install')() + ) diff --git a/kelner/venv/Scripts/easy_install.exe b/kelner/venv/Scripts/easy_install.exe new file mode 100644 index 0000000..675e6bf Binary files /dev/null and b/kelner/venv/Scripts/easy_install.exe differ diff --git a/kelner/venv/Scripts/pip-script.py b/kelner/venv/Scripts/pip-script.py new file mode 100644 index 0000000..e772aa8 --- /dev/null +++ b/kelner/venv/Scripts/pip-script.py @@ -0,0 +1,12 @@ +#!J:\PycharmProjects\kelner\venv\Scripts\python.exe +# EASY-INSTALL-ENTRY-SCRIPT: 'pip==19.0.3','console_scripts','pip' +__requires__ = 'pip==19.0.3' +import re +import sys +from pkg_resources import load_entry_point + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit( + load_entry_point('pip==19.0.3', 'console_scripts', 'pip')() + ) diff --git a/kelner/venv/Scripts/pip.exe b/kelner/venv/Scripts/pip.exe new file mode 100644 index 0000000..675e6bf Binary files /dev/null and b/kelner/venv/Scripts/pip.exe differ diff --git a/kelner/venv/Scripts/pip3-script.py b/kelner/venv/Scripts/pip3-script.py new file mode 100644 index 0000000..10d28a9 --- /dev/null +++ b/kelner/venv/Scripts/pip3-script.py @@ -0,0 +1,12 @@ +#!J:\PycharmProjects\kelner\venv\Scripts\python.exe +# EASY-INSTALL-ENTRY-SCRIPT: 'pip==19.0.3','console_scripts','pip3' +__requires__ = 'pip==19.0.3' +import re +import sys +from pkg_resources import load_entry_point + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit( + load_entry_point('pip==19.0.3', 'console_scripts', 'pip3')() + ) diff --git a/kelner/venv/Scripts/pip3.7-script.py b/kelner/venv/Scripts/pip3.7-script.py new file mode 100644 index 0000000..e230926 --- /dev/null +++ b/kelner/venv/Scripts/pip3.7-script.py @@ -0,0 +1,12 @@ +#!J:\PycharmProjects\kelner\venv\Scripts\python.exe +# EASY-INSTALL-ENTRY-SCRIPT: 'pip==19.0.3','console_scripts','pip3.7' +__requires__ = 'pip==19.0.3' +import re +import sys +from pkg_resources import load_entry_point + +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw?|\.exe)?$', '', sys.argv[0]) + sys.exit( + load_entry_point('pip==19.0.3', 'console_scripts', 'pip3.7')() + ) diff --git a/kelner/venv/Scripts/pip3.7.exe b/kelner/venv/Scripts/pip3.7.exe new file mode 100644 index 0000000..675e6bf Binary files /dev/null and b/kelner/venv/Scripts/pip3.7.exe differ diff --git a/kelner/venv/Scripts/pip3.exe b/kelner/venv/Scripts/pip3.exe new file mode 100644 index 0000000..675e6bf Binary files /dev/null and b/kelner/venv/Scripts/pip3.exe differ diff --git a/kelner/venv/Scripts/python.exe b/kelner/venv/Scripts/python.exe new file mode 100644 index 0000000..371dc7f Binary files /dev/null and b/kelner/venv/Scripts/python.exe differ diff --git a/kelner/venv/Scripts/pythonw.exe b/kelner/venv/Scripts/pythonw.exe new file mode 100644 index 0000000..2d4ee10 Binary files /dev/null and b/kelner/venv/Scripts/pythonw.exe differ diff --git a/kelner/venv/pyvenv.cfg b/kelner/venv/pyvenv.cfg new file mode 100644 index 0000000..3003e2a --- /dev/null +++ b/kelner/venv/pyvenv.cfg @@ -0,0 +1,3 @@ +home = c:\software\python3 +include-system-site-packages = false +version = 3.7.3