diff --git a/PBMap.pb b/PBMap.pb new file mode 100644 index 0000000..0034046 --- /dev/null +++ b/PBMap.pb @@ -0,0 +1,1059 @@ +;************************************************************** +; Program: PBMap +; Description: Permits the use of tiled maps like +; OpenStreetMap in a handy PureBASIC module +; Author: Thyphoon And Djes +; Date: Mai 17, 2016 +; License: Free, unrestricted, credit appreciated +; but not required. +; Note: Please share improvement ! +; Thanks: Progi1984 +;************************************************************** + +CompilerIf #PB_Compiler_Thread = #False + MessageRequester("Warning !!","You must enable ThreadSafe support in compiler options",#PB_MessageRequester_Ok ) + End +CompilerEndIf + +EnableExplicit + +InitNetwork() +UsePNGImageDecoder() +UsePNGImageEncoder() + +DeclareModule PBMap + ;-Show debug infos + Global Verbose = #True + ;-Proxy ON/OFF + Global Proxy = #True + Declare InitPBMap() + Declare MapGadget(Gadget.i, X.i, Y.i, Width.i, Height.i) + Declare Event(Event.l) + Declare SetLocation(latitude.d, longitude.d, zoom = 15, mode.i = #PB_Absolute) + Declare DrawingThread(Null) + Declare SetZoom(Zoom.i, mode.i = #PB_Relative) + Declare ZoomToArea() + Declare SetCallBackLocation(*CallBackLocation) + Declare LoadGpxFile(file.s); + Declare AddMarker(Latitude.d,Longitude.d,color.l=-1, CallBackPointer.i = -1) + Declare Quit() + Declare Error(msg.s) + Declare Refresh() + Declare.d GetLatitude() + Declare.d GetLongitude() + Declare.i GetZoom() +EndDeclareModule + +Module PBMap + + EnableExplicit + + Structure Location + Longitude.d + Latitude.d + EndStructure + + Structure Position + x.d + y.d + EndStructure + + Structure PixelPosition + x.i + y.i + EndStructure + + ;- Tile Structure + Structure Tile + Position.Position + PBMapTileX.i + PBMapTileY.i + PBMapZoom.i + nImage.i + GetImageThread.i + EndStructure + + Structure DrawingParameters + Position.Position + Canvas.i + PBMapTileX.i + PBMapTileY.i + PBMapZoom.i + Mutex.i + TargetLocation.Location + CenterX.i + CenterY.i + DeltaX.i + DeltaY.i + Semaphore.i + Dirty.i + PassNB.i + End.i + EndStructure + + Structure TileThread + GetImageThread.i + *Tile.Tile + EndStructure + + Structure ImgMemCach + nImage.i + Usage.i + EndStructure + + Structure TileMemCach + Map Images.ImgMemCach() + EndStructure + + Structure Marker + Location.Location ; Marker latitude and longitude + color.l ; Marker color + CallBackPointer.i ; @Procedure(X.i, Y.i) to DrawPointer (you must use VectorDrawing lib) + EndStructure + + ;-PBMap Structure + Structure PBMap + Gadget.i ; Canvas Gadget Id + Font.i ; Font to uses when write on the map + TargetLocation.Location ; Latitude and Longitude from focus point + Drawing.DrawingParameters ; Drawing parameters based on focus point + ; + CallBackLocation.i ; @Procedure(latitude.d,lontitude.d) + ; + Position.PixelPosition ; Actual focus point coords in pixels (global) + MoveStartingPoint.PixelPosition ; Start mouse position coords when dragging the map + ; + ServerURL.s ; Web URL ex: http://tile.openstreetmap.org/ + ZoomMin.i ; Min Zoom supported by server + ZoomMax.i ; Max Zoom supported by server + Zoom.i ; Current zoom + TileSize.i ; Tile size downloaded on the server ex : 256 + ; + HDDCachePath.S ; Path where to load and save tiles downloaded from server + MemCache.TileMemCach ; Images in memory cache + ; + Moving.i + Dirty.i ; To signal that drawing need a refresh + ; + MainDrawingThread.i + List TilesThreads.TileThread() + ; + List track.Location() ; To display a GPX track + List Marker.Marker() ; To diplay marker + EditMarkerIndex.l + EndStructure + + Global PBMap.PBMap, Null.i + + ;Shows an error msg and terminates the program + Procedure Error(msg.s) + MessageRequester("MapGadget", msg, #PB_MessageRequester_Ok) + End + EndProcedure + + ;Send debug infos to stdout + Procedure MyDebug(msg.s) + If Verbose + PrintN(msg) + EndIf + EndProcedure + + ;- *** CURL specific *** + ; (program has To be compiled in console format for curl debug infos) + + IncludeFile "libcurl.pbi" ; https://github.com/deseven/pbsamples/tree/master/crossplatform/libcurl + + ;Curl write callback (needed for win32 dll) + ProcedureC ReceiveHTTPWriteToFileFunction(*ptr, Size.i, NMemB.i, FileHandle.i) + ProcedureReturn WriteData(FileHandle, *ptr, Size * NMemB) + EndProcedure + + Procedure.i CurlReceiveHTTPToFile(URL$, DestFileName$, ProxyURL$="", ProxyPort$="", ProxyUser$="", ProxyPassword$="") + Protected *Buffer, curl.i, Timeout.i, res.i + Protected FileHandle.i + MyDebug("ReceiveHTTPToFile from " + URL$ + " " + ProxyURL$ + ProxyPort$ + ProxyUser$) + MyDebug(" to file : " + DestFileName$) + FileHandle = CreateFile(#PB_Any, DestFileName$) + If FileHandle And Len(URL$) + curl = curl_easy_init() + If curl + Timeout = 120 + curl_easy_setopt(curl, #CURLOPT_URL, str2curl(URL$)) + curl_easy_setopt(curl, #CURLOPT_SSL_VERIFYPEER, 0) + curl_easy_setopt(curl, #CURLOPT_SSL_VERIFYHOST, 0) + curl_easy_setopt(curl, #CURLOPT_HEADER, 0) + curl_easy_setopt(curl, #CURLOPT_FOLLOWLOCATION, 1) + curl_easy_setopt(curl, #CURLOPT_TIMEOUT, Timeout) + curl_easy_setopt(curl, #CURLOPT_VERBOSE, 1) + ;curl_easy_setopt(curl, #CURLOPT_CONNECTTIMEOUT, 60) + If Len(ProxyURL$) + ;curl_easy_setopt(curl, #CURLOPT_HTTPPROXYTUNNEL, #True) + If Len(ProxyPort$) + ProxyURL$ + ":" + ProxyPort$ + EndIf + MyDebug( ProxyURL$) + curl_easy_setopt(curl, #CURLOPT_PROXY, str2curl(ProxyURL$)) + If Len(ProxyUser$) + If Len(ProxyPassword$) + ProxyUser$ + ":" + ProxyPassword$ + EndIf + MyDebug( ProxyUser$) + curl_easy_setopt(curl, #CURLOPT_PROXYUSERPWD, str2curl(ProxyUser$)) + EndIf + EndIf + curl_easy_setopt(curl, #CURLOPT_WRITEDATA, FileHandle) + curl_easy_setopt(curl, #CURLOPT_WRITEFUNCTION, @ReceiveHTTPWriteToFileFunction()) + res = curl_easy_perform(curl) + If res <> #CURLE_OK + MyDebug("CURL problem") + EndIf + curl_easy_cleanup(curl) + Else + MyDebug("Can't init CURL") + EndIf + CloseFile(FileHandle) + ProcedureReturn FileSize(DestFileName$) + EndIf + ProcedureReturn #False + EndProcedure + ;- *** + + Procedure InitPBMap() + Protected Result.i + If Verbose + OpenConsole() + EndIf + PBMap\HDDCachePath = GetTemporaryDirectory() + PBMap\ServerURL = "http://tile.openstreetmap.org/" + PBMap\ZoomMin = 0 + PBMap\ZoomMax = 18 + PBMap\MoveStartingPoint\x = - 1 + PBMap\TileSize = 256 + PBMap\Dirty = #False + PBMap\Drawing\Mutex = CreateMutex() + PBMap\Drawing\Semaphore = CreateSemaphore() + PBMap\EditMarkerIndex = -1 ;<- You must initialize with No Marker selected + PBMap\Font = LoadFont(#PB_Any, "Arial", 20, #PB_Font_Bold) + ;- Proxy details + ;Use this to create and customize your preferences file for the first time + ; Result = CreatePreferences(GetHomeDirectory() + "PBMap.prefs") + ; If Proxy + ; PreferenceGroup("PROXY") + ; WritePreferenceString("ProxyURL", "myproxy.fr") + ; WritePreferenceString("ProxyPort", "myproxyport") + ; WritePreferenceString("ProxyUser", "myproxyname") + ; EndIf + ; If Result + ; ClosePreferences() + ; EndIf + Result = OpenPreferences(GetHomeDirectory() + "PBMap.prefs") + If Proxy + PreferenceGroup("PROXY") + Global ProxyURL$ = ReadPreferenceString("ProxyURL", "") ;InputRequester("ProxyServer", "Do you use a Proxy Server? Then enter the full url:", "") + Global ProxyPort$ = ReadPreferenceString("ProxyPort", "") ;InputRequester("ProxyPort" , "Do you use a specific port? Then enter it", "") + Global ProxyUser$ = ReadPreferenceString("ProxyUser", "") ;InputRequester("ProxyUser" , "Do you use a user name? Then enter it", "") + Global ProxyPassword$ = InputRequester("ProxyPass", "Do you use a password ? Then enter it", "") + EndIf + If Result + ClosePreferences() + EndIf + curl_global_init(#CURL_GLOBAL_WIN32); + ;- Main drawing thread launching + PBMap\MainDrawingThread = CreateThread(@DrawingThread(), @PBMap\Drawing) + If PBMap\MainDrawingThread = 0 + Error("MapGadget : can't create main drawing thread.") + EndIf + EndProcedure + + Procedure Quit() + ;kill main drawing thread (nicer than KillThread(PBMap\MainDrawingThread)) + LockMutex(PBMap\Drawing\Mutex) + PBMap\Drawing\End = #True + UnlockMutex(PBMap\Drawing\Mutex) + ;wait for loading threads to finish nicely + ResetList(PBMap\TilesThreads()) + While NextElement(PBMap\TilesThreads()) + If IsThread(PBMap\TilesThreads()\GetImageThread) = 0 + FreeMemory(PBMap\TilesThreads()\Tile) + DeleteElement(PBMap\TilesThreads()) + ResetList( PBMap\TilesThreads()) + EndIf + Wend + curl_global_cleanup() + EndProcedure + + Macro Min(a,b) + (Bool((a) <= (b)) * (a) + Bool((b) < (a)) * (b)) + EndMacro + + Macro Max(a,b) + (Bool((a) >= (b)) * (a) + Bool((b) > (a)) * (b)) + EndMacro + + Procedure.d Distance(x1.d, y1.d, x2.d, y2.d) + Protected Result.d + Result = Sqr( (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)) + ProcedureReturn Result + EndProcedure + + Procedure MapGadget(Gadget.i, X.i, Y.i, Width.i, Height.i) + If Gadget = #PB_Any + PBMap\Gadget = CanvasGadget(PBMap\Gadget, X, Y, Width, Height) + Else + PBMap\Gadget = Gadget + CanvasGadget(PBMap\Gadget, X, Y, Width, Height) + EndIf + EndProcedure + + ;*** Converts coords to tile.decimal + ;Warning, structures used in parameters are not tested + Procedure LatLon2XY(*Location.Location, *Coords.Position) + Protected n.d = Pow(2.0, PBMap\Zoom) + Protected LatRad.d = Radian(*Location\Latitude) + *Coords\x = n * ( (*Location\Longitude + 180.0) / 360.0) + *Coords\y = n * ( 1.0 - Log(Tan(LatRad) + 1.0/Cos(LatRad)) / #PI ) / 2.0 + MyDebug("Latitude : " + StrD(*Location\Latitude) + " ; Longitude : " + StrD(*Location\Longitude)) + MyDebug("Coords X : " + Str(*Coords\x) + " ; Y : " + Str(*Coords\y)) + EndProcedure + + ;*** Converts tile.decimal to coords + ;Warning, structures used in parameters are not tested + Procedure XY2LatLon(*Coords.Position, *Location.Location) + Protected n.d = Pow(2.0, PBMap\Zoom) + Protected LatitudeRad.d + *Location\Longitude = *Coords\x / n * 360.0 - 180.0 + LatitudeRad = ATan(SinH(#PI * (1.0 - 2.0 * *Coords\y / n))) + *Location\Latitude = Degree(LatitudeRad) + EndProcedure + + ; HaversineAlgorithm + ; http://andrew.hedges.name/experiments/haversine/ + Procedure.d HaversineInKM(*posA.Location, *posB.Location) + Protected eQuatorialEarthRadius.d = 6378.1370;6372.795477598; + Protected dlong.d = (*posB\Longitude - *posA\Longitude); + Protected dlat.d = (*posB\Latitude - *posA\Latitude) ; + Protected alpha.d=dlat/2 + Protected beta.d=dlong/2 + Protected a.d = Sin(Radian(alpha)) * Sin(Radian(alpha)) + Cos(Radian(*posA\Latitude)) * Cos(Radian(*posB\Latitude)) * Sin(Radian(beta)) * Sin(Radian(beta)) + Protected c.d = ASin(Min(1,Sqr(a))); + Protected distance.d = 2*eQuatorialEarthRadius * c + ProcedureReturn distance ; + EndProcedure + + Procedure.d HaversineInM(*posA.Location, *posB.Location) + ProcedureReturn (1000 * HaversineInKM(@*posA,@*posB)); + EndProcedure + + Procedure GetPixelCoordFromLocation(*Location.Location, *Pixel.PixelPosition) ; TODO to Optimize + Protected mapWidth.l = Pow(2, PBMap\Zoom + 8) + Protected mapHeight.l = Pow(2, PBMap\Zoom + 8) + Protected x1.l,y1.l + ; get x value + x1 = (*Location\Longitude+180)*(mapWidth/360) + ; convert from degrees To radians + Protected latRad.d = *Location\Latitude*#PI/180; + Protected mercN.d = Log(Tan((#PI/4)+(latRad/2))); + y1 = (mapHeight/2)-(mapWidth*mercN/(2*#PI)) ; + Protected x2.l, y2.l + ; get x value + x2 = (PBMap\TargetLocation\Longitude+180)*(mapWidth/360) + ; convert from degrees To radians + latRad = PBMap\TargetLocation\Latitude*#PI/180; + ; get y value + mercN = Log(Tan((#PI/4)+(latRad/2))) + y2 = (mapHeight/2)-(mapWidth*mercN/(2*#PI)); + *Pixel\x=GadgetWidth(PBMap\Gadget)/2 - (x2-x1) + *Pixel\y=GadgetHeight(PBMap\Gadget)/2 - (y2-y1) + EndProcedure + + Procedure LoadGpxFile(file.s) + If LoadXML(0, file.s) + Protected Message.s + If XMLStatus(0) <> #PB_XML_Success + Message = "Error in the XML file:" + Chr(13) + Message + "Message: " + XMLError(0) + Chr(13) + Message + "Line: " + Str(XMLErrorLine(0)) + " Character: " + Str(XMLErrorPosition(0)) + MessageRequester("Error", Message) + EndIf + Protected *MainNode,*subNode,*child,child.l + *MainNode=MainXMLNode(0) + *MainNode=XMLNodeFromPath(*MainNode,"/gpx/trk/trkseg") + ClearList(PBMap\track()) + For child = 1 To XMLChildCount(*MainNode) + *child = ChildXMLNode(*MainNode, child) + AddElement(PBMap\track()) + If ExamineXMLAttributes(*child) + While NextXMLAttribute(*child) + Select XMLAttributeName(*child) + Case "lat" + PBMap\track()\Latitude=ValD(XMLAttributeValue(*child)) + Case "lon" + PBMap\track()\Longitude=ValD(XMLAttributeValue(*child)) + EndSelect + Wend + EndIf + Next + EndIf + EndProcedure + + Procedure.i GetTileFromMem(Zoom.i, XTile.i, YTile.i) + Protected key.s = "Z" + RSet(Str(Zoom), 4, "0") + "X" + RSet(Str(XTile), 8, "0") + "Y" + RSet(Str(YTile), 8, "0") + MyDebug("Check if we have this image in memory") + If FindMapElement(PBMap\MemCache\Images(), key) + MyDebug("Key : " + key + " found !") + ProcedureReturn PBMap\MemCache\Images()\nImage + Else + MyDebug("Key : " + key + " not found !") + ProcedureReturn -1 + EndIf + EndProcedure + + Procedure.i GetTileFromHDD(CacheFile.s) + Protected nImage.i + If FileSize(CacheFile) > 0 + nImage = LoadImage(#PB_Any, CacheFile) + If IsImage(nImage) + MyDebug("Loadimage " + CacheFile + " -> Success !") + ProcedureReturn nImage + EndIf + EndIf + MyDebug("Loadimage " + CacheFile + " -> Failed !") + ProcedureReturn -1 + EndProcedure + + Procedure.i GetTileFromWeb(Zoom.i, XTile.i, YTile.i, CacheFile.s) + Protected *Buffer + Protected nImage.i = -1 + Protected FileHandle.i + Protected TileURL.s = PBMap\ServerURL + Str(Zoom) + "/" + Str(XTile) + "/" + Str(YTile) + ".png" + MyDebug("Check if we have this image on Web") + If Proxy + FileHandle = CurlReceiveHTTPToFile(TileURL, CacheFile, ProxyURL$, ProxyPort$, ProxyUser$, ProxyPassword$) + If FileHandle + nImage = GetTileFromHDD(CacheFile) + Else + MyDebug("File " + TileURL + " not correctly received with Curl and proxy") + EndIf + Else + *Buffer = ReceiveHTTPMemory(TileURL) ;TODO to thread by using #PB_HTTP_Asynchronous + If *Buffer + nImage = CatchImage(#PB_Any, *Buffer, MemorySize(*Buffer)) + If IsImage(nImage) + MyDebug("Load from web " + TileURL + " as Tile nb " + nImage) + SaveImage(nImage, CacheFile, #PB_ImagePlugin_PNG) + FreeMemory(*Buffer) + Else + MyDebug("Can't catch image " + TileURL) + nImage = -1 + ;ShowMemoryViewer(*Buffer, MemorySize(*Buffer)) + EndIf + Else + MyDebug("ReceiveHTTPMemory's buffer is empty") + EndIf + EndIf + ProcedureReturn nImage + EndProcedure + + Procedure GetImageThread(*Tile.Tile) + Protected nImage.i = -1 + Protected key.s = "Z" + RSet(Str(*Tile\PBMapZoom), 4, "0") + "X" + RSet(Str(*Tile\PBMapTileX), 8, "0") + "Y" + RSet(Str(*Tile\PBMapTileY), 8, "0") + Protected CacheFile.s = PBMap\HDDCachePath + "PBMap_" + Str(*Tile\PBMapZoom) + "_" + Str(*Tile\PBMapTileX) + "_" + Str(*Tile\PBMapTileY) + ".png" + ;Adding the image to the cache if possible + AddMapElement(PBMap\MemCache\Images(), key) + nImage = GetTileFromHDD(CacheFile) + If nImage = -1 + nImage = GetTileFromWeb(*Tile\PBMapZoom, *Tile\PBMapTileX, *Tile\PBMapTileY, CacheFile) + EndIf + If nImage <> -1 + PBMap\MemCache\Images(key)\nImage = nImage + MyDebug("Image nb " + Str(nImage) + " successfully added to mem cache") + MyDebug("With the following key : " + key) + Else + MyDebug("Error GetImageThread procedure, image not loaded - " + key) + nImage = -1 + EndIf + ;Define this tile image nb + *Tile\nImage = nImage + EndProcedure + + Procedure DrawTile(*Tile.Tile) + Protected x = *Tile\Position\x + Protected y = *Tile\Position\y + MyDebug(" Drawing tile nb " + " X : " + Str(*Tile\PBMapTileX) + " Y : " + Str(*Tile\PBMapTileX)) + MyDebug(" at coords " + Str(x) + "," + Str(y)) + MovePathCursor(x, y) + DrawVectorImage(ImageID(*Tile\nImage)) + EndProcedure + + Procedure DrawLoading(*Tile.Tile) + Protected x = *Tile\Position\x + Protected y = *Tile\Position\y + Protected Text$ = "Loading" + MyDebug(" Drawing tile nb " + " X : " + Str(*Tile\PBMapTileX) + " Y : " + Str(*Tile\PBMapTileX)) + MyDebug(" at coords " + Str(x) + "," + Str(y)) + BeginVectorLayer() + ;MovePathCursor(x, y) + VectorSourceColor(RGBA(255, 255, 255, 128)) + AddPathBox(x, y, PBMap\TileSize, PBMap\TileSize) + FillPath() + MovePathCursor(x, y) + VectorFont(FontID(PBMap\Font), PBMap\TileSize / 20) + VectorSourceColor(RGBA(150, 150, 150, 255)) + MovePathCursor(x + (PBMap\TileSize - VectorTextWidth(Text$)) / 2, y + (PBMap\TileSize - VectorTextHeight(Text$)) / 2) + DrawVectorText(Text$) + EndVectorLayer() + EndProcedure + + Procedure DrawTiles(*Drawing.DrawingParameters) + Protected x.i, y.i + Protected tx = Int(*Drawing\Position\x) ;Don't forget the Int() ! + Protected ty = Int(*Drawing\Position\y) + Protected nx = *Drawing\CenterX / PBMap\TileSize ;How many tiles around the point + Protected ny = *Drawing\CenterY / PBMap\TileSize + MyDebug("Drawing tiles") + For y = - ny - 1 To ny + 1 + For x = - nx - 1 To nx + 1 + ;Was quiting the loop if a move occured, giving maybe smoother movement + ;If PBMap\Moving + ; Break 2 + ;EndIf + Protected *NewTile.Tile = AllocateMemory(SizeOf(Tile)) + If *NewTile + With *NewTile + ;Keep a track of tiles (especially to free memory) + AddElement(PBMap\TilesThreads()) + PBMap\TilesThreads()\Tile = *NewTile + ;New tile parameters + \Position\x = *Drawing\CenterX + x * PBMap\TileSize - *Drawing\DeltaX + \Position\y = *Drawing\CenterY + y * PBMap\TileSize - *Drawing\DeltaY + \PBMapTileX = tx + x + \PBMapTileY = ty + y + \PBMapZoom = PBMap\Zoom + ;Check if the image exists + \nImage = GetTileFromMem(\PBMapZoom, \PBMapTileX, \PBMapTileY) + If \nImage = -1 + ;If not, load it in the background + \GetImageThread = CreateThread(@GetImageThread(), *NewTile) + PBMap\TilesThreads()\GetImageThread = \GetImageThread + MyDebug(" Creating get image thread nb " + Str(\GetImageThread)) + EndIf + If IsImage(\nImage) + DrawTile(*NewTile) + Else + MyDebug("Image missing") + DrawLoading(*NewTile) + *Drawing\Dirty = #True ;Signals that this image is missing so we should have to redraw + EndIf + EndWith + Else + MyDebug(" Error, can't create a new tile") + Break 2 + EndIf + Next + Next + ;Free tile memory when the loading thread has finished + ;TODO : get out this proc from drawtiles in a special "free ressources" task + ForEach PBMap\TilesThreads() + If IsThread(PBMap\TilesThreads()\GetImageThread) = 0 + FreeMemory(PBMap\TilesThreads()\Tile) + DeleteElement(PBMap\TilesThreads()) + EndIf + Next + EndProcedure + + Procedure Pointer(x.i, y.i, color.l = #Red) + color=RGBA(255, 0, 0, 255) + VectorSourceColor(color) + MovePathCursor(x, y) + AddPathLine(-8,-16,#PB_Path_Relative) + AddPathCircle(8,0,8,180,0,#PB_Path_Relative) + AddPathLine(-8,16,#PB_Path_Relative) + ;FillPath(#PB_Path_Preserve) + ;ClipPath(#PB_Path_Preserve) + AddPathCircle(0,-16,5,0,360,#PB_Path_Relative) + VectorSourceColor(color) + FillPath(#PB_Path_Preserve):VectorSourceColor(RGBA(0, 0, 0, 255)):StrokePath(1) + EndProcedure + + Procedure TrackPointer(x.i, y.i,dist.l) + Protected color.l + color=RGBA(0, 0, 0, 255) + MovePathCursor(x,y) + AddPathLine(-8,-16,#PB_Path_Relative) + AddPathLine(16,0,#PB_Path_Relative) + AddPathLine(-8,16,#PB_Path_Relative) + VectorSourceColor(color) + AddPathCircle(x,y-20,14) + FillPath() + VectorSourceColor(RGBA(255, 255, 255, 255)) + AddPathCircle(x,y-20,12) + FillPath() + VectorFont(FontID(PBMap\Font), 13) + MovePathCursor(x-VectorTextWidth(Str(dist))/2, y-20-VectorTextHeight(Str(dist))/2) + VectorSourceColor(RGBA(0, 0, 0, 255)) + DrawVectorText(Str(dist)) + EndProcedure + + Procedure DrawTrack(*Drawing.DrawingParameters) + Protected Pixel.PixelPosition + Protected Location.Location + Protected km.f, memKm.i + If ListSize(PBMap\track())>0 + ;Trace Track + LockMutex(PBMap\Drawing\Mutex) + ForEach PBMap\track() + If *Drawing\TargetLocation\Latitude<>0 And *Drawing\TargetLocation\Longitude<>0 + GetPixelCoordFromLocation(@PBMap\track(),@Pixel) + If ListIndex(PBMap\track())=0 + MovePathCursor(Pixel\X, Pixel\Y) + Else + AddPathLine(Pixel\X, Pixel\Y) + EndIf + EndIf + Next + VectorSourceColor(RGBA(0, 255, 0, 150)) + StrokePath(10, #PB_Path_RoundEnd|#PB_Path_RoundCorner) + ;Draw Distance + ForEach PBMap\track() + ;-Test Distance + If ListIndex(PBMap\track())=0 + Location\Latitude=PBMap\track()\Latitude + Location\Longitude=PBMap\track()\Longitude + Else + km=km+HaversineInKM(@Location,@PBMap\track()) ;<- display Distance + Location\Latitude=PBMap\track()\Latitude + Location\Longitude=PBMap\track()\Longitude + EndIf + GetPixelCoordFromLocation(@PBMap\track(),@Pixel) + If Int(km)<>memKm + memKm=Int(km) + If PBMap\Zoom>10 + BeginVectorLayer() + TrackPointer(Pixel\X , Pixel\Y,Int(km)) + EndVectorLayer() + EndIf + EndIf + Next + UnlockMutex(PBMap\Drawing\Mutex) + EndIf + EndProcedure + + ; Add a Marker To the Map + Procedure AddMarker(Latitude.d,Longitude.d,color.l=-1, CallBackPointer.i = -1) + AddElement(PBMap\Marker()) + PBMap\Marker()\Location\Latitude=Latitude + PBMap\Marker()\Location\Longitude=Longitude + PBMap\Marker()\color=color + PBMap\Marker()\CallBackPointer = CallBackPointer + EndProcedure + + ; Draw all markers on the screen ! + Procedure DrawMarker(*Drawing.DrawingParameters) + Protected Pixel.PixelPosition + ForEach PBMap\Marker() + If PBMap\Marker()\Location\Latitude <> 0 And PBMap\Marker()\Location\Longitude <> 0 + GetPixelCoordFromLocation(PBMap\Marker()\Location, @Pixel) + If Pixel\X >= 0 And Pixel\Y >= 0 And Pixel\X < GadgetWidth(PBMap\Gadget) And Pixel\Y < GadgetHeight(PBMap\Gadget) ; Only if visible ^_^ + If PBMap\Marker()\CallBackPointer > 0 + CallFunctionFast(PBMap\Marker()\CallBackPointer, Pixel\X, Pixel\Y) + Else + Pointer(Pixel\X, Pixel\Y, PBMap\Marker()\color) + EndIf + EndIf + EndIf + Next + EndProcedure + + ;-*** Main drawing thread + ; always running, waiting for a semaphore to start refreshing + Procedure DrawingThread(*SharedDrawing.DrawingParameters) + Protected Drawing.DrawingParameters + Protected Px.d, Py.d + Repeat + WaitSemaphore(*SharedDrawing\Semaphore) + MyDebug("--------- Main drawing thread ------------") + ;Creates a copy of the structure to work with to avoid multiple mutex locks + LockMutex(*SharedDrawing\Mutex) + CopyStructure(*SharedDrawing, @Drawing, DrawingParameters) + UnlockMutex(*SharedDrawing\Mutex) + ;Precalc some values + Drawing\CenterX = GadgetWidth(PBMap\Gadget) / 2 + Drawing\CenterY = GadgetHeight(PBMap\Gadget) / 2 + ;Pixel shift, aka position in the tile + Px = Drawing\Position\x : Py = Drawing\Position\y + Drawing\DeltaX = Px * PBMap\TileSize - (Int(Px) * PBMap\TileSize) ;Don't forget the Int() ! + Drawing\DeltaY = Py * PBMap\TileSize - (Int(Py) * PBMap\TileSize) + Drawing\TargetLocation\Latitude = PBMap\TargetLocation\Latitude + Drawing\TargetLocation\Longitude = PBMap\TargetLocation\Longitude + Drawing\Dirty = #False + ;Main drawing stuff + StartVectorDrawing(CanvasVectorOutput(PBMap\Gadget)) + DrawTiles(@Drawing) + DrawTrack(@Drawing) + DrawMarker(@Drawing) + Pointer(Drawing\CenterX, Drawing\CenterY, #Red) + StopVectorDrawing() + ;Redraw + ; If something was not correctly drawn, redraw after a while + LockMutex(*SharedDrawing\Mutex) ;Be sure that we're not modifying variables while moving (seems not useful, but it is, especially to clean the semaphore) + If Drawing\Dirty + MyDebug("Something was dirty ! We try again to redraw") + Drawing\PassNb + 1 + SignalSemaphore(*SharedDrawing\Semaphore) + Else + ;Clean the semaphore to avoid multiple unuseful redraws + Repeat : Until TrySemaphore(*SharedDrawing\Semaphore) = 0 + EndIf + UnlockMutex(*SharedDrawing\Mutex) + Until Drawing\End + EndProcedure + + Procedure Refresh() + SignalSemaphore(PBMap\Drawing\Semaphore) + EndProcedure + + Procedure SetLocation(latitude.d, longitude.d, zoom = 15, Mode.i = #PB_Absolute) + Select Mode + Case #PB_Absolute + PBMap\TargetLocation\Latitude = latitude + PBMap\TargetLocation\Longitude = longitude + PBMap\Zoom = zoom + Case #PB_Relative + PBMap\TargetLocation\Latitude + latitude + PBMap\TargetLocation\Longitude + longitude + PBMap\Zoom + zoom + EndSelect + If PBMap\Zoom > PBMap\ZoomMax : PBMap\Zoom = PBMap\ZoomMax : EndIf + If PBMap\Zoom < PBMap\ZoomMin : PBMap\Zoom = PBMap\ZoomMin : EndIf + LatLon2XY(@PBMap\TargetLocation, @PBMap\Drawing) + ;Convert X, Y in tile.decimal into real pixels + PBMap\Position\x = PBMap\Drawing\Position\x * PBMap\TileSize + PBMap\Position\y = PBMap\Drawing\Position\y * PBMap\TileSize + PBMap\Drawing\PassNb = 1 + ;Start drawing + SignalSemaphore(PBMap\Drawing\Semaphore) + ;*** + If PBMap\CallBackLocation > 0 + CallFunctionFast(PBMap\CallBackLocation, @PBMap\TargetLocation) + EndIf + EndProcedure + + Procedure ZoomToArea() + ;Source => http://gis.stackexchange.com/questions/19632/how-to-calculate-the-optimal-zoom-level-to-display-two-or-more-points-on-a-map + ;bounding box in long/lat coords (x=long, y=lat) + Protected MinY.d,MaxY.d,MinX.d,MaxX.d + ForEach PBMap\track() + If ListIndex(PBMap\track())=0 Or PBMap\track()\LongitudeMaxX + MaxX=PBMap\track()\Longitude + EndIf + If ListIndex(PBMap\track())=0 Or PBMap\track()\LatitudeMaxY + MaxY=PBMap\track()\Latitude + EndIf + Next + Protected DeltaX.d=MaxX-MinX ;assumption ! In original code DeltaX have no source + Protected centerX.d=MinX+DeltaX/2 ; assumption ! In original code CenterX have no source + Protected paddingFactor.f= 1.2 ;paddingFactor: this can be used to get the "120%" effect ThomM refers to. Value of 1.2 would get you the 120%. + Protected ry1.d = Log((Sin(Radian(MinY)) + 1) / Cos(Radian(MinY))) + Protected ry2.d = Log((Sin(Radian(MaxY)) + 1) / Cos(Radian(MaxY))) + Protected ryc.d = (ry1 + ry2) / 2 + Protected centerY.d = Degree(ATan(SinH(ryc))) + Protected resolutionHorizontal.d = DeltaX / GadgetWidth(PBMap\Gadget) + Protected vy0.d = Log(Tan(#PI*(0.25 + centerY/360))); + Protected vy1.d = Log(Tan(#PI*(0.25 + MaxY/360))) ; + Protected viewHeightHalf.d = GadgetHeight(PBMap\Gadget)/2; + Protected zoomFactorPowered.d = viewHeightHalf / (40.7436654315252*(vy1 - vy0)) + Protected resolutionVertical.d = 360.0 / (zoomFactorPowered * PBMap\TileSize) + If resolutionHorizontal<>0 And resolutionVertical<>0 + Protected resolution.d = Max(resolutionHorizontal, resolutionVertical)* paddingFactor + Protected zoom.d = Log(360 / (resolution * PBMap\TileSize))/Log(2) + Protected lon.d = centerX; + Protected lat.d = centerY; + SetLocation(lat,lon, Round(zoom,#PB_Round_Down)) + Else + SetLocation(PBMap\TargetLocation\Latitude,PBMap\TargetLocation\Longitude, 15) + EndIf + EndProcedure + + Procedure SetZoom(Zoom.i, mode.i = #PB_Relative) + Select mode + Case #PB_Relative + PBMap\Zoom = PBMap\Zoom + zoom + Case #PB_Absolute + PBMap\Zoom = zoom + EndSelect + If PBMap\Zoom > PBMap\ZoomMax : PBMap\Zoom = PBMap\ZoomMax : EndIf + If PBMap\Zoom < PBMap\ZoomMin : PBMap\Zoom = PBMap\ZoomMin : EndIf + LatLon2XY(@PBMap\TargetLocation, @PBMap\Drawing) + ;Convert X, Y in tile.decimal into real pixels + PBMap\Position\X = PBMap\Drawing\Position\x * PBMap\TileSize + PBMap\Position\Y = PBMap\Drawing\Position\y * PBMap\TileSize + ;*** Creates a drawing thread and fill parameters + PBMap\Drawing\PassNb = 1 + ;Start drawing + SignalSemaphore(PBMap\Drawing\Semaphore) + ;*** + If PBMap\CallBackLocation > 0 + CallFunctionFast(PBMap\CallBackLocation, @PBMap\TargetLocation) + EndIf + EndProcedure + + Procedure SetCallBackLocation(CallBackLocation.i) + PBMap\CallBackLocation = CallBackLocation + EndProcedure + + Procedure.d GetLatitude() + Protected Value.d + LockMutex(PBMap\Drawing\Mutex) + Value = PBMap\TargetLocation\Latitude + UnlockMutex(PBMap\Drawing\Mutex) + ProcedureReturn Value + EndProcedure + + Procedure.d GetLongitude() + Protected Value.d + LockMutex(PBMap\Drawing\Mutex) + Value = PBMap\TargetLocation\Longitude + UnlockMutex(PBMap\Drawing\Mutex) + ProcedureReturn Value + EndProcedure + + Procedure.i GetZoom() + Protected Value.d + LockMutex(PBMap\Drawing\Mutex) + Value = PBMap\Zoom + UnlockMutex(PBMap\Drawing\Mutex) + ProcedureReturn Value + EndProcedure + + Procedure Event(Event.l) + Protected Gadget.i + Protected MouseX.i, MouseY.i + Protected Marker.Position + Protected *Drawing.DrawingParameters + If IsGadget(PBMap\Gadget) And GadgetType(PBMap\Gadget) = #PB_GadgetType_Canvas + Select Event + Case #PB_Event_Gadget ;{ + Gadget = EventGadget() + Select Gadget + Case PBMap\Gadget + Select EventType() + Case #PB_EventType_LeftButtonDown + ;Check if we select a marker + MouseX = PBMap\Position\x - GadgetWidth(PBMap\Gadget) / 2 + GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseX) + MouseY = PBMap\Position\y - GadgetHeight(PBMap\Gadget) / 2 + GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseY) + ForEach PBMap\Marker() + LatLon2XY(@PBMap\Marker()\Location, @Marker) + Marker\x * PBMap\TileSize + Marker\y * PBMap\TileSize + If Distance(Marker\x, Marker\y, MouseX, MouseY) < 8 + PBMap\EditMarkerIndex = ListIndex(PBMap\Marker()) + Break + EndIf + Next + ;Mem cursor Coord + PBMap\MoveStartingPoint\x = GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseX) + PBMap\MoveStartingPoint\y = GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseY) + Case #PB_EventType_MouseMove + If PBMap\MoveStartingPoint\x <> - 1 + MouseX = GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseX) - PBMap\MoveStartingPoint\x + MouseY = GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseY) - PBMap\MoveStartingPoint\y + PBMap\Moving = #True + ;move Marker + If PBMap\EditMarkerIndex > -1 + SelectElement(PBMap\Marker(), PBMap\EditMarkerIndex) + LatLon2XY(@PBMap\Marker()\Location, @Marker) + Marker\x + MouseX / PBMap\TileSize + Marker\y + MouseY / PBMap\TileSize + XY2LatLon(@Marker, @PBMap\Marker()\Location) + Else + ;New move values + PBMap\Position\x - MouseX + PBMap\Position\y - MouseY + ;-*** Fill parameters and signal the drawing thread + LockMutex(PBMap\Drawing\Mutex) + ;PBMap tile position in tile.decimal + PBMap\Drawing\Position\x = PBMap\Position\x / PBMap\TileSize + PBMap\Drawing\Position\y = PBMap\Position\y / PBMap\TileSize + PBMap\Drawing\PassNb = 1 + XY2LatLon(@PBMap\Drawing, @PBMap\TargetLocation) + ;If CallBackLocation send Location to function + If PBMap\CallBackLocation > 0 + CallFunctionFast(PBMap\CallBackLocation, @PBMap\TargetLocation) + EndIf + UnlockMutex(PBMap\Drawing\Mutex) + EndIf + ;Start drawing + SignalSemaphore(PBMap\Drawing\Semaphore) + ;- *** + PBMap\MoveStartingPoint\x = GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseX) + PBMap\MoveStartingPoint\y = GetGadgetAttribute(PBMap\Gadget, #PB_Canvas_MouseY) + EndIf + Case #PB_EventType_LeftButtonUp + PBMap\Moving = #False + PBMap\MoveStartingPoint\x = - 1 + If PBMap\EditMarkerIndex > -1 + PBMap\EditMarkerIndex = -1 + Else ;Move Map + LockMutex(PBMap\Drawing\Mutex) + PBMap\Drawing\Position\x = PBMap\Position\x / PBMap\TileSize + PBMap\Drawing\Position\y = PBMap\Position\y / PBMap\TileSize + MyDebug("PBMap\Drawing\Position\x " + Str(PBMap\Drawing\Position\x) + " ; PBMap\Drawing\Position\y " + Str(PBMap\Drawing\Position\y) ) + XY2LatLon(@PBMap\Drawing, @PBMap\TargetLocation) + UnlockMutex(PBMap\Drawing\Mutex) + EndIf + EndSelect + EndSelect + EndSelect + Else + MessageRequester("Module PBMap", "You must use PBMapGadget before", #PB_MessageRequester_Ok ) + End + EndIf + + EndProcedure +EndModule + +;-Exemple +CompilerIf #PB_Compiler_IsMainFile + InitNetwork() + + Enumeration + #Window_0 + #Map + #Gdt_Left + #Gdt_Right + #Gdt_Up + #Gdt_Down + #Button_4 + #Button_5 + #Combo_0 + #Text_0 + #Text_1 + #Text_2 + #Text_3 + #Text_4 + #String_0 + #String_1 + #Gdt_LoadGpx + #Gdt_AddMarker + EndEnumeration + + Structure Location + Longitude.d + Latitude.d + EndStructure + + Procedure UpdateLocation(*Location.Location) + SetGadgetText(#String_0, StrD(*Location\Latitude)) + SetGadgetText(#String_1, StrD(*Location\Longitude)) + ProcedureReturn 0 + EndProcedure + + Procedure MyPointer(x.i, y.i) + Protected color.l + color=RGBA(0, 255, 0, 255) + VectorSourceColor(color) + MovePathCursor(x, y) + AddPathLine(-16,-32,#PB_Path_Relative) + AddPathCircle(16,0,16,180,0,#PB_Path_Relative) + AddPathLine(-16,32,#PB_Path_Relative) + VectorSourceColor(color) + FillPath(#PB_Path_Preserve):VectorSourceColor(RGBA(0, 0, 0, 255)):StrokePath(1) + EndProcedure + + Procedure ResizeAll() + ResizeGadget(#Map,10,10,WindowWidth(#Window_0)-198,WindowHeight(#Window_0)-59) + ResizeGadget(#Text_1,WindowWidth(#Window_0)-170,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Gdt_Left, WindowWidth(#Window_0) - 150 ,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Gdt_Right,WindowWidth(#Window_0) - 90 ,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Gdt_Up, WindowWidth(#Window_0) - 120 ,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Gdt_Down, WindowWidth(#Window_0) - 120 ,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Text_2,WindowWidth(#Window_0)-170,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Button_4,WindowWidth(#Window_0)-150,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Button_5,WindowWidth(#Window_0)-100,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Text_3,WindowWidth(#Window_0)-170,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#String_0,WindowWidth(#Window_0)-100,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#String_1,WindowWidth(#Window_0)-100,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Text_4,WindowWidth(#Window_0)-170,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Gdt_AddMarker,WindowWidth(#Window_0)-170,#PB_Ignore,#PB_Ignore,#PB_Ignore) + ResizeGadget(#Gdt_LoadGpx,WindowWidth(#Window_0)-170,#PB_Ignore,#PB_Ignore,#PB_Ignore) + PBMap::Refresh() + EndProcedure + + ;- MAIN TEST + If OpenWindow(#Window_0, 260, 225, 700, 571, "OpenStreetMap", #PB_Window_SystemMenu | #PB_Window_MinimizeGadget | #PB_Window_TitleBar | #PB_Window_ScreenCentered | #PB_Window_SizeGadget) + + LoadFont(0, "Wingdings", 12) + LoadFont(1, "Arial", 12, #PB_Font_Bold) + + TextGadget(#Text_1, 530, 50, 60, 15, "Movements") + ButtonGadget(#Gdt_Left, 550, 100, 30, 30, Chr($E7)) : SetGadgetFont(#Gdt_Left, FontID(0)) + ButtonGadget(#Gdt_Right, 610, 100, 30, 30, Chr($E8)) : SetGadgetFont(#Gdt_Right, FontID(0)) + ButtonGadget(#Gdt_Up, 580, 070, 30, 30, Chr($E9)) : SetGadgetFont(#Gdt_Up, FontID(0)) + ButtonGadget(#Gdt_Down, 580, 130, 30, 30, Chr($EA)) : SetGadgetFont(#Gdt_Down, FontID(0)) + TextGadget(#Text_2, 530, 160, 60, 15, "Zoom") + ButtonGadget(#Button_4, 550, 180, 50, 30, " + ") : SetGadgetFont(#Button_4, FontID(1)) + ButtonGadget(#Button_5, 600, 180, 50, 30, " - ") : SetGadgetFont(#Button_5, FontID(1)) + TextGadget(#Text_3, 530, 230, 60, 15, "Latitude : ") + StringGadget(#String_0, 600, 230, 90, 20, "") + TextGadget(#Text_4, 530, 250, 60, 15, "Longitude : ") + StringGadget(#String_1, 600, 250, 90, 20, "") + ButtonGadget(#Gdt_AddMarker, 530, 280, 150, 30, "Add Marker") + ButtonGadget(#Gdt_LoadGpx, 530, 310, 150, 30, "Load GPX") + + Define Event.i, Gadget.i, Quit.b = #False + Define pfValue.d + + ;Our main gadget + PBMap::InitPBMap() + PBMap::MapGadget(#Map, 10, 10, 512, 512) + PBMap::SetCallBackLocation(@UpdateLocation()) + PBMap::SetLocation(49.04599, 2.03347, 17) + PBMap::AddMarker(49.0446828398, 2.0349812508, -1, @MyPointer()) + + Repeat + Event = WaitWindowEvent() + PBMap::Event(Event) + Select Event + Case #PB_Event_CloseWindow : Quit = 1 + Case #PB_Event_Gadget ;{ + Gadget = EventGadget() + Select Gadget + Case #Gdt_Up + PBMap::SetLocation(10* 360 / Pow(2, PBMap::GetZoom() + 8), 0, 0, #PB_Relative) + Case #Gdt_Down + PBMap::SetLocation(10* -360 / Pow(2, PBMap::GetZoom() + 8), 0, 0, #PB_Relative) + Case #Gdt_Left + PBMap::SetLocation(0, 10* -360 / Pow(2, PBMap::GetZoom() + 8), 0, #PB_Relative) + Case #Gdt_Right + PBMap::SetLocation(0, 10* 360 / Pow(2, PBMap::GetZoom() + 8), 0, #PB_Relative) + Case #Button_4 + PBMap::SetZoom(1) + Case #Button_5 + PBMap::SetZoom( - 1) + Case #Gdt_LoadGpx + PBMap::LoadGpxFile(OpenFileRequester("Choisissez un fichier à charger", "", "*.gpx", 0)) + PBMap::ZoomToArea() ; <-To center the view, and to viex all the track + Case #Gdt_AddMarker + PBMap:: AddMarker(ValD(GetGadgetText(#String_0)),ValD(GetGadgetText(#String_1)),RGBA(Random(255),Random(255),Random(255),255)) + EndSelect + Case #PB_Event_SizeWindow + ResizeAll() + EndSelect + Until Quit = #True + + PBMap::Quit() + EndIf +CompilerEndIf + +; IDE Options = PureBasic 5.42 LTS (Windows - x86) +; CursorPosition = 8 +; Folding = -------- +; EnableUnicode +; EnableThread +; EnableXP \ No newline at end of file diff --git a/README.md b/README.md index 6903d11..4070e5b 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,3 @@ -# PBOpenMap +# PBMap Purebasic opensource tiled map software Created to develop and test our tiles applications for PureBasic diff --git a/Roller.gpx b/Roller.gpx new file mode 100644 index 0000000..d286dad --- /dev/null +++ b/Roller.gpx @@ -0,0 +1,9706 @@ + + + + Haaaaaaaa une bonne grosse montée après une petite pluie puis le reste de la rando sous une bonne pluie. Mais tip top! + + 2016 + http://www.runtastic.com + + + runtastic + + + + + + Cliquez sur ce lien pour voir cette activité sur Runtastic.com + + + + 91.0 + + + + 91.0 + + + + 89.0 + + + + 88.0 + + + + 88.0 + + + + 86.0 + + + + 86.0 + + + + 86.0 + + + + 87.0 + + + + 88.0 + + + + 88.0 + + + + 88.0 + + + + 86.0 + + + + 86.0 + + + + 87.0 + + + + 87.0 + + + + 85.0 + + + + 85.0 + + + + 84.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 87.0 + + + + 85.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 81.0 + + + + 82.0 + + + + 83.0 + + + + 85.0 + + + + 85.0 + + + + 86.0 + + + + 86.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 86.0 + + + + 84.0 + + + + 85.0 + + + + 86.0 + + + + 85.0 + + + + 85.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 81.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 83.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 82.0 + + + + 83.0 + + + + 82.0 + + + + 83.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 80.0 + + + + 78.0 + + + + 78.0 + + + + 79.0 + + + + 78.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 78.0 + + + + 77.0 + + + + 77.0 + + + + 79.0 + + + + 78.0 + + + + 78.0 + + + + 78.0 + + + + 79.0 + + + + 80.0 + + + + 79.0 + + + + 80.0 + + + + 80.0 + + + + 79.0 + + + + 80.0 + + + + 79.0 + + + + 78.0 + + + + 77.0 + + + + 78.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 80.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 80.0 + + + + 80.0 + + + + 81.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 79.0 + + + + 77.0 + + + + 78.0 + + + + 78.0 + + + + 79.0 + + + + 78.0 + + + + 77.0 + + + + 79.0 + + + + 78.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 75.0 + + + + 73.0 + + + + 71.0 + + + + 71.0 + + + + 71.0 + + + + 70.0 + + + + 71.0 + + + + 70.0 + + + + 70.0 + + + + 69.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 65.0 + + + + 64.0 + + + + 64.0 + + + + 63.0 + + + + 61.0 + + + + 61.0 + + + + 62.0 + + + + 62.0 + + + + 61.0 + + + + 61.0 + + + + 62.0 + + + + 63.0 + + + + 65.0 + + + + 66.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 70.0 + + + + 69.0 + + + + 71.0 + + + + 70.0 + + + + 69.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 70.0 + + + + 73.0 + + + + 71.0 + + + + 70.0 + + + + 70.0 + + + + 69.0 + + + + 68.0 + + + + 68.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 68.0 + + + + 67.0 + + + + 68.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 65.0 + + + + 63.0 + + + + 62.0 + + + + 62.0 + + + + 62.0 + + + + 61.0 + + + + 59.0 + + + + 59.0 + + + + 60.0 + + + + 61.0 + + + + 64.0 + + + + 65.0 + + + + 66.0 + + + + 67.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 69.0 + + + + 67.0 + + + + 65.0 + + + + 64.0 + + + + 64.0 + + + + 62.0 + + + + 63.0 + + + + 64.0 + + + + 64.0 + + + + 67.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 72.0 + + + + 72.0 + + + + 72.0 + + + + 70.0 + + + + 70.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 69.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 67.0 + + + + 68.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 70.0 + + + + 70.0 + + + + 70.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 70.0 + + + + 69.0 + + + + 69.0 + + + + 71.0 + + + + 71.0 + + + + 71.0 + + + + 71.0 + + + + 71.0 + + + + 71.0 + + + + 70.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 67.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 69.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 70.0 + + + + 71.0 + + + + 71.0 + + + + 70.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 65.0 + + + + 65.0 + + + + 65.0 + + + + 65.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 68.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 68.0 + + + + 66.0 + + + + 68.0 + + + + 67.0 + + + + 68.0 + + + + 67.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 67.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 65.0 + + + + 66.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 67.0 + + + + 66.0 + + + + 65.0 + + + + 66.0 + + + + 66.0 + + + + 67.0 + + + + 65.0 + + + + 64.0 + + + + 63.0 + + + + 65.0 + + + + 65.0 + + + + 66.0 + + + + 66.0 + + + + 67.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 68.0 + + + + 68.0 + + + + 66.0 + + + + 68.0 + + + + 68.0 + + + + 66.0 + + + + 67.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 67.0 + + + + 68.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 64.0 + + + + 64.0 + + + + 61.0 + + + + 61.0 + + + + 60.0 + + + + 61.0 + + + + 62.0 + + + + 61.0 + + + + 60.0 + + + + 60.0 + + + + 58.0 + + + + 56.0 + + + + 55.0 + + + + 55.0 + + + + 55.0 + + + + 56.0 + + + + 56.0 + + + + 56.0 + + + + 56.0 + + + + 56.0 + + + + 58.0 + + + + 58.0 + + + + 57.0 + + + + 57.0 + + + + 57.0 + + + + 57.0 + + + + 57.0 + + + + 57.0 + + + + 58.0 + + + + 61.0 + + + + 61.0 + + + + 60.0 + + + + 63.0 + + + + 65.0 + + + + 67.0 + + + + 68.0 + + + + 68.0 + + + + 69.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 66.0 + + + + 65.0 + + + + 65.0 + + + + 65.0 + + + + 65.0 + + + + 66.0 + + + + 67.0 + + + + 67.0 + + + + 68.0 + + + + 69.0 + + + + 70.0 + + + + 71.0 + + + + 72.0 + + + + 71.0 + + + + 72.0 + + + + 71.0 + + + + 71.0 + + + + 69.0 + + + + 69.0 + + + + 68.0 + + + + 67.0 + + + + 66.0 + + + + 65.0 + + + + 65.0 + + + + 66.0 + + + + 67.0 + + + + 69.0 + + + + 70.0 + + + + 71.0 + + + + 71.0 + + + + 72.0 + + + + 72.0 + + + + 73.0 + + + + 74.0 + + + + 74.0 + + + + 76.0 + + + + 74.0 + + + + 76.0 + + + + 77.0 + + + + 77.0 + + + + 75.0 + + + + 74.0 + + + + 73.0 + + + + 73.0 + + + + 75.0 + + + + 76.0 + + + + 77.0 + + + + 77.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 81.0 + + + + 81.0 + + + + 81.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 81.0 + + + + 79.0 + + + + 80.0 + + + + 79.0 + + + + 78.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 76.0 + + + + 75.0 + + + + 75.0 + + + + 75.0 + + + + 75.0 + + + + 73.0 + + + + 75.0 + + + + 75.0 + + + + 75.0 + + + + 74.0 + + + + 74.0 + + + + 74.0 + + + + 75.0 + + + + 75.0 + + + + 76.0 + + + + 75.0 + + + + 73.0 + + + + 72.0 + + + + 73.0 + + + + 75.0 + + + + 76.0 + + + + 75.0 + + + + 72.0 + + + + 73.0 + + + + 75.0 + + + + 77.0 + + + + 78.0 + + + + 78.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 77.0 + + + + 78.0 + + + + 77.0 + + + + 78.0 + + + + 75.0 + + + + 73.0 + + + + 72.0 + + + + 75.0 + + + + 74.0 + + + + 70.0 + + + + 69.0 + + + + 69.0 + + + + 70.0 + + + + 70.0 + + + + 71.0 + + + + 70.0 + + + + 70.0 + + + + 69.0 + + + + 67.0 + + + + 67.0 + + + + 70.0 + + + + 68.0 + + + + 66.0 + + + + 66.0 + + + + 65.0 + + + + 66.0 + + + + 68.0 + + + + 70.0 + + + + 70.0 + + + + 72.0 + + + + 71.0 + + + + 71.0 + + + + 71.0 + + + + 73.0 + + + + 75.0 + + + + 75.0 + + + + 75.0 + + + + 77.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 76.0 + + + + 76.0 + + + + 77.0 + + + + 78.0 + + + + 77.0 + + + + 77.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 83.0 + + + + 82.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 83.0 + + + + 85.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 83.0 + + + + 82.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 81.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 80.0 + + + + 83.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 85.0 + + + + 86.0 + + + + 86.0 + + + + 83.0 + + + + 83.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 80.0 + + + + 80.0 + + + + 79.0 + + + + 80.0 + + + + 79.0 + + + + 80.0 + + + + 81.0 + + + + 82.0 + + + + 81.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 80.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 78.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 75.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 77.0 + + + + 79.0 + + + + 78.0 + + + + 77.0 + + + + 78.0 + + + + 78.0 + + + + 78.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 77.0 + + + + 79.0 + + + + 79.0 + + + + 78.0 + + + + 79.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 78.0 + + + + 76.0 + + + + 75.0 + + + + 74.0 + + + + 74.0 + + + + 73.0 + + + + 74.0 + + + + 73.0 + + + + 74.0 + + + + 75.0 + + + + 75.0 + + + + 75.0 + + + + 76.0 + + + + 74.0 + + + + 76.0 + + + + 76.0 + + + + 75.0 + + + + 72.0 + + + + 75.0 + + + + 75.0 + + + + 76.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 77.0 + + + + 77.0 + + + + 75.0 + + + + 77.0 + + + + 77.0 + + + + 77.0 + + + + 80.0 + + + + 80.0 + + + + 79.0 + + + + 79.0 + + + + 79.0 + + + + 77.0 + + + + 77.0 + + + + 76.0 + + + + 75.0 + + + + 76.0 + + + + 76.0 + + + + 77.0 + + + + 76.0 + + + + 76.0 + + + + 76.0 + + + + 77.0 + + + + 77.0 + + + + 78.0 + + + + 78.0 + + + + 78.0 + + + + 78.0 + + + + 78.0 + + + + 78.0 + + + + 77.0 + + + + 79.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 85.0 + + + + 83.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 79.0 + + + + 78.0 + + + + 81.0 + + + + 80.0 + + + + 81.0 + + + + 81.0 + + + + 80.0 + + + + 80.0 + + + + 80.0 + + + + 81.0 + + + + 81.0 + + + + 81.0 + + + + 82.0 + + + + 83.0 + + + + 84.0 + + + + 83.0 + + + + 84.0 + + + + 85.0 + + + + 85.0 + + + + 87.0 + + + + 86.0 + + + + 85.0 + + + + 88.0 + + + + 87.0 + + + + 87.0 + + + + 88.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 91.0 + + + + 93.0 + + + + 93.0 + + + + 93.0 + + + + 90.0 + + + + 91.0 + + + + 92.0 + + + + 93.0 + + + + 91.0 + + + + 91.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 89.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 92.0 + + + + 94.0 + + + + 96.0 + + + + 98.0 + + + + 98.0 + + + + 100.0 + + + + 98.0 + + + + 98.0 + + + + 96.0 + + + + 94.0 + + + + 89.0 + + + + 89.0 + + + + 88.0 + + + + 88.0 + + + + 86.0 + + + + 88.0 + + + + 88.0 + + + + 90.0 + + + + 90.0 + + + + 89.0 + + + + 89.0 + + + + 88.0 + + + + 88.0 + + + + 86.0 + + + + 87.0 + + + + 88.0 + + + + 88.0 + + + + 88.0 + + + + 88.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 85.0 + + + + 87.0 + + + + 87.0 + + + + 88.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 91.0 + + + + 90.0 + + + + 90.0 + + + + 90.0 + + + + 90.0 + + + + 90.0 + + + + 92.0 + + + + 90.0 + + + + 88.0 + + + + 89.0 + + + + 88.0 + + + + 87.0 + + + + 87.0 + + + + 85.0 + + + + 83.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 82.0 + + + + 82.0 + + + + 86.0 + + + + 86.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 84.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 84.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 85.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 85.0 + + + + 85.0 + + + + 86.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 84.0 + + + + 86.0 + + + + 85.0 + + + + 86.0 + + + + 86.0 + + + + 86.0 + + + + 86.0 + + + + 88.0 + + + + 87.0 + + + + 87.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 93.0 + + + + 93.0 + + + + 94.0 + + + + 94.0 + + + + 95.0 + + + + 95.0 + + + + 98.0 + + + + 98.0 + + + + 96.0 + + + + 95.0 + + + + 94.0 + + + + 94.0 + + + + 95.0 + + + + 95.0 + + + + 96.0 + + + + 96.0 + + + + 96.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 96.0 + + + + 96.0 + + + + 96.0 + + + + 97.0 + + + + 97.0 + + + + 97.0 + + + + 97.0 + + + + 97.0 + + + + 98.0 + + + + 97.0 + + + + 97.0 + + + + 97.0 + + + + 97.0 + + + + 96.0 + + + + 96.0 + + + + 95.0 + + + + 96.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 94.0 + + + + 94.0 + + + + 94.0 + + + + 94.0 + + + + 94.0 + + + + 93.0 + + + + 91.0 + + + + 90.0 + + + + 90.0 + + + + 88.0 + + + + 88.0 + + + + 88.0 + + + + 89.0 + + + + 89.0 + + + + 90.0 + + + + 91.0 + + + + 90.0 + + + + 90.0 + + + + 89.0 + + + + 88.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 90.0 + + + + 89.0 + + + + 88.0 + + + + 88.0 + + + + 89.0 + + + + 89.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 91.0 + + + + 90.0 + + + + 89.0 + + + + 87.0 + + + + 88.0 + + + + 87.0 + + + + 87.0 + + + + 86.0 + + + + 87.0 + + + + 87.0 + + + + 86.0 + + + + 84.0 + + + + 82.0 + + + + 81.0 + + + + 82.0 + + + + 83.0 + + + + 82.0 + + + + 82.0 + + + + 83.0 + + + + 84.0 + + + + 83.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 81.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 83.0 + + + + 82.0 + + + + 83.0 + + + + 83.0 + + + + 82.0 + + + + 82.0 + + + + 80.0 + + + + 81.0 + + + + 82.0 + + + + 81.0 + + + + 82.0 + + + + 82.0 + + + + 82.0 + + + + 83.0 + + + + 84.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 84.0 + + + + 86.0 + + + + 86.0 + + + + 87.0 + + + + 87.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 85.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 90.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 86.0 + + + + 86.0 + + + + 86.0 + + + + 87.0 + + + + 87.0 + + + + 87.0 + + + + 86.0 + + + + 87.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 91.0 + + + + 92.0 + + + + 94.0 + + + + 94.0 + + + + 93.0 + + + + 89.0 + + + + 89.0 + + + + 89.0 + + + + 88.0 + + + + 88.0 + + + + 85.0 + + + + 83.0 + + + + 84.0 + + + + 85.0 + + + + 84.0 + + + + 86.0 + + + + 86.0 + + + + 86.0 + + + + 86.0 + + + + 85.0 + + + + 85.0 + + + + 84.0 + + + + 84.0 + + + + 84.0 + + + + 82.0 + + + + 83.0 + + + + 84.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 83.0 + + + + 84.0 + + + + 84.0 + + + + 85.0 + + + + 86.0 + + + + 87.0 + + + + 87.0 + + + + 89.0 + + + + 89.0 + + + + 90.0 + + + + 90.0 + + + + 91.0 + + + + 92.0 + + + + 92.0 + + + + 95.0 + + + + 95.0 + + + + 98.0 + + + + 98.0 + + + + 97.0 + + + + 97.0 + + + + 96.0 + + + + 96.0 + + + + 98.0 + + + + 98.0 + + + + 98.0 + + + + 98.0 + + + + 100.0 + + + + 102.0 + + + + 102.0 + + + + 103.0 + + + + 104.0 + + + + 105.0 + + + + 105.0 + + + + 106.0 + + + + 106.0 + + + + 106.0 + + + + 111.0 + + + + 110.0 + + + + 110.0 + + + + 111.0 + + + + 111.0 + + + + 112.0 + + + + 112.0 + + + + 114.0 + + + + 114.0 + + + + 114.0 + + + + 114.0 + + + + 112.0 + + + + 112.0 + + + + 113.0 + + + + 113.0 + + + + 112.0 + + + + 113.0 + + + + 113.0 + + + + 114.0 + + + + 114.0 + + + + 115.0 + + + + 117.0 + + + + 117.0 + + + + 117.0 + + + + 117.0 + + + + 119.0 + + + + 119.0 + + + + 117.0 + + + + 117.0 + + + + 117.0 + + + + 117.0 + + + + 122.0 + + + + 122.0 + + + + 120.0 + + + + 121.0 + + + + 120.0 + + + + 120.0 + + + + 122.0 + + + + 122.0 + + + + 124.0 + + + + 125.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 125.0 + + + + 126.0 + + + + 127.0 + + + + 127.0 + + + + 126.0 + + + + 125.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 128.0 + + + + 128.0 + + + + 129.0 + + + + 129.0 + + + + 131.0 + + + + 131.0 + + + + 132.0 + + + + 132.0 + + + + 131.0 + + + + 131.0 + + + + 130.0 + + + + 130.0 + + + + 129.0 + + + + 128.0 + + + + 128.0 + + + + 127.0 + + + + 127.0 + + + + 127.0 + + + + 126.0 + + + + 125.0 + + + + 123.0 + + + + 122.0 + + + + 120.0 + + + + 120.0 + + + + 120.0 + + + + 120.0 + + + + 119.0 + + + + 119.0 + + + + 119.0 + + + + 117.0 + + + + 116.0 + + + + 116.0 + + + + 115.0 + + + + 115.0 + + + + 114.0 + + + + 114.0 + + + + 113.0 + + + + 112.0 + + + + 112.0 + + + + 111.0 + + + + 111.0 + + + + 112.0 + + + + 112.0 + + + + 111.0 + + + + 110.0 + + + + 109.0 + + + + 108.0 + + + + 108.0 + + + + 108.0 + + + + 108.0 + + + + 109.0 + + + + 110.0 + + + + 109.0 + + + + 110.0 + + + + 111.0 + + + + 112.0 + + + + 111.0 + + + + 112.0 + + + + 112.0 + + + + 111.0 + + + + 111.0 + + + + 111.0 + + + + 111.0 + + + + 113.0 + + + + 113.0 + + + + 114.0 + + + + 114.0 + + + + 115.0 + + + + 114.0 + + + + 116.0 + + + + 118.0 + + + + 120.0 + + + + 120.0 + + + + 120.0 + + + + 121.0 + + + + 121.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 121.0 + + + + 122.0 + + + + 123.0 + + + + 123.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 126.0 + + + + 126.0 + + + + 125.0 + + + + 124.0 + + + + 125.0 + + + + 126.0 + + + + 125.0 + + + + 125.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 128.0 + + + + 127.0 + + + + 126.0 + + + + 125.0 + + + + 126.0 + + + + 126.0 + + + + 125.0 + + + + 126.0 + + + + 126.0 + + + + 127.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 126.0 + + + + 125.0 + + + + 125.0 + + + + 126.0 + + + + 127.0 + + + + 127.0 + + + + 129.0 + + + + 129.0 + + + + 130.0 + + + + 130.0 + + + + 130.0 + + + + 130.0 + + + + 130.0 + + + + 131.0 + + + + 132.0 + + + + 132.0 + + + + 130.0 + + + + 130.0 + + + + 131.0 + + + + 131.0 + + + + 131.0 + + + + 131.0 + + + + 131.0 + + + + 131.0 + + + + 131.0 + + + + 131.0 + + + + 132.0 + + + + 132.0 + + + + 133.0 + + + + 133.0 + + + + 132.0 + + + + 133.0 + + + + 133.0 + + + + 134.0 + + + + 134.0 + + + + 134.0 + + + + 134.0 + + + + 135.0 + + + + 135.0 + + + + 134.0 + + + + 134.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 134.0 + + + + 135.0 + + + + 136.0 + + + + 136.0 + + + + 136.0 + + + + 136.0 + + + + 135.0 + + + + 135.0 + + + + 135.0 + + + + 135.0 + + + + 136.0 + + + + 136.0 + + + + 135.0 + + + + 135.0 + + + + 136.0 + + + + 135.0 + + + + 136.0 + + + + 136.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 136.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 140.0 + + + + 141.0 + + + + 141.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 138.0 + + + + 139.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 138.0 + + + + 138.0 + + + + 137.0 + + + + 138.0 + + + + 137.0 + + + + 137.0 + + + + 136.0 + + + + 136.0 + + + + 135.0 + + + + 136.0 + + + + 137.0 + + + + 136.0 + + + + 136.0 + + + + 135.0 + + + + 135.0 + + + + 135.0 + + + + 135.0 + + + + 135.0 + + + + 136.0 + + + + 136.0 + + + + 136.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 138.0 + + + + 138.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 138.0 + + + + 138.0 + + + + 137.0 + + + + 138.0 + + + + 138.0 + + + + 138.0 + + + + 139.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 138.0 + + + + 138.0 + + + + 138.0 + + + + 138.0 + + + + 138.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 139.0 + + + + 139.0 + + + + 138.0 + + + + 138.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 137.0 + + + + 137.0 + + + + 138.0 + + + + 139.0 + + + + 138.0 + + + + 138.0 + + + + 139.0 + + + + 140.0 + + + + 139.0 + + + + 140.0 + + + + 139.0 + + + + 141.0 + + + + 142.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 141.0 + + + + 140.0 + + + + 143.0 + + + + 142.0 + + + + 143.0 + + + + 142.0 + + + + 143.0 + + + + 143.0 + + + + 144.0 + + + + 144.0 + + + + 143.0 + + + + 142.0 + + + + 144.0 + + + + 143.0 + + + + 143.0 + + + + 142.0 + + + + 145.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 146.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 144.0 + + + + 144.0 + + + + 143.0 + + + + 143.0 + + + + 142.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 142.0 + + + + 142.0 + + + + 141.0 + + + + 142.0 + + + + 142.0 + + + + 143.0 + + + + 143.0 + + + + 144.0 + + + + 145.0 + + + + 145.0 + + + + 144.0 + + + + 144.0 + + + + 143.0 + + + + 143.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 148.0 + + + + 148.0 + + + + 151.0 + + + + 153.0 + + + + 153.0 + + + + 152.0 + + + + 152.0 + + + + 149.0 + + + + 147.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 150.0 + + + + 150.0 + + + + 150.0 + + + + 150.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 147.0 + + + + 146.0 + + + + 146.0 + + + + 144.0 + + + + 143.0 + + + + 152.0 + + + + 154.0 + + + + 154.0 + + + + 150.0 + + + + 150.0 + + + + 148.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 148.0 + + + + 148.0 + + + + 149.0 + + + + 150.0 + + + + 150.0 + + + + 151.0 + + + + 150.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 150.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 148.0 + + + + 148.0 + + + + 149.0 + + + + 148.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 148.0 + + + + 148.0 + + + + 147.0 + + + + 146.0 + + + + 148.0 + + + + 149.0 + + + + 145.0 + + + + 146.0 + + + + 146.0 + + + + 148.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 150.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 149.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 148.0 + + + + 148.0 + + + + 147.0 + + + + 146.0 + + + + 147.0 + + + + 147.0 + + + + 149.0 + + + + 149.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 145.0 + + + + 145.0 + + + + 144.0 + + + + 149.0 + + + + 149.0 + + + + 150.0 + + + + 150.0 + + + + 151.0 + + + + 151.0 + + + + 150.0 + + + + 149.0 + + + + 150.0 + + + + 150.0 + + + + 149.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 148.0 + + + + 148.0 + + + + 149.0 + + + + 149.0 + + + + 151.0 + + + + 150.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 149.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 149.0 + + + + 150.0 + + + + 151.0 + + + + 152.0 + + + + 151.0 + + + + 151.0 + + + + 152.0 + + + + 152.0 + + + + 151.0 + + + + 152.0 + + + + 152.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 152.0 + + + + 152.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 151.0 + + + + 150.0 + + + + 152.0 + + + + 151.0 + + + + 153.0 + + + + 153.0 + + + + 154.0 + + + + 155.0 + + + + 154.0 + + + + 154.0 + + + + 154.0 + + + + 154.0 + + + + 154.0 + + + + 155.0 + + + + 155.0 + + + + 155.0 + + + + 155.0 + + + + 155.0 + + + + 155.0 + + + + 156.0 + + + + 157.0 + + + + 157.0 + + + + 157.0 + + + + 154.0 + + + + 155.0 + + + + 157.0 + + + + 157.0 + + + + 157.0 + + + + 159.0 + + + + 160.0 + + + + 164.0 + + + + 164.0 + + + + 163.0 + + + + 164.0 + + + + 163.0 + + + + 163.0 + + + + 164.0 + + + + 159.0 + + + + 161.0 + + + + 161.0 + + + + 162.0 + + + + 162.0 + + + + 161.0 + + + + 161.0 + + + + 160.0 + + + + 154.0 + + + + 155.0 + + + + 155.0 + + + + 154.0 + + + + 155.0 + + + + 150.0 + + + + 150.0 + + + + 149.0 + + + + 149.0 + + + + 150.0 + + + + 150.0 + + + + 151.0 + + + + 150.0 + + + + 150.0 + + + + 149.0 + + + + 146.0 + + + + 153.0 + + + + 152.0 + + + + 148.0 + + + + 149.0 + + + + 147.0 + + + + 144.0 + + + + 141.0 + + + + 142.0 + + + + 143.0 + + + + 144.0 + + + + 153.0 + + + + 153.0 + + + + 149.0 + + + + 145.0 + + + + 144.0 + + + + 143.0 + + + + 143.0 + + + + 145.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 144.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 147.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 146.0 + + + + 146.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 143.0 + + + + 142.0 + + + + 141.0 + + + + 142.0 + + + + 144.0 + + + + 144.0 + + + + 146.0 + + + + 148.0 + + + + 148.0 + + + + 149.0 + + + + 149.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 147.0 + + + + 148.0 + + + + 148.0 + + + + 148.0 + + + + 147.0 + + + + 147.0 + + + + 146.0 + + + + 146.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 146.0 + + + + 145.0 + + + + 145.0 + + + + 141.0 + + + + 140.0 + + + + 140.0 + + + + 142.0 + + + + 143.0 + + + + 144.0 + + + + 145.0 + + + + 144.0 + + + + 146.0 + + + + 146.0 + + + + 144.0 + + + + 145.0 + + + + 145.0 + + + + 146.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 144.0 + + + + 145.0 + + + + 145.0 + + + + 145.0 + + + + 143.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 143.0 + + + + 143.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 146.0 + + + + 146.0 + + + + 146.0 + + + + 145.0 + + + + 144.0 + + + + 144.0 + + + + 144.0 + + + + 145.0 + + + + 144.0 + + + + 144.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 144.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 139.0 + + + + 141.0 + + + + 141.0 + + + + 142.0 + + + + 141.0 + + + + 141.0 + + + + 141.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 138.0 + + + + 139.0 + + + + 140.0 + + + + 139.0 + + + + 140.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 141.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 142.0 + + + + 141.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 140.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 141.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 140.0 + + + + 138.0 + + + + 139.0 + + + + 140.0 + + + + 140.0 + + + + 140.0 + + + + 144.0 + + + + 144.0 + + + + 142.0 + + + + 142.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 143.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 142.0 + + + + 141.0 + + + + 141.0 + + + + 141.0 + + + + 141.0 + + + + 139.0 + + + + 139.0 + + + + 141.0 + + + + 141.0 + + + + 142.0 + + + + 141.0 + + + + 140.0 + + + + 140.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 139.0 + + + + 141.0 + + + + 142.0 + + + + 141.0 + + + + 140.0 + + + + 139.0 + + + + 135.0 + + + + 134.0 + + + + 134.0 + + + + 135.0 + + + + 135.0 + + + + 136.0 + + + + 136.0 + + + + 138.0 + + + + 136.0 + + + + 136.0 + + + + 135.0 + + + + 135.0 + + + + 134.0 + + + + 136.0 + + + + 135.0 + + + + 135.0 + + + + 134.0 + + + + 134.0 + + + + 134.0 + + + + 133.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 132.0 + + + + 133.0 + + + + 133.0 + + + + 132.0 + + + + 133.0 + + + + 133.0 + + + + 133.0 + + + + 132.0 + + + + 131.0 + + + + 132.0 + + + + 132.0 + + + + 131.0 + + + + 133.0 + + + + 132.0 + + + + 132.0 + + + + 132.0 + + + + 133.0 + + + + 133.0 + + + + 134.0 + + + + 137.0 + + + + 137.0 + + + + 137.0 + + + + 136.0 + + + + 136.0 + + + + 136.0 + + + + 135.0 + + + + 135.0 + + + + 136.0 + + + + 136.0 + + + + 136.0 + + + + 133.0 + + + + 132.0 + + + + 129.0 + + + + 129.0 + + + + 129.0 + + + + 130.0 + + + + 130.0 + + + + 130.0 + + + + 129.0 + + + + 130.0 + + + + 130.0 + + + + 130.0 + + + + 129.0 + + + + 129.0 + + + + 128.0 + + + + 128.0 + + + + 126.0 + + + + 125.0 + + + + 126.0 + + + + 125.0 + + + + 125.0 + + + + 125.0 + + + + 123.0 + + + + 123.0 + + + + 123.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 121.0 + + + + 121.0 + + + + 121.0 + + + + 121.0 + + + + 120.0 + + + + 120.0 + + + + 120.0 + + + + 120.0 + + + + 120.0 + + + + 119.0 + + + + 119.0 + + + + 120.0 + + + + 119.0 + + + + 120.0 + + + + 121.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 123.0 + + + + 121.0 + + + + 121.0 + + + + 121.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 122.0 + + + + 120.0 + + + + 118.0 + + + + 117.0 + + + + 120.0 + + + + 119.0 + + + + 119.0 + + + + 117.0 + + + + 117.0 + + + + 119.0 + + + + 118.0 + + + + 119.0 + + + + 118.0 + + + + 119.0 + + + + 118.0 + + + + 118.0 + + + + 118.0 + + + + 119.0 + + + + 115.0 + + + + 118.0 + + + + 118.0 + + + + 118.0 + + + + 116.0 + + + + 113.0 + + + + 114.0 + + + + 114.0 + + + + 113.0 + + + + 112.0 + + + + 111.0 + + + + 111.0 + + + + 111.0 + + + + 111.0 + + + + 111.0 + + + + 111.0 + + + + 110.0 + + + + 111.0 + + + + 110.0 + + + + 109.0 + + + + 108.0 + + + + 109.0 + + + + 108.0 + + + + 108.0 + + + + 108.0 + + + + 108.0 + + + + 109.0 + + + + 108.0 + + + + 109.0 + + + + 107.0 + + + + 106.0 + + + + 107.0 + + + + 107.0 + + + + 106.0 + + + + 103.0 + + + + 103.0 + + + + 103.0 + + + + 103.0 + + + + 104.0 + + + + 102.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 104.0 + + + + 105.0 + + + + 105.0 + + + + 104.0 + + + + 104.0 + + + + 103.0 + + + + 103.0 + + + + 103.0 + + + + 103.0 + + + + 102.0 + + + + 101.0 + + + + 101.0 + + + + 100.0 + + + + 100.0 + + + + 100.0 + + + + 99.0 + + + + 100.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 100.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 102.0 + + + + 99.0 + + + + 97.0 + + + + 97.0 + + + + 96.0 + + + + 96.0 + + + + 96.0 + + + + 95.0 + + + + 94.0 + + + + 94.0 + + + + 94.0 + + + + 95.0 + + + + 96.0 + + + + 95.0 + + + + 96.0 + + + + 96.0 + + + + 96.0 + + + + 96.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 96.0 + + + + 97.0 + + + + 97.0 + + + + 99.0 + + + + 97.0 + + + + 97.0 + + + + 98.0 + + + + 97.0 + + + + 98.0 + + + + 97.0 + + + + 99.0 + + + + 100.0 + + + + 99.0 + + + + 99.0 + + + + 100.0 + + + + 100.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 98.0 + + + + 97.0 + + + + 97.0 + + + + 97.0 + + + + 96.0 + + + + 95.0 + + + + 95.0 + + + + 94.0 + + + + 94.0 + + + + 94.0 + + + + 96.0 + + + + 95.0 + + + + 94.0 + + + + 93.0 + + + + 92.0 + + + + 94.0 + + + + 93.0 + + + + 93.0 + + + + 92.0 + + + + 91.0 + + + + 91.0 + + + + 92.0 + + + + 92.0 + + + + 90.0 + + + + 101.0 + + + + 102.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 99.0 + + + + 94.0 + + + + 94.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 95.0 + + + + 96.0 + + + + 98.0 + + + + 100.0 + + + + 99.0 + + + + 98.0 + + + + 98.0 + + + + 98.0 + + + + 98.0 + + + + 98.0 + + + + 98.0 + + + + 103.0 + + + + 104.0 + + + + 103.0 + + + + 103.0 + + + + 104.0 + + + + 104.0 + + + + 102.0 + + + + 102.0 + + + + 102.0 + + + + 102.0 + + + + 105.0 + + + + 105.0 + + + + 106.0 + + + + 109.0 + + + + 108.0 + + + + 106.0 + + + + 106.0 + + + + 106.0 + + + + + diff --git a/libcurl.pbi b/libcurl.pbi new file mode 100644 index 0000000..0feb7dc --- /dev/null +++ b/libcurl.pbi @@ -0,0 +1,1074 @@ +Enumeration 0 + #CURLE_OK + #CURLE_UNSUPPORTED_PROTOCOL ; 1 + #CURLE_FAILED_INIT ; 2 + #CURLE_URL_MALFORMAT ; 3 + #CURLE_URL_MALFORMAT_USER ; 4 (Not USED) + #CURLE_COULDNT_RESOLVE_PROXY ; 5 + #CURLE_COULDNT_RESOLVE_HOST ; 6 + #CURLE_COULDNT_CONNECT ; 7 + #CURLE_FTP_WEIRD_SERVER_REPLY ; 8 + #CURLE_FTP_ACCESS_DENIED ; 9 a service was denied by the FTP server due To lack of access - when login fails this is Not returned. + #CURLE_FTP_USER_PASSWORD_INCORRECT ; 10 + #CURLE_FTP_WEIRD_PASS_REPLY ; 11 + #CURLE_FTP_WEIRD_USER_REPLY ; 12 + #CURLE_FTP_WEIRD_PASV_REPLY ; 13 + #CURLE_FTP_WEIRD_227_FORMAT ; 14 + #CURLE_FTP_CANT_GET_HOST ; 15 + #CURLE_FTP_CANT_RECONNECT ; 16 + #CURLE_FTP_COULDNT_SET_BINARY ; 17 + #CURLE_PARTIAL_FILE ; 18 + #CURLE_FTP_COULDNT_RETR_FILE ; 19 + #CURLE_FTP_WRITE_ERROR ; 20 + #CURLE_FTP_QUOTE_ERROR ; 21 + #CURLE_HTTP_RETURNED_ERROR ; 22 + #CURLE_WRITE_ERROR ; 23 + #CURLE_MALFORMAT_USER ; 24 - Not USED + #CURLE_FTP_COULDNT_STOR_FILE ; 25 - failed FTP upload + #CURLE_READ_ERROR ; 26 - could open/Read from file + #CURLE_OUT_OF_MEMORY ; 27 + #CURLE_OPERATION_TIMEOUTED ; 28 - the timeout time was reached + #CURLE_FTP_COULDNT_SET_ASCII ; 29 - TYPE A failed + #CURLE_FTP_PORT_FAILED ; 30 - FTP PORT operation failed + #CURLE_FTP_COULDNT_USE_REST ; 31 - the REST command failed + #CURLE_FTP_COULDNT_GET_SIZE ; 32 - the SIZE command failed + #CURLE_HTTP_RANGE_ERROR ; 33 - RANGE "command" didn't work + #CURLE_HTTP_POST_ERROR ; 34 + #CURLE_SSL_CONNECT_ERROR ; 35 - wrong when connecting With SSL + #CURLE_BAD_DOWNLOAD_RESUME ; 36 - couldn't resume download + #CURLE_FILE_COULDNT_READ_FILE ; 37 + #CURLE_LDAP_CANNOT_BIND ; 38 + #CURLE_LDAP_SEARCH_FAILED ; 39 + #CURLE_LIBRARY_NOT_FOUND ; 40 + #CURLE_FUNCTION_NOT_FOUND ; 41 + #CURLE_ABORTED_BY_CALLBACK ; 42 + #CURLE_BAD_FUNCTION_ARGUMENT ; 43 + #CURLE_BAD_CALLING_ORDER ; 44 - Not USED + #CURLE_INTERFACE_FAILED ; 45 - CURLOPT_INTERFACE failed + #CURLE_BAD_PASSWORD_ENTERED ; 46 - Not USED + #CURLE_TOO_MANY_REDIRECTS ; 47 - catch endless re-direct loops + #CURLE_UNKNOWN_TELNET_OPTION ; 48 - User specified an unknown option + #CURLE_TELNET_OPTION_SYNTAX ; 49 - Malformed telnet option + #CURLE_OBSOLETE ; 50 - Not USED + #CURLE_SSL_PEER_CERTIFICATE ; 51 - peer's certificate wasn't ok + #CURLE_GOT_NOTHING ; 52 - when this is a specific error + #CURLE_SSL_ENGINE_NOTFOUND ; 53 - SSL crypto engine Not found + #CURLE_SSL_ENGINE_SETFAILED ; 54 - can Not set SSL crypto engine As Default + #CURLE_SEND_ERROR ; 55 - failed sending network Data + #CURLE_RECV_ERROR ; 56 - failure in receiving network Data + #CURLE_SHARE_IN_USE ; 57 - share is in use + #CURLE_SSL_CERTPROBLEM ; 58 - problem With the local certificate + #CURLE_SSL_CIPHER ; 59 - couldn't use specified cipher + #CURLE_SSL_CACERT ; 60 - problem With the CA cert (path?) + #CURLE_BAD_CONTENT_ENCODING ; 61 - Unrecognized transfer encoding + #CURLE_LDAP_INVALID_URL ; 62 - Invalid LDAP URL + #CURLE_FILESIZE_EXCEEDED ; 63 - Maximum file size exceeded + #CURLE_FTP_SSL_FAILED ; 64 - Requested FTP SSL level failed + #CURLE_SEND_FAIL_REWIND ; 65 - Sending the Data requires a rewind that failed + #CURLE_SSL_ENGINE_INITFAILED ; 66 - failed To initialise ENGINE + #CURLE_LOGIN_DENIED ; 67 - user password Or similar was Not accepted And we failed To login + #CURLE_TFTP_NOTFOUND ; 68 - file Not found on server + #CURLE_TFTP_PERM ; 69 - permission problem on server + #CURLE_TFTP_DISKFULL ; 70 - out of disk space on server + #CURLE_TFTP_ILLEGAL ; 71 - Illegal TFTP operation + #CURLE_TFTP_UNKNOWNID ; 72 - Unknown transfer ID + #CURLE_TFTP_EXISTS ; 73 - File already exists + #CURLE_TFTP_NOSUCHUSER ; 74 - No such user + #CURL_LAST ; never use! +EndEnumeration +Enumeration 0 ; curlsocktype + #CURLSOCKTYPE_IPCXN ; socket created For a specific IP connection + #CURLSOCKTYPE_LAST ; never use +EndEnumeration +Enumeration ; curlioerr + #CURLIOE_OK ; I/O operation successful + #CURLIOE_UNKNOWNCMD ; command was unknown To callback + #CURLIOE_FAILRESTART ; failed To restart the Read + #CURLIOE_LAST ; never use +EndEnumeration +Enumeration ; curliocmd + #CURLIOCMD_NOP ; no operation + #CURLIOCMD_RESTARTREAD ; restart the Read stream from start + #CURLIOCMD_LAST ; never use +EndEnumeration +Enumeration 0 ; curl_infotype + ; the kind of Data that is passed To information_callback + #CURLINFO_TEXT + #CURLINFO_HEADER_IN ; 1 + #CURLINFO_HEADER_OUT ; 2 + #CURLINFO_DATA_IN ; 3 + #CURLINFO_DATA_OUT ; 4 + #CURLINFO_SSL_DATA_IN ; 5 + #CURLINFO_SSL_DATA_OUT ; 6 + #CURLINFO_END +EndEnumeration +Enumeration ; curl_proxytype + #CURLPROXY_HTTP = 0 + #CURLPROXY_SOCKS4 = 4 + #CURLPROXY_SOCKS5 = 5 +EndEnumeration +Enumeration ; curl_usessl + ; parameter For the CURLOPT_USE_SSL option + #CURLUSESSL_NONE ; do Not attempt To use SSL + #CURLUSESSL_TRY ; try using SSL proceed anyway otherwise + #CURLUSESSL_CONTROL ; SSL For the control connection Or fail + #CURLUSESSL_ALL ; SSL For all communication Or fail + #CURLUSESSL_LAST ; Not an option never use +EndEnumeration ; +Enumeration ; curl_ftpccc + ; parameter For the CURLOPT_FTP_SSL_CCC option + #CURLFTPSSL_CCC_NONE ; do Not send CCC + #CURLFTPSSL_CCC_PASSIVE ; Let the server initiate the shutdown + #CURLFTPSSL_CCC_ACTIVE ; Initiate the shutdown + #CURLFTPSSL_CCC_LAST ; Not an option never use +EndEnumeration +Enumeration ; curl_ftpauth + ; parameter For the CURLOPT_FTPSSLAUTH option + #CURLFTPAUTH_DEFAULT ; let libcurl decide + #CURLFTPAUTH_SSL ; use "AUTH SSL" + #CURLFTPAUTH_TLS ; use "AUTH TLS" + #CURLFTPAUTH_LAST ; Not an option never use +EndEnumeration +Enumeration ; curl_ftpmethod + ; parameter For the CURLOPT_FTP_FILEMETHOD option + #CURLFTPMETHOD_DEFAULT ; let libcurl pick + #CURLFTPMETHOD_MULTICWD ; single CWD operation For each path part + #CURLFTPMETHOD_NOCWD ; no CWD at all + #CURLFTPMETHOD_SINGLECWD ; one CWD To full dir then work on file + #CURLFTPMETHOD_LAST ; Not an option never use +EndEnumeration +Enumeration ; curl_http + ; These enums are For use With the CURLOPT_HTTP_VERSION option. + #CURL_HTTP_VERSION_NONE ; setting this means we don't care and that we'd + ; like the library To choose the best possible + ; For us! + #CURL_HTTP_VERSION_1_0 ; please use HTTP 1.0 in the request + #CURL_HTTP_VERSION_1_1 ; please use HTTP 1.1 in the request + #CURL_HTTP_VERSION_LAST ; *ILLEGAL* http version +EndEnumeration +Enumeration ; curl_NETRC_OPTION + ; These enums are For use With the CURLOPT_NETRC option. + #CURL_NETRC_IGNORED ; The .netrc will never be Read. + ; This is the Default. + #CURL_NETRC_OPTIONAL ; A user:password in the URL will be preferred + ; To one in the .netrc. + #CURL_NETRC_REQUIRED ; A user:password in the URL will be ignored. + ; Unless one is set programmatically the .netrc + ; will be queried. + #CURL_NETRC_LAST +EndEnumeration +Enumeration ; curl_sslversion + #CURL_SSLVERSION_DEFAULT + #CURL_SSLVERSION_TLSv1 + #CURL_SSLVERSION_SSLv2 + #CURL_SSLVERSION_SSLv3 + #CURL_SSLVERSION_LAST ; never use keep last +EndEnumeration +Enumeration ; curl_TimeCond + #CURL_TIMECOND_NONE + #CURL_TIMECOND_IFMODSINCE + #CURL_TIMECOND_IFUNMODSINCE + #CURL_TIMECOND_LASTMOD + #CURL_TIMECOND_LAST +EndEnumeration ; +Enumeration ; curlformoption + #CURLFORM_NOTHING ; the first one is unused + #CURLFORM_COPYNAME + #CURLFORM_PTRNAME + #CURLFORM_NAMELENGTH + #CURLFORM_COPYCONTENTS + #CURLFORM_PTRCONTENTS + #CURLFORM_CONTENTSLENGTH + #CURLFORM_FILECONTENT + #CURLFORM_ARRAY + #CURLFORM_OBSOLETE + #CURLFORM_FILE + #CURLFORM_BUFFER + #CURLFORM_BUFFERPTR + #CURLFORM_BUFFERLENGTH + #CURLFORM_CONTENTTYPE + #CURLFORM_CONTENTHEADER + #CURLFORM_FILENAME + #CURLFORM_End + #CURLFORM_OBSOLETE2 + #CURLFORM_LASTENTRY ; the last unusued +EndEnumeration +; use this For multipart formpost building +; Returns code For #CURL_formadd() +; Returns: +; #CURL_FORMADD_OK on success +; #CURL_FORMADD_MEMORY If the FormInfo allocation fails +; #CURL_FORMADD_OPTION_TWICE If one option is given twice For one Form +; #CURL_FORMADD_NULL If a null pointer was given For a char +; #CURL_FORMADD_MEMORY If the allocation of a FormInfo struct failed +; #CURL_FORMADD_UNKNOWN_OPTION If an unknown option was used +; #CURL_FORMADD_INCOMPLETE If the some FormInfo is Not complete (Or error) +; #CURL_FORMADD_MEMORY If a HttpPost struct cannot be allocated +; #CURL_FORMADD_MEMORY If some allocation For string copying failed. +; #CURL_FORMADD_ILLEGAL_ARRAY If an illegal option is used in an array +Enumeration ; CURLFORMcode + #CURL_FORMADD_OK ; first no error + #CURL_FORMADD_MEMORY + #CURL_FORMADD_OPTION_TWICE + #CURL_FORMADD_NULL + #CURL_FORMADD_UNKNOWN_OPTION + #CURL_FORMADD_INCOMPLETE + #CURL_FORMADD_ILLEGAL_ARRAY + #CURL_FORMADD_DISABLED ; libcurl was built With this disabled + #CURL_FORMADD_LAST ; last +EndEnumeration +Enumeration ; CURL_closepolicy + #CURLCLOSEPOLICY_NONE ; first never use this + #CURLCLOSEPOLICY_OLDEST + #CURLCLOSEPOLICY_LEAST_RECENTLY_USED + #CURLCLOSEPOLICY_LEAST_TRAFFIC + #CURLCLOSEPOLICY_SLOWEST + #CURLCLOSEPOLICY_CALLBACK + #CURLCLOSEPOLICY_LAST ; last never use this +EndEnumeration +; Different Data locks For a single share +Enumeration 0 ; CURL_lock_data + #CURL_LOCK_DATA_NONE + ; #CURL_LOCK_DATA_SHARE is used internaly To say that + ; the locking is just made To change the internal state of the share + ; itself. + #CURL_LOCK_DATA_SHARE + #CURL_LOCK_DATA_COOKIE + #CURL_LOCK_DATA_DNS + #CURL_LOCK_DATA_SSL_SESSION + #CURL_LOCK_DATA_CONNECT + #CURL_LOCK_DATA_LAST +EndEnumeration ; + ; Different lock access types +Enumeration ; CURL_lock_access + #CURL_LOCK_ACCESS_NONE = 0 ; unspecified action + #CURL_LOCK_ACCESS_SHARED = 1 ; For Read perhaps + #CURL_LOCK_ACCESS_SINGLE = 2 ; For write perhaps + #CURL_LOCK_ACCESS_LAST ; never use +EndEnumeration ; +Enumeration ; CURLSHcode + #CURLSHE_OK ; all is fine + #CURLSHE_BAD_OPTION ; 1 + #CURLSHE_IN_USE ; 2 + #CURLSHE_INVALID ; 3 + #CURLSHE_NOMEM ; out of memory + #CURLSHE_LAST ; never use +EndEnumeration +Enumeration ; CURLSHoption + #CURLSHOPT_NONE ; don't use + #CURLSHOPT_SHARE ; specify a Data type To share + #CURLSHOPT_UNSHARE ; specify shich Data type To stop sharing + #CURLSHOPT_LOCKFUNC ; pass in a '#CURL_lock_function' pointer + #CURLSHOPT_UNLOCKFUNC ; pass in a '#CURL_unlock_function' pointer + #CURLSHOPT_USERDATA ; pass in a user Data pointer used in the lock/unlock + ; callback functions + #CURLSHOPT_LAST ; never use +EndEnumeration +Enumeration ; CURLversion + #CURLVERSION_FIRST + #CURLVERSION_SECOND + #CURLVERSION_THIRD + #CURLVERSION_FOURTH + #CURLVERSION_LAST ; never actually use this +EndEnumeration +;} + +;{ Constantes +#CURL_IPRESOLVE_WHATEVER = 0 ; Default resolves addresses To all IP versions that your system allows +#CURL_IPRESOLVE_V4 = 1 ; resolve To ipv4 addresses +#CURL_IPRESOLVE_V6 = 2 ; resolve To ipv6 addresses + +#CURLOPT_HTTPREQUEST = -1 +; #CURLOPT_FTPASCII = #CURLOPT_TRANSFERTEXT +#CURLOPT_MUTE = -2 +#CURLOPT_PASSWDFUNCTION = -3 +#CURLOPT_PASSWDDATA = -4 +#CURLOPT_CLOSEFUNCTION = -5 +#CURLOPT_SOURCE_HOST = -6 +#CURLOPT_SOURCE_PATH = -7 +#CURLOPT_SOURCE_PORT = -8 +#CURLOPT_PASV_HOST = -9 + +#CURLOPT_INFILESIZE = 00014 +#CURLOPT_VERBOSE = 00041 +#CURLOPT_HEADER = 00042 +#CURLOPT_UPLOAD = 00046 +#CURLOPT_FOLLOWLOCATION = 00052 +#CURLOPT_SSL_VERIFYPEER = 00064 +#CURLOPT_SSL_VERIFYHOST = 00081 +#CURLOPT_IGNORE_CONTENT_LENGTH= 00136 +#CURLOPT_FILE = 10001 +#CURLOPT_URL = 10002 +#CURLOPT_USERPWD = 10005 +#CURLOPT_INFILE = 10009 +#CURLOPT_WRITEHEADER = 10029 +#CURLOPT_POSTQUOTE = 10039 + +#CURLOPT_INFILESIZE_LARGE = 30115 + +#CURLOPTTYPE_OBJECTPOINT = 10000 +#CURLOPT_POSTFIELDS = #CURLOPTTYPE_OBJECTPOINT + 15 + +#CURLOPTTYPE_FUNCTIONPOINT = 20000 +#CURLOPT_WRITEFUNCTION = #CURLOPTTYPE_FUNCTIONPOINT + 11 +#CURLOPT_HEADERFUNCTION = #CURLOPTTYPE_FUNCTIONPOINT + 79 + +; Three convenient "aliases" that follow the name scheme better +#CURLOPT_WRITEDATA = #CURLOPT_FILE +#CURLOPT_READDATA = #CURLOPT_INFILE +#CURLOPT_HEADERDATA = #CURLOPT_WRITEHEADER + +#CURL_GLOBAL_ALL = $00000003 +#CURL_GLOBAL_DEFAULT = $00000003 + +#CURL_MAX_WRITE_SIZE = 16384 +#CURL_READFUNC_ABORT = $10000000 +;{ #CURLINFO +#CURLINFO_STRING = $100000 +#CURLINFO_LONG = $200000 +#CURLINFO_DOUBLE = $300000 +#CURLINFO_SLIST = $400000 +#CURLINFO_MASK = $0fffff +#CURLINFO_TYPEMASK = $f00000 + +#CURLINFO_EFFECTIVE_URL = #CURLINFO_STRING + 1 +#CURLINFO_RESPONSE_CODE = #CURLINFO_LONG + 2 +#CURLINFO_TOTAL_TIME = #CURLINFO_DOUBLE + 3 +#CURLINFO_NAMELOOKUP_TIME = #CURLINFO_DOUBLE + 4 +#CURLINFO_CONNECT_TIME = #CURLINFO_DOUBLE + 5 +#CURLINFO_PRETRANSFER_TIME = #CURLINFO_DOUBLE + 6 +#CURLINFO_SIZE_UPLOAD = #CURLINFO_DOUBLE + 7 +#CURLINFO_SIZE_DOWNLOAD = #CURLINFO_DOUBLE + 8 +#CURLINFO_SPEED_DOWNLOAD = #CURLINFO_DOUBLE + 9 +#CURLINFO_SPEED_UPLOAD = #CURLINFO_DOUBLE + 10 +#CURLINFO_HEADER_SIZE = #CURLINFO_LONG + 11 +#CURLINFO_REQUEST_SIZE = #CURLINFO_LONG + 12 +#CURLINFO_SSL_VERIFYRESULT = #CURLINFO_LONG + 13 +#CURLINFO_FILETIME = #CURLINFO_LONG + 14 +#CURLINFO_CONTENT_LENGTH_DOWNLOAD = #CURLINFO_DOUBLE + 15 +#CURLINFO_CONTENT_LENGTH_UPLOAD = #CURLINFO_DOUBLE + 16 +#CURLINFO_STARTTRANSFER_TIME = #CURLINFO_DOUBLE + 17 +#CURLINFO_CONTENT_TYPE = #CURLINFO_STRING + 18 +#CURLINFO_REDIRECT_TIME = #CURLINFO_DOUBLE + 19 +#CURLINFO_REDIRECT_COUNT = #CURLINFO_LONG + 20 +#CURLINFO_PRIVATE = #CURLINFO_STRING + 21 +#CURLINFO_HTTP_CONNECTCODE = #CURLINFO_LONG + 22 +#CURLINFO_HTTPAUTH_AVAIL = #CURLINFO_LONG + 23 +#CURLINFO_PROXYAUTH_AVAIL = #CURLINFO_LONG + 24 +#CURLINFO_OS_ERRNO = #CURLINFO_LONG + 25 +#CURLINFO_NUM_CONNECTS = #CURLINFO_LONG + 26 +#CURLINFO_SSL_ENGINES = #CURLINFO_SLIST + 27 +#CURLINFO_COOKIELIST = #CURLINFO_SLIST + 28 +#CURLINFO_LASTSOCKET = #CURLINFO_LONG + 29 +#CURLINFO_FTP_ENTRY_PATH = #CURLINFO_STRING + 30 +#CURLINFO_LASTONE = 30 +#CURLINFO_HTTP_CODE = #CURLINFO_RESPONSE_CODE +;} +;{ #CURLOPT +#CURLOPTTYPE_LONG = 0 +#CURLOPTTYPE_OBJECTPOINT = 10000 +#CURLOPTTYPE_FUNCTIONPOINT = 20000 +#CURLOPTTYPE_OFF_T = 30000 + +;This Macro-mania below setups the CURLOPT_[what] enum + To be used With +;curl_easy_setopt(). The first argument in the CURLOPT_) Macro is the [what] word. + +; This is the FILE;Or void;the regular output should be written To. +#CURLOPT_FILE = #CURLOPTTYPE_OBJECTPOINT + 1 +; The full URL To get/put +#CURLOPT_URL= #CURLOPTTYPE_OBJECTPOINT + 2 +; Port number To connect To + If other than Default. +#CURLOPT_PORT= #CURLOPTTYPE_LONG + 3 +; Name of proxy To use. +#CURLOPT_PROXY= #CURLOPTTYPE_OBJECTPOINT + 4 +; "name:password" To use when fetching. +#CURLOPT_USERPWD= #CURLOPTTYPE_OBJECTPOINT + 5 +; "name:password" To use With proxy. +#CURLOPT_PROXYUSERPWD= #CURLOPTTYPE_OBJECTPOINT + 6 +; Range To get + specified As an ASCII string. +#CURLOPT_RANGE= #CURLOPTTYPE_OBJECTPOINT + 7 +; Specified file stream To upload from (use As input): +#CURLOPT_INFILE= #CURLOPTTYPE_OBJECTPOINT + 9 +; Buffer To receive error messages in + must be at least CURL_ERROR_SIZE +; bytes big. If this is Not used + error messages go To stderr instead: +#CURLOPT_ERRORBUFFER= #CURLOPTTYPE_OBJECTPOINT + 10 +; Function that will be called To store the output (instead of fwrite). The +; parameters will use fwrite() syntax + make sure To follow them. +#CURLOPT_WRITEFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 11 +; Function that will be called To Read the Input (instead of fread). The +; parameters will use fread() syntax + make sure To follow them. +#CURLOPT_READFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 12 +; Time-out the Read operation after this amount of seconds +#CURLOPT_TIMEOUT= #CURLOPTTYPE_LONG + 13 +; If the CURLOPT_INFILE is used + this can be used To inform libcurl about +; how large the file being sent really is. That allows better error +; checking And better verifies that the upload was succcessful. -1 means +; unknown size. +; For large file support + there is also a _LARGE version of the key +; which takes an off_t type + allowing platforms With larger off_t +; sizes To handle larger files. See below For INFILESIZE_LARGE. +#CURLOPT_INFILESIZE= #CURLOPTTYPE_LONG + 14 +; POST input fields. +#CURLOPT_POSTFIELDS= #CURLOPTTYPE_OBJECTPOINT + 15 +; Set the referer page (needed by some CGIs) +#CURLOPT_REFERER= #CURLOPTTYPE_OBJECTPOINT + 16 +; Set the FTP PORT string (Interface name + named Or numerical IP address) +; Use i.e '-' To use Default address. +#CURLOPT_FTPPORT= #CURLOPTTYPE_OBJECTPOINT + 17 +; Set the User-Agent string (examined by some CGIs) +#CURLOPT_USERAGENT= #CURLOPTTYPE_OBJECTPOINT + 18 +; If the download receives less than "low speed limit" bytes/second +; during "low speed time" seconds + the operations is aborted. +; You could i.e If you have a pretty high speed connection + abort If +; it is less than 2000 bytes/sec during 20 seconds. +; Set the "low speed limit" +#CURLOPT_LOW_SPEED_LIMIT= #CURLOPTTYPE_LONG + 19 +; Set the "low speed time" +#CURLOPT_LOW_SPEED_TIME= #CURLOPTTYPE_LONG + 20 +; Set the continuation offset. +; Note there is also a _LARGE version of this key which uses +; off_t types + allowing For large file offsets on platforms which +; use larger-than-32-bit off_t's. Look below for RESUME_FROM_LARGE. +#CURLOPT_RESUME_FROM= #CURLOPTTYPE_LONG + 21 +; Set cookie in request: +#CURLOPT_COOKIE= #CURLOPTTYPE_OBJECTPOINT + 22 +; This points To a linked list of headers + struct curl_slist kind +#CURLOPT_HTTPHEADER= #CURLOPTTYPE_OBJECTPOINT + 23 +; This points To a linked list of post entries + struct HttpPost +#CURLOPT_HTTPPOST= #CURLOPTTYPE_OBJECTPOINT + 24 +; name of the file keeping your private SSL-certificate +#CURLOPT_SSLCERT= #CURLOPTTYPE_OBJECTPOINT + 25 +; password For the SSL Or SSH private key +#CURLOPT_KEYPASSWD= #CURLOPTTYPE_OBJECTPOINT + 26 +; send TYPE parameter? +#CURLOPT_CRLF= #CURLOPTTYPE_LONG + 27 +; send linked-list of QUOTE commands +#CURLOPT_QUOTE= #CURLOPTTYPE_OBJECTPOINT + 28 +; send FILE;Or void;To store headers To + If you use a callback it +; is simply passed To the callback unmodified +#CURLOPT_WRITEHEADER= #CURLOPTTYPE_OBJECTPOINT + 29 +; point To a file To Read the initial cookies from + also enables +; "cookie awareness" +#CURLOPT_COOKIEFILE= #CURLOPTTYPE_OBJECTPOINT + 31 +; What version To specifly try To use. +; See CURL_SSLVERSION defines below. +#CURLOPT_SSLVERSION= #CURLOPTTYPE_LONG + 32 +; What kind of HTTP time condition To use + see defines +#CURLOPT_TIMECONDITION= #CURLOPTTYPE_LONG + 33 +; Time To use With the above condition. Specified in number of seconds +; since 1 Jan 1970 +#CURLOPT_TIMEVALUE= #CURLOPTTYPE_LONG + 34 +; Custom request= #CURLOPTTYPE_For customizing the get command like +; HTTP: DELETE + TRACE And others +; FTP: To use a different list command +#CURLOPT_CUSTOMREQUEST= #CURLOPTTYPE_OBJECTPOINT + 36 +; HTTP request= #CURLOPTTYPE_For odd commands like DELETE + TRACE And others +#CURLOPT_STDERR= #CURLOPTTYPE_OBJECTPOINT + 37 +; send linked-list of post-transfer QUOTE commands +#CURLOPT_POSTQUOTE= #CURLOPTTYPE_OBJECTPOINT + 39 +; Pass a pointer To string of the output using full variable-replacement +; As described elsewhere. +#CURLOPT_WRITEINFO= #CURLOPTTYPE_OBJECTPOINT + 40 +#CURLOPT_VERBOSE= #CURLOPTTYPE_LONG + 41 ; talk a lot +#CURLOPT_HEADER= #CURLOPTTYPE_LONG + 42 ; throw the header out too +#CURLOPT_NOPROGRESS= #CURLOPTTYPE_LONG + 43 ; shut off the progress meter +#CURLOPT_NOBODY= #CURLOPTTYPE_LONG + 44 ; use HEAD To get http document +#CURLOPT_FAILONERROR= #CURLOPTTYPE_LONG + 45 ; no output on http error codes >= 300 +#CURLOPT_UPLOAD= #CURLOPTTYPE_LONG + 46 ; this is an upload +#CURLOPT_POST= #CURLOPTTYPE_LONG + 47 ; HTTP POST method +#CURLOPT_DIRLISTONLY= #CURLOPTTYPE_LONG + 48 ; Return bare names when listing directories +#CURLOPT_APPEND= #CURLOPTTYPE_LONG + 50 ; Append instead of overwrite on upload! + ; Specify whether To Read the user+password from the .netrc Or the URL. + ; This must be one of the CURL_NETRC_* enums below. +#CURLOPT_NETRC= #CURLOPTTYPE_LONG + 51 +#CURLOPT_FOLLOWLOCATION= #CURLOPTTYPE_LONG + 52 ; use Location: Luke! +#CURLOPT_TRANSFERTEXT= #CURLOPTTYPE_LONG + 53 ; transfer Data in text/ASCII format +#CURLOPT_PUT= #CURLOPTTYPE_LONG + 54 ; HTTP PUT + ; Function that will be called instead of the internal progress display + ; function. This function should be defined As the curl_progress_callback + ; Prototype defines. +#CURLOPT_PROGRESSFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 56 +; Data passed To the progress callback +#CURLOPT_PROGRESSDATA= #CURLOPTTYPE_OBJECTPOINT + 57 +; We want the referer field set automatically when following locations +#CURLOPT_AUTOREFERER= #CURLOPTTYPE_LONG + 58 +; Port of the proxy + can be set in the proxy string As well With: +; "[host]:[port]" +#CURLOPT_PROXYPORT= #CURLOPTTYPE_LONG + 59 +; size of the POST input Data + If strlen() is Not good To use +#CURLOPT_POSTFIELDSIZE= #CURLOPTTYPE_LONG + 60 +; tunnel non-http operations through a HTTP proxy +#CURLOPT_HTTPPROXYTUNNEL= #CURLOPTTYPE_LONG + 61 +; Set the Interface string To use As outgoing network Interface +#CURLOPT_INTERFACE= #CURLOPTTYPE_OBJECTPOINT + 62 +; Set the krb4/5 security level + this also enables krb4/5 awareness. This +; is a string + 'clear' + 'safe' + 'confidential' Or 'private'. If the string +; is set but doesn't match one of these + 'private' will be used. +#CURLOPT_KRBLEVEL= #CURLOPTTYPE_OBJECTPOINT + 63 +; Set If we should verify the peer in ssl handshake + set 1 To verify. +#CURLOPT_SSL_VERIFYPEER= #CURLOPTTYPE_LONG + 64 +; The CApath Or CAfile used To validate the peer certificate +; this option is used only If SSL_VERIFYPEER is true +#CURLOPT_CAINFO= #CURLOPTTYPE_OBJECTPOINT + 65 +; Maximum number of http redirects To follow +#CURLOPT_MAXREDIRS= #CURLOPTTYPE_LONG + 68 +; Pass a long set To 1 To get the date of the requested document (If +; possible)! Pass a zero To shut it off. +#CURLOPT_FILETIME= #CURLOPTTYPE_LONG + 69 +; This points To a linked list of telnet options +#CURLOPT_TELNETOPTIONS= #CURLOPTTYPE_OBJECTPOINT + 70 +; Max amount of cached alive connections +#CURLOPT_MAXCONNECTS= #CURLOPTTYPE_LONG + 71 +; What policy To use when closing connections when the cache is filled up +#CURLOPT_CLOSEPOLICY= #CURLOPTTYPE_LONG + 72 +; Set To explicitly use a new connection For the upcoming transfer. +; Do Not use this unless you're absolutely sure of this + as it makes the +; operation slower And is less friendly For the network. +#CURLOPT_FRESH_CONNECT= #CURLOPTTYPE_LONG + 74 +; Set To explicitly forbid the upcoming transfer's connection to be re-used +; when done. Do Not use this unless you're absolutely sure of this + as it +; makes the operation slower And is less friendly For the network. +#CURLOPT_FORBID_REUSE= #CURLOPTTYPE_LONG + 75 +; Set To a file name that contains random Data For libcurl To use To +; seed the random engine when doing SSL connects. +#CURLOPT_RANDOM_FILE= #CURLOPTTYPE_OBJECTPOINT + 76 +; Set To the Entropy Gathering Daemon socket pathname +#CURLOPT_EGDSOCKET= #CURLOPTTYPE_OBJECTPOINT + 77 +; Time-out connect operations after this amount of seconds + If connects +; are OK within this time + then fine... This only aborts the connect +; phase. [Only works on unix-style/SIGALRM operating systems] +#CURLOPT_CONNECTTIMEOUT= #CURLOPTTYPE_LONG + 78 +; Function that will be called To store headers (instead of fwrite). The +; parameters will use fwrite() syntax + make sure To follow them. +#CURLOPT_HEADERFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 79 +; Set this To force the HTTP request To get back To GET. Only really usable +; If POST + PUT Or a custom request have been used first. +#CURLOPT_HTTPGET= #CURLOPTTYPE_LONG + 80 +; Set If we should verify the Common name from the peer certificate in ssl +; handshake + set 1 To check existence + 2 To ensure that it matches the +; provided hostname. +#CURLOPT_SSL_VERIFYHOST= #CURLOPTTYPE_LONG + 81 +; Specify which file name To write all known cookies in after completed +; operation. Set file name To "-" (dash) To make it go To stdout. +#CURLOPT_COOKIEJAR= #CURLOPTTYPE_OBJECTPOINT + 82 +; Specify which SSL ciphers To use +#CURLOPT_SSL_CIPHER_LIST= #CURLOPTTYPE_OBJECTPOINT + 83 +; Specify which HTTP version To use! This must be set To one of the +; CURL_HTTP_VERSION* enums set below. +#CURLOPT_HTTP_VERSION= #CURLOPTTYPE_LONG + 84 +; Specificly switch on Or off the FTP engine's use of the EPSV command. By +; Default + that one will always be attempted before the more traditional +; PASV command. +#CURLOPT_FTP_USE_EPSV= #CURLOPTTYPE_LONG + 85 +; type of the file keeping your SSL-certificate ("DER" + "PEM" + "ENG") +#CURLOPT_SSLCERTTYPE= #CURLOPTTYPE_OBJECTPOINT + 86 +; name of the file keeping your private SSL-key +#CURLOPT_SSLKEY= #CURLOPTTYPE_OBJECTPOINT + 87 +; type of the file keeping your private SSL-key ("DER" + "PEM" + "ENG") +#CURLOPT_SSLKEYTYPE= #CURLOPTTYPE_OBJECTPOINT + 88 +; crypto engine For the SSL-sub system +#CURLOPT_SSLENGINE= #CURLOPTTYPE_OBJECTPOINT + 89 +; set the crypto engine For the SSL-sub system As Default +; the param has no meaning... +#CURLOPT_SSLENGINE_DEFAULT= #CURLOPTTYPE_LONG + 90 +; Non-zero value means To use the Global dns cache +#CURLOPT_DNS_USE_GLOBAL_CACHE= #CURLOPTTYPE_LONG + 91 ; To become OBSOLETE soon + ; DNS cache timeout +#CURLOPT_DNS_CACHE_TIMEOUT= #CURLOPTTYPE_LONG + 92 +; send linked-list of pre-transfer QUOTE commands (Wesley Laxton) +#CURLOPT_PREQUOTE= #CURLOPTTYPE_OBJECTPOINT + 93 +; set the Debug function +#CURLOPT_DEBUGFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 94 +; set the Data For the Debug function +#CURLOPT_DEBUGDATA= #CURLOPTTYPE_OBJECTPOINT + 95 +; mark this As start of a cookie session +#CURLOPT_COOKIESESSION= #CURLOPTTYPE_LONG + 96 +; The CApath directory used To validate the peer certificate +; this option is used only If SSL_VERIFYPEER is true +#CURLOPT_CAPATH= #CURLOPTTYPE_OBJECTPOINT + 97 +; Instruct libcurl To use a smaller receive buffer +#CURLOPT_BUFFERSIZE= #CURLOPTTYPE_LONG + 98 +; Instruct libcurl To Not use any signal/alarm handlers + even when using +; timeouts. This option is useful For multi-threaded applications. +; See libcurl-the-guide For more background information. +#CURLOPT_NOSIGNAL= #CURLOPTTYPE_LONG + 99 +; Provide a CURLShare For mutexing non-ts Data +#CURLOPT_SHARE= #CURLOPTTYPE_OBJECTPOINT + 100 +; indicates type of proxy. accepted values are CURLPROXY_HTTP (Default +; CURLPROXY_SOCKS4 And CURLPROXY_SOCKS5. +#CURLOPT_PROXYTYPE= #CURLOPTTYPE_LONG + 101 +; Set the Accept-Encoding string. Use this To tell a server you would like +; the response To be compressed. +#CURLOPT_ENCODING= #CURLOPTTYPE_OBJECTPOINT + 102 +; Set pointer To private Data +#CURLOPT_PRIVATE= #CURLOPTTYPE_OBJECTPOINT + 103 +; Set aliases For HTTP 200 in the HTTP Response header +#CURLOPT_HTTP200ALIASES= #CURLOPTTYPE_OBJECTPOINT + 104 +; Continue To send authentication (user+password) when following locations, +; even when hostname changed. This can potentionally send off the name +; And password To whatever host the server decides. +#CURLOPT_UNRESTRICTED_AUTH= #CURLOPTTYPE_LONG + 105 +; Specificly switch on Or off the FTP engine's use of the EPRT command ( it +; also disables the LPRT attempt). By Default + those ones will always be +; attempted before the good old traditional PORT command. +#CURLOPT_FTP_USE_EPRT= #CURLOPTTYPE_LONG + 106 +; Set this To a bitmask value To enable the particular authentications +; methods you like. Use this in combination With CURLOPT_USERPWD. +; Note that setting multiple bits may cause extra network round-trips. +#CURLOPT_HTTPAUTH= #CURLOPTTYPE_LONG + 107 +; Set the ssl context callback function + currently only For OpenSSL ssl_ctx +; in second argument. The function must be matching the +; curl_ssl_ctx_callback proto. +#CURLOPT_SSL_CTX_FUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 108 +; Set the userdata For the ssl context callback function's third +; argument +#CURLOPT_SSL_CTX_DATA= #CURLOPTTYPE_OBJECTPOINT + 109 +; FTP Option that causes missing dirs To be created on the remote server +#CURLOPT_FTP_CREATE_MISSING_DIRS= #CURLOPTTYPE_LONG + 110 +; Set this To a bitmask value To enable the particular authentications +; methods you like. Use this in combination With CURLOPT_PROXYUSERPWD. +; Note that setting multiple bits may cause extra network round-trips. +#CURLOPT_PROXYAUTH= #CURLOPTTYPE_LONG + 111 +; FTP option that changes the timeout + in seconds + associated With +; getting a response. This is different from transfer timeout time And +; essentially places a demand on the FTP server To acknowledge commands +; in a timely manner. +#CURLOPT_FTP_RESPONSE_TIMEOUT= #CURLOPTTYPE_LONG + 112 +; Set this option To one of the CURL_IPRESOLVE_* defines (see below) To +; tell libcurl To resolve names To those IP versions only. This only has +; affect on systems With support For more than one + i.e IPv4 _and_ IPv6. +#CURLOPT_IPRESOLVE= #CURLOPTTYPE_LONG + 113 +; Set this option To limit the size of a file that will be downloaded from +; an HTTP Or FTP server. +; Note there is also _LARGE version which adds large file support For +; platforms which have larger off_t sizes. See MAXFILESIZE_LARGE below. +#CURLOPT_MAXFILESIZE= #CURLOPTTYPE_LONG + 114 +; See the comment For INFILESIZE above + but in short + specifies +; the size of the file being uploaded. -1 means unknown. +#CURLOPT_INFILESIZE_LARGE= #CURLOPTTYPE_OFF_T + 115 +; Sets the continuation offset. There is also a LONG version of this; +; look above For RESUME_FROM. +#CURLOPT_RESUME_FROM_LARGE= #CURLOPTTYPE_OFF_T + 116 +; Sets the maximum size of Data that will be downloaded from +; an HTTP Or FTP server. See MAXFILESIZE above For the LONG version. +#CURLOPT_MAXFILESIZE_LARGE= #CURLOPTTYPE_OFF_T + 117 +; Set this option To the file name of your .netrc file you want libcurl +; To parse (using the CURLOPT_NETRC option). If Not set= #CURLOPTTYPE_Libcurl will do +; a poor attempt To find the user's home directory and check for a .netrc +; file in there. +#CURLOPT_NETRC_FILE= #CURLOPTTYPE_OBJECTPOINT + 118 +; Enable SSL/TLS For FTP + pick one of: +; CURLFTPSSL_TRY - try using SSL + proceed anyway otherwise +; CURLFTPSSL_CONTROL - SSL For the control connection Or fail +; CURLFTPSSL_ALL - SSL For all communication Or fail +#CURLOPT_USE_SSL= #CURLOPTTYPE_LONG + 119 +; The _LARGE version of the standard POSTFIELDSIZE option +#CURLOPT_POSTFIELDSIZE_LARGE= #CURLOPTTYPE_OFF_T + 120 +; Enable/disable the TCP Nagle algorithm +#CURLOPT_TCP_NODELAY= #CURLOPTTYPE_LONG + 121 +; 122 OBSOLETE + used in 7.12.3. Gone in 7.13.0 +; 123 OBSOLETE. Gone in 7.16.0 +; 124 OBSOLETE + used in 7.12.3. Gone in 7.13.0 +; 125 OBSOLETE + used in 7.12.3. Gone in 7.13.0 +; 126 OBSOLETE + used in 7.12.3. Gone in 7.13.0 +; 127 OBSOLETE. Gone in 7.16.0 +; 128 OBSOLETE. Gone in 7.16.0 +; When FTP over SSL/TLS is selected (With CURLOPT_USE_SSL this option +; can be used To change libcurl's default action which is to first try +; "AUTH SSL" And then "AUTH TLS" in this order + And proceed when a OK +; response has been received. +; Available parameters are: +; CURLFTPAUTH_DEFAULT - let libcurl decide +; CURLFTPAUTH_SSL - try "AUTH SSL" first + then TLS +; CURLFTPAUTH_TLS - try "AUTH TLS" first + then SSL +#CURLOPT_FTPSSLAUTH= #CURLOPTTYPE_LONG + 129 +#CURLOPT_IOCTLFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 130 +#CURLOPT_IOCTLDATA= #CURLOPTTYPE_OBJECTPOINT + 131 +; 132 OBSOLETE. Gone in 7.16.0 +; 133 OBSOLETE. Gone in 7.16.0 +; zero terminated string For pass on To the FTP server when asked For +; "account" info +#CURLOPT_FTP_ACCOUNT= #CURLOPTTYPE_OBJECTPOINT + 134 +; feed cookies into cookie engine +#CURLOPT_COOKIELIST= #CURLOPTTYPE_OBJECTPOINT + 135 +; ignore Content-Length +#CURLOPT_IGNORE_CONTENT_LENGTH= #CURLOPTTYPE_LONG + 136 +; Set To non-zero To skip the IP address received in a 227 PASV FTP server +; response. Typically used For FTP-SSL purposes but is Not restricted To +; that. libcurl will then instead use the same IP address it used For the +; control connection. +#CURLOPT_FTP_SKIP_PASV_IP= #CURLOPTTYPE_LONG + 137 +; Select "file method" To use when doing FTP + see the curl_ftpmethod +; above. +#CURLOPT_FTP_FILEMETHOD= #CURLOPTTYPE_LONG + 138 +; Local port number To bind the socket To +#CURLOPT_LOCALPORT= #CURLOPTTYPE_LONG + 139 +; Number of ports To try + including the first one set With LOCALPORT. +; Thus + setting it To 1 will make no additional attempts but the first. +#CURLOPT_LOCALPORTRANGE= #CURLOPTTYPE_LONG + 140 +; no transfer + set up connection And let application use the socket by +; extracting it With CURLINFO_LASTSOCKET +#CURLOPT_CONNECT_ONLY= #CURLOPTTYPE_LONG + 141 +; Function that will be called To convert from the +; network encoding (instead of using the iconv calls in libcurl) +#CURLOPT_CONV_FROM_NETWORK_FUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 142 +; Function that will be called To convert To the +; network encoding (instead of using the iconv calls in libcurl) +#CURLOPT_CONV_TO_NETWORK_FUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 143 +; Function that will be called To convert from UTF8 +; (instead of using the iconv calls in libcurl) +; Note that this is used only For SSL certificate processing +#CURLOPT_CONV_FROM_UTF8_FUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 144 +; If the connection proceeds too quickly then need To slow it down +; limit-rate: maximum number of bytes per second To send Or receive +#CURLOPT_MAX_SEND_SPEED_LARGE= #CURLOPTTYPE_OFF_T + 145 +#CURLOPT_MAX_RECV_SPEED_LARGE= #CURLOPTTYPE_OFF_T + 146 +; Pointer To command string To send If USER/PASS fails. +#CURLOPT_FTP_ALTERNATIVE_TO_USER= #CURLOPTTYPE_OBJECTPOINT + 147 +; callback function For setting socket options +#CURLOPT_SOCKOPTFUNCTION= #CURLOPTTYPE_FUNCTIONPOINT + 148 +#CURLOPT_SOCKOPTDATA= #CURLOPTTYPE_OBJECTPOINT + 149 +; set To 0 To disable session ID re-use For this transfer + Default is +; enabled (== 1) +#CURLOPT_SSL_SESSIONID_CACHE= #CURLOPTTYPE_LONG + 150 +; allowed SSH authentication methods +#CURLOPT_SSH_AUTH_TYPES= #CURLOPTTYPE_LONG + 151 +; Used by scp/sftp To do public/private key authentication +#CURLOPT_SSH_PUBLIC_KEYFILE= #CURLOPTTYPE_OBJECTPOINT + 152 +#CURLOPT_SSH_PRIVATE_KEYFILE= #CURLOPTTYPE_OBJECTPOINT + 153 +; Send CCC (Clear Command Channel) after authentication +#CURLOPT_FTP_SSL_CCC= #CURLOPTTYPE_LONG + 154 +; Same As TIMEOUT And CONNECTTIMEOUT + but With ms resolution +#CURLOPT_TIMEOUT_MS= #CURLOPTTYPE_LONG + 155 +#CURLOPT_CONNECTTIMEOUT_MS= #CURLOPTTYPE_LONG + 156 +; set To zero To disable the libcurl's decoding and thus pass the raw body +; Data To the appliction even when it is encoded/compressed +#CURLOPT_HTTP_TRANSFER_DECODING= #CURLOPTTYPE_LONG + 157 +#CURLOPT_HTTP_CONTENT_DECODING= #CURLOPTTYPE_LONG + 158 +; Permission used when creating new files And directories on the remote +; server For protocols that support it + SFTP/SCP/FILE +#CURLOPT_NEW_FILE_PERMS= #CURLOPTTYPE_LONG + 159 +#CURLOPT_NEW_DIRECTORY_PERMS= #CURLOPTTYPE_LONG + 160 +; CURLOPT_LASTENTRY ; the last unused +#CURLOPT_FTPLISTONLY = #CURLOPT_DIRLISTONLY +;} +;{ #HTTPPOST +#HTTPPOST_FILENAME = 1<<0 ; specified content is a file name +#HTTPPOST_READFILE = 1<<1 ; specified content is a file name +#HTTPPOST_PTRNAME = 1<<2 ; name is only stored pointer + ; do Not free in formfree +#HTTPPOST_PTRCONTENTS = 1<<3 ; contents is only stored pointer + ; do Not free in formfree +#HTTPPOST_BUFFER = 1<<4 ; upload file from buffer +#HTTPPOST_PTRBUFFER = 1<<5 ; upload file from pointer contents + ;} + +; #CURLE_OBSOLETE = #CURLE_OBSOLETE50 ; noone should be using this! +; #CURLE_BAD_PASSWORD_ENTERED = #CURLE_OBSOLETE46 +; #CURLE_BAD_CALLING_ORDER = #CURLE_OBSOLETE44 +; #CURLE_FTP_USER_PASSWORD_INCORRECT = #CURLE_OBSOLETE10 +; #CURLE_FTP_CANT_RECONNECT = #CURLE_OBSOLETE16 +; #CURLE_FTP_COULDNT_GET_SIZE = #CURLE_OBSOLETE32 +; #CURLE_FTP_COULDNT_SET_ASCII = #CURLE_OBSOLETE29 +; #CURLE_FTP_WEIRD_USER_REPLY = #CURLE_OBSOLETE12 +; #CURLE_FTP_WRITE_ERROR = #CURLE_OBSOLETE20 +; #CURLE_LIBRARY_NOT_FOUND = #CURLE_OBSOLETE40 +; #CURLE_MALFORMAT_USER = #CURLE_OBSOLETE24 +; #CURLE_SHARE_IN_USE = #CURLE_OBSOLETE57 +; #CURLE_URL_MALFORMAT_USER = #CURLE_OBSOLETE4 + +; #CURLE_FTP_ACCESS_DENIED = #CURLE_REMOTE_ACCESS_DENIED +; #CURLE_FTP_COULDNT_SET_BINARY = #CURLE_FTP_COULDNT_SET_TYPE +; #CURLE_FTP_QUOTE_ERROR = #CURLE_QUOTE_ERROR +; #CURLE_TFTP_DISKFULL = #CURLE_REMOTE_DISK_FULL +; #CURLE_TFTP_EXISTS = #CURLE_REMOTE_FILE_EXISTS +; #CURLE_HTTP_RANGE_ERROR = #CURLE_RANGE_ERROR +; #CURLE_FTP_SSL_FAILED = #CURLE_USE_SSL_FAILED + +; #CURLE_OPERATION_TIMEOUTED = #CURLE_OPERATION_TIMEDOUT + +#CURLE_HTTP_NOT_FOUND = #CURLE_HTTP_RETURNED_ERROR +#CURLE_HTTP_PORT_FAILED = #CURLE_INTERFACE_FAILED +; #CURLE_FTP_COULDNT_STOR_FILE = #CURLE_UPLOAD_FAILED + +#CURLE_FTP_PARTIAL_FILE = #CURLE_PARTIAL_FILE +#CURLE_FTP_BAD_DOWNLOAD_RESUME = #CURLE_BAD_DOWNLOAD_RESUME + +#CURLE_ALREADY_COMPLETE = 99999 + +#CURLAUTH_NONE = 0 ; nothing +#CURLAUTH_BASIC = 1<<0 ; Basic (Default) +#CURLAUTH_DIGEST = 1<<1 ; Digest +#CURLAUTH_GSSNEGOTIATE = 1<<2 ; GSS-Negotiate +#CURLAUTH_NTLM = 1<<3 ; NTLM +#CURLAUTH_ANY = ~0 ; all types set +#CURLAUTH_ANYSAFE = ~#CURLAUTH_BASIC + +#CURLSSH_AUTH_ANY = ~0 ; all types supported by the server +#CURLSSH_AUTH_NONE = 0 ; none allowed, silly but complete +#CURLSSH_AUTH_PUBLICKEY = 1<<0 ; public/private key files +#CURLSSH_AUTH_PASSWORD = 1<<1 ; password +#CURLSSH_AUTH_HOST = 1<<2 ; host key files +#CURLSSH_AUTH_KEYBOARD = 1<<3 ; keyboard interactive +#CURLSSH_AUTH_DEFAULT = #CURLSSH_AUTH_ANY + +#CURL_ERROR_SIZE = 256 + + +#CURLFTPSSL_NONE = #CURLUSESSL_NONE +#CURLFTPSSL_TRY = #CURLUSESSL_TRY +#CURLFTPSSL_CONTROL = #CURLUSESSL_CONTROL +#CURLFTPSSL_ALL = #CURLUSESSL_ALL +#CURLFTPSSL_LAST = #CURLUSESSL_LAST + +#CURLOPT_SSLKEYPASSWD = #CURLOPT_KEYPASSWD +#CURLOPT_FTPAPPEND = #CURLOPT_APPEND +#CURLOPT_FTPLISTONLY = #CURLOPT_DIRLISTONLY +#CURLOPT_FTP_SSL = #CURLOPT_USE_SSL + +#CURLOPT_SSLCERTPASSWD = #CURLOPT_KEYPASSWD +#CURLOPT_KRB4LEVEL = #CURLOPT_KRBLEVEL +; Below here follows defines for the CURLOPT_IPRESOLVE option. If a host +; name resolves addresses using more than one IP protocol version, this +; option might be handy to force libcurl to use a specific IP version. +#CURL_IPRESOLVE_WHATEVER = 0 ; Default, resolves addresses To all IP versions that your system allows +#CURL_IPRESOLVE_V4 = 1 ; resolve To ipv4 addresses +#CURL_IPRESOLVE_V6 = 2 ; resolve To ipv6 addresses + +; three convenient "aliases" that follow the name scheme better +#CURLOPT_WRITEDATA = #CURLOPT_FILE +#CURLOPT_READDATA = #CURLOPT_INFILE +#CURLOPT_HEADERDATA = #CURLOPT_WRITEHEADER +; CURLINFO_RESPONSE_CODE is the new name For the option previously known As +; CURLINFO_HTTP_CODE +#CURLINFO_HTTP_CODE = #CURLINFO_RESPONSE_CODE + +#CURL_GLOBAL_SSL = 1<<0 +#CURL_GLOBAL_WIN32 = 1<<1 +#CURL_GLOBAL_ALL = #CURL_GLOBAL_SSL|#CURL_GLOBAL_WIN32 +#CURL_GLOBAL_NOTHING= 0 +#CURL_GLOBAL_DEFAULT= #CURL_GLOBAL_ALL +;The 'CURLVERSION_NOW' is the symbolic name meant To be used by +; basicly all programs ever, that want To get version information. It is +; meant To be a built-in version number For what kind of struct the caller +; expects. If the struct ever changes, we rethe NOW To another enum +; from above. +#CURLVERSION_NOW = #CURLVERSION_FOURTH + +#CURL_VERSION_IPV6 = 1<<0 ;IPv6-enabled +#CURL_VERSION_KERBEROS4 = 1<<1 ;kerberos auth is supported +#CURL_VERSION_SSL = 1<<2 ;SSL options are present +#CURL_VERSION_LIBZ = 1<<3 ;libz features are present +#CURL_VERSION_NTLM = 1<<4 ;NTLM auth is supported +#CURL_VERSION_GSSNEGOTIATE = 1<<5; Negotiate auth support +#CURL_VERSION_DEBUG = 1<<6 ;built With Debug capabilities +#CURL_VERSION_ASYNCHDNS = 1<<7 ;asynchronous dns resolves +#CURL_VERSION_SPNEGO = 1<<8 ;SPNEGO auth +#CURL_VERSION_LARGEFILE = 1<<9 ;supports files bigger than 2GB +#CURL_VERSION_IDN = 1<<10 ;International Domain Names support +#CURL_VERSION_SSPI = 1<<11 ;SSPI is supported +#CURL_VERSION_CONV = 1<<12 ;character conversions are supported + +Structure Curl_HTTPPost + *Next_.Curl_HTTPPost ; Next entry in the list + *name.String ; Ptr to allocated name + namelength.l ; Length of name length + *contents.String ; Ptr to allocated data contents + contentslength.l ; Length of contents field + *buffer.String ; Ptr to allocated buffer contents + bufferlength.l ; Length of buffer field + *contenttype.String ; Content-Type + *contentheader ; List of extra headers for this form + *more.Curl_HTTPPost ; If one field name has more than one + ; file, this link should link To following files + flags.l ; constante #HTTPPOST + *showfilename ; The file name to show. If not set, the + ; actual file name will be used (If this + ; is a file part) +EndStructure + +; Structure To be used As parameter For CURLFORM_ARRAY +Structure Curl_Forms + option.l + *value.String +EndStructure + +; linked-list Structure For the CURLOPT_QUOTE option (And other) +Structure Curl_Slist + *Data.String + *Next_.curl_slist +EndStructure + +Structure curl_version_info_data + age.l ; age of the returned struct + *version.String ; LIBCURL_VERSION + version_num.l ; LIBCURL_VERSION_NUM + *host.String ; OS/host/cpu/machine when configured + features.l ; bitmask, see defines below + *ssl_version.String ; human readable string + ssl_version_num.l ; not used anymore, always 0 + *libz_version.String; human readable string + ; protocols is terminated by an entry With a NULL protoname + *protocols.String + ; The fields below this were added in CURLVERSION_SECOND + *ares.String + ares_num.l + ; This field was added in CURLVERSION_THIRD + *libidn.String; + ; These field were added in CURLVERSION_FOURTH + ; Same As '_libiconv_version' If built With HAVE_ICONV + iconv_ver_num.l + *libssh_version.String ; human readable string +EndStructure + +CompilerIf #PB_Compiler_OS = #PB_OS_Windows + ImportC "libcurl.lib" + curl_easy_cleanup(handle.i) + curl_easy_duphandle(handle.i) + curl_easy_getinfo(curl.i, info_type.i, info.i) + curl_easy_init() + curl_easy_perform(handle.i) + curl_easy_reset(handle.i) + curl_easy_setopt(handle.i, option.i, parameter.i) + curl_easy_strerror(errornum.i) + curl_escape(url.i, length.i) + curl_formadd(firstitem.i, lastitem.i) + curl_formfree(form.i) + curl_free(ptr.i) + curl_getdate(datestring.i, now.i) + curl_getenv(name.i) + curl_global_cleanup() + curl_global_init(flags.i) + curl_global_init_mem(flags.i, m.i, f.i, r.i, s.i, c.i) + curl_mprintf(format.i) + curl_mfprintf(fd.i, format.i) + curl_msprintf(buffer.i, format.i) + curl_msnprintf(buffer.i, maxlength.i, format.i) + curl_mvprintf(format.i, args.i) + curl_mvfprintf(fd.i, format.i, args.i) + curl_mvsprintf(buffer.i, format.i, args.i) + curl_mvsnprintf(buffer.i, maxlength.i, format.i, args.i) + curl_maprintf(format.i) + curl_mvaprintf(format.i, args.i) + curl_multi_add_handle(multi_handle.i, easy_handle.i) + curl_multi_cleanup(multi_handle.i) + curl_multi_fdset(multi_handle.i, read_fd_set.i, write_fd_set.i, exc_fd_set.i, max_fd.i) + curl_multi_info_read(multi_handle.i, msgs_in_queue.i) + curl_multi_init() + curl_multi_perform(multi_handle.i, running_handles.i) + curl_multi_remove_handle(multi_handle.i, easy_handle.i) + curl_multi_strerror(errornum.i) + curl_share_cleanup(share_handle.i) + curl_share_init() + curl_share_setopt(share.i, option.i, parameter.i) + curl_share_strerror(errornum.i) + curl_slist_append(slist.i, string.p-utf8) + curl_slist_free_all(slist.i) + curl_strequal(str1.i, str2.i) + curl_strnequal(str1.i, str2.i, len.i) + curl_unescape(url.i, length.i) + curl_version() + curl_version_info(type.i) + EndImport +CompilerElse + ImportC "-lcurl" + curl_easy_cleanup(handle.i) + curl_easy_duphandle(handle.i) + curl_easy_getinfo(curl.i, info_type.i, info.i) + curl_easy_init() + curl_easy_perform(handle.i) + curl_easy_reset(handle.i) + curl_easy_setopt(handle.i, option.i, parameter.i) + curl_easy_strerror(errornum.i) + curl_escape(url.i, length.i) + curl_formadd(firstitem.i, lastitem.i) + curl_formfree(form.i) + curl_free(ptr.i) + curl_getdate(datestring.i, now.i) + curl_getenv(name.i) + curl_global_cleanup() + curl_global_init(flags.i) + curl_global_init_mem(flags.i, m.i, f.i, r.i, s.i, c.i) + curl_mprintf(format.i) + curl_mfprintf(fd.i, format.i) + curl_msprintf(buffer.i, format.i) + curl_msnprintf(buffer.i, maxlength.i, format.i) + curl_mvprintf(format.i, args.i) + curl_mvfprintf(fd.i, format.i, args.i) + curl_mvsprintf(buffer.i, format.i, args.i) + curl_mvsnprintf(buffer.i, maxlength.i, format.i, args.i) + curl_maprintf(format.i) + curl_mvaprintf(format.i, args.i) + curl_multi_add_handle(multi_handle.i, easy_handle.i) + curl_multi_cleanup(multi_handle.i) + curl_multi_fdset(multi_handle.i, read_fd_set.i, write_fd_set.i, exc_fd_set.i, max_fd.i) + curl_multi_info_read(multi_handle.i, msgs_in_queue.i) + curl_multi_init() + curl_multi_perform(multi_handle.i, running_handles.i) + curl_multi_remove_handle(multi_handle.i, easy_handle.i) + curl_multi_strerror(errornum.i) + curl_share_cleanup(share_handle.i) + curl_share_init() + curl_share_setopt(share.i, option.i, parameter.i) + curl_share_strerror(errornum.i) + curl_slist_append(slist.i, string.p-utf8) + curl_slist_free_all(slist.i) + curl_strequal(str1.i, str2.i) + curl_strnequal(str1.i, str2.i, len.i) + curl_unescape(url.i, length.i) + curl_version() + curl_version_info(type.i) + EndImport +CompilerEndIf + +CompilerIf #PB_Compiler_OS = #PB_OS_Windows + ImportC "ws2_32.lib" + EndImport +CompilerEndIf + +; ProcedureC curlWriteData(*ptr, Size, NMemB, *Stream) +; ;retreives utf-8/ascii encoded data +; Protected SizeProper.i = Size & 255 +; Protected NMemBProper.i = NMemB +; Protected MyDataS.s +; ;Shared ReceivedData.s +; +; MyDataS = PeekS(*ptr, SizeProper * NMemBProper, #PB_UTF8) +; ReceivedData + MyDataS +; ProcedureReturn SizeProper * NMemBProper +; EndProcedure + +; Procedure.s curlGetData() +; ;Shared ReceivedData.s +; Protected ReturnData.s +; +; ReturnData.s = ReceivedData.s +; ReceivedData.s = "" +; +; ProcedureReturn ReturnData.s +; EndProcedure + +Procedure.s str2curl(string.s) + Protected *curlstring, newstring.s + *curlstring = AllocateMemory(Len(string) + 1) + If *curlstring + PokeS(*curlstring,string,-1,#PB_Ascii) + newstring = PeekS(*curlstring,-1) + FreeMemory(*curlstring) + ProcedureReturn newstring + Else + ProcedureReturn "" + EndIf +EndProcedure + + +; IDE Options = PureBasic 5.40 LTS Beta 5 (Windows - x86) +; EnableUnicode +; EnableXP +; EnableBuildCount = 0 +; IDE Options = PureBasic 5.42 LTS (Windows - x86) +; CursorPosition = 1031 +; FirstLine = 986 +; Folding = -- +; EnableUnicode +; EnableXP \ No newline at end of file