Alcinoe Component Library van Zeus64 is een open source bibliotheek met visuele en niet-visuele componenten voor Delphi.
Volledige OpenGL-videospeler, WebRTC Delphi-wrapper, native ios/android TEdit, verbeterde Firemonkey-bediening, Firebase-cloud-berichten, Android/ios Facebook SDK-login, Json/Bson Parser, ImageMagick-wrapper, MongoDB-client.
Alcinoe is compatibel met Delphi Rio 10.3.3 en Delphi Sydney 10.4.2
https://github.com/Zeus64/alcinoe
Met Delphi Alexandria 11.1 die MOD-download ondersteunt (verwijderd):
Alcinoe is nu volledig compatibel met Delphi Athene 12.3.
Installeer Alcinoe
Als u tijdens de ontwerpfase geen visuele componenten van Alcinoe wilt gebruiken, hoeft u niets te installeren. Voeg gewoon {alcinoe_rootdir}\source toe aan het zoekpad van uw project.
Als u van plan bent om tijdens de ontwerpfase visuele componenten te gebruiken, moet u de BPL installeren. Start Delphi en ga naar component > Pakketten installeren… > en kies de BPL in {alcinoe_rootdir}\lib\bpl\alcinoe\Win32\sydney\Alcinoe_sydney.bpl (als u zich in Delphi Sydney bevindt, kiest u anders de map die overeenkomt met uw Delphi-versie). U moet nog steeds {alcinoe_rootdir}\source toevoegen aan uw zoekpad
Alcinoe verbetert ook een beetje de originele Delphi-broncodes. Op deze manier moet u naar {alcinoe_rootdir}\embarcadero\sydney\10_4_2 gaan en update.bat uitvoeren om de originele Delphi-broncode op te halen en te patchen. Het batchbestand gaat ervan uit dat de originele broncode zich bevindt in “c:\Program Files (x86)\Embarcadero\Studio\21.0\source” en dat je GIT in je pad hebt. Nadat de batch is gekopieerd en gepatcht, moet de Delphi-broncode deze broncode opnemen in uw projectzoekpad.
Om het af te maken, gebruiken steeds meer bibliotheken Java 1.8-functies (zoals webRTC, exoplayer, enz.). Op deze manier moeten we desugaring uitvoeren (met desugaring kunt u deze functies op oudere apparaten gebruiken door nieuwe bytecodes en taal APIs te vervangen door oudere tijdens het bouwproces). Met d8.bat (vervanging van dx.bat) is het ontsuikeren standaard ingeschakeld. U kunt nu dus de meeste van de nieuwste taalwijzigingen gebruiken terwijl u zich richt op oudere apparaten. In afwachting van de overstap van Embarcadero naar D8.bat moeten we van DX.bat een “proxy” voor D8.bat maken. Vervang hiervoor gewoon uw originele DX.bat (de mijne bevindt zich in c:\SDKs\android\build-tools\30.0.3\d8.bat) door die in {alcinoe_rootdir}\tools\D8Proxy\dx.bat. meer details hier: https://quality.embarcadero.com/browse/RSP-24155
Volledige OpenGL-videospeler voor FireMonkey
ALVideoPlayer rendert een video naar een TEXTUUR. Dit is erg belangrijk omdat je de video volledig kunt integreren in het Delphi-formulier en je alle gewenste bedieningselementen erbovenop kunt plaatsen, aangezien deze Z-ORDER ondersteunt. De officiële Delphi-videospeler is slechts een native videospelervenster bovenaan het formulier en ondersteunt dus geen Z-ORDER.
Onder Android gebruik ik ExoPlayer. ExoPlayer ondersteunt functies zoals dynamische adaptieve streaming via HTTP (DASH), HLS, SmoothStreaming en Common Encryption, die niet worden ondersteund door MediaPlayer. Het is ontworpen om eenvoudig aan te passen en uit te breiden. Onder iOS gebruik ik AVPlayer met ondersteuning en ook HLS zoals ExoPlayer dat doet
videospeler voor FireMonkey videospeler voor FireMonkey videospeler voor FireMonkey
WebRTC Delphi-wrapper
WebRTC (Web Real-Time Communications) is een technologie waarmee webapplicaties en sites audio- en/of videomedia kunnen vastleggen en optioneel kunnen streamen, en willekeurige gegevens kunnen uitwisselen tussen browsers en mobiele applicaties zonder dat er een tussenpersoon nodig is. De set standaarden waaruit WebRTC bestaat, maakt het mogelijk om gegevens te delen en peer-to-peer teleconferenties uit te voeren, zonder dat de gebruiker plug-ins of andere software van derden hoeft te installeren.
De TALWebRTC-component maakt het eenvoudig om video- en audiochat aan uw applicaties toe te voegen, wat een geheel nieuwe wereld van interactiviteit opent
Delphi WebRTC-wrapper
Firemonkey native iOS/Android TEdit en TMemo
De bedoeling is om FireMonkey-besturing te combineren met native platformbesturing wanneer de functionaliteit van een dergelijke besturing erg moeilijk te implementeren begint te worden (zoals webbrowser, bewerken, memo, datumkiezer, enz.). Maar het is niet de bedoeling om verschillende aparte formulieren te maken voor verschillende platforms, zoals bijvoorbeeld http://www.turbococoa.com/ (maar deze optie is op de een of andere manier ook een goed alternatief, het is aan jou om te beslissen)
In Delphi (berlijn) is er al een IOS-platformbesturing die redelijk goed is geïmplementeerd, maar bijna geen Android-platformbesturing en dus begin ik native Android/iOS-besturingselementen te bouwen, zoals TEdit/TMemo. Deze besturingselementen werken grotendeels zoals sommige vensters die bovenaan het formulier zijn geplaatst (dus uiteraard geen z-volgorde met FireMonkey-besturingselementen)
Tekening Tekening
Tekening
Snelle/dubbelgebufferde FireMonkey-besturingselementen met native draw
Rechthoek
Cirkel
Tekst (kan ook HTML-tekst tekenen op iOS/Android/win/macOS)
Glyph
enz.
TALRechthoek
TALRechthoek
Het feit
Het schilderen van FireMonkey-besturingselementen kan soms langzaam zijn, of anders gezegd, niet snel genoeg voor vloeiend scrollen. Als u bijvoorbeeld eenvoudig de basisTRectangle met ronde hoeken bekijkt, kan het verfproces ongeveer 3 ms duren! Dus als je ongeveer 20 zichtbare TRectangles op je scherm hebt, dan kost het je ongeveer 60 ms om het volledige scherm opnieuw te schilderen (en normaal gesproken heb je niet alleen TRectangle, je hebt ook TLabel, TCheckbox, enz.). Nadat het alleen maar wiskunde is, neem je 100 ms om het scherm opnieuw te schilderen, zodat je slechts ongeveer 10 frames per seconde kunt doen (in werkelijkheid zul je veel minder gelijkmatig zijn), dus het scrollen kan niet vloeiend zijn 🙁
De oplossing
Ik wilde de FireMonkey-besturing niet opnieuw opbouwen, het is een te grote klus voor mij, en in plaats daarvan probeer ik een tussenoplossing te vinden. Dit is wat ik vind door de eigenschap "dubbel gebufferd" toe te voegen aan de FireMonkey-besturingselementen. Dus in plaats van de besturingselementen opnieuw te schilderen en opnieuw te schilderen (en opnieuw te schilderen) voor elke afzonderlijke pixelbeweging van de scrollbox, schilder ik eerst de besturing op een "buffer" die ik rechtstreeks in het GPU-geheugen opsla (via TTexture), en wanneer het systeem mij vraagt om de besturingselementen opnieuw te schilderen in plaats van het verfalgoritme opnieuw aan te roepen, teken ik eenvoudigweg de buffer TTexture opnieuw.
De resultaten
Zoals ik al eerder zei, duurde het 3 ms om een eenvoudige rechthoek met ronde hoeken te schilderen. Met mijn dubbelgebufferde eigenschap duurt het nu ongeveer 0,1 ms! Dus nu ziet de scroll er veel vloeiender uit!
OpenGL draw => Vervangen door native iOS/Android draw
De meeste basisvormen (zoals TRectangle, TCircle, enz.) gebruiken openGL om te tekenen. het is niet erg efficiënt. Als je bijvoorbeeld een cirkel tekent onder openGL, teken je in feite 50 driehoeken. Dit resultaat is vaak van slechte kwaliteit: https://quality.embarcadero.com/browse/RSP-15206 Voor roundrect is het nog erger omdat je eerst het pad moet berekenen en het later moet tekenen (veel langzamer dan TCircle)
Een ander probleem is dat al deze tekenen afhankelijk zijn van Form.quality. als je form.quality instelt op highquality, zal alles wat je op het canvas doet multisample zijn, zoals bijvoorbeeld het tekenen van een afbeelding, en dat kan problematisch zijn omdat de afbeelding anti-aliasing zal hebben. als je form.quality instelt op highperformance, zal de trekking erg ruw zijn (geen anti-aliasing).
Om dit op te lossen, bouw ik de buffer van mijn besturing met behulp van NATIVE ANDROID/IOS API. Op deze manier krijgen we een hoge kwaliteit trekking, ook op hoge snelheid, zonder afhankelijk te zijn van de vormkwaliteit
TALCirkel
Verbeterde FireMonkey-besturingselementen
ScrollBox
TabControl
BereikTrackBar
BereikTrackBar
videospeler voor FireMonkey videospeler voor FireMonkey videospeler voor FireMonkey
Confetti vallende animatie
ALConfetti is een standaard Delphi-bibliotheek voor het maken van een configureerbare, hoogwaardige vallende confetti-animatie.
confetti
Firebase-cloudberichten
Een platformonafhankelijke methode om Firebase Cloud Messaging (FCM) te gebruiken om pushmeldingen te ontvangen. Met FCM kunt u een client-app laten weten dat er nieuwe e-mail of andere gegevens beschikbaar zijn om te synchroniseren. U kunt meldingsberichten verzenden om de hernieuwde betrokkenheid en het behoud van gebruikers te stimuleren. Voor gebruiksscenario's zoals instant messaging kan een bericht een payload van maximaal 4 KB overbrengen naar een client-app.
Android/iOS VKontakte/Facebook SDK inloggen
Met VKontakte/Facebook SDK voor Android kunnen mensen zich bij uw app aanmelden met VKontakte/Facebook Login. Wanneer mensen zich aanmelden bij uw app met VKontakte/Facebook, kunnen zij toestemming geven aan uw app, zodat u namens hen informatie kunt ophalen of acties kunt uitvoeren op VKontakte/Facebook.
Foto-editorfilters voor Android/iOS
Met TALColorAdjustEffect maken prachtige fotofilters met automatische verbetering met één tik uw foto's in slechts enkele minuten mooi en expressief!
videospeler voor FireMonkey videospeler voor FireMonkey
Json-parser
TALJsonDocument is een Delphi-parser/schrijver voor JSON/BSON-gegevensformaat. het ondersteunt DOM en SAX parser (merk op dat een betere naam SAJ zou kunnen zijn voor Simple API voor JSON in plaats van SAX voor Simple API voor XML maar aangezien het concept van SAX bekend is, behoud ik deze naam), ondersteunt het BSON-formaat en gebruikt een vergelijkbare syntaxis dan TALXMLDocument / TXMLDocument. TALJsonDocument kan ook Json-/Bson-gegevens exporteren in TALStringList.
Als het gaat om het ontleden van bepaalde (tekstuele) inhoud, worden doorgaans twee richtingen overwogen. In de JSON-wereld moet je meestal een keuze maken tussen:
Een DOM-parser, die een in-memory boomstructuur van objecten creëert die de JSON-inhoud in kaart brengt;
Een SAX-parser, die de JSON-inhoud leest, roept vervolgens vooraf gedefinieerde gebeurtenissen aan voor elk JSON-inhoudselement.
In feite gebruiken DOM-parsers intern een SAX-parser om de JSON-inhoud te lezen. Daarom zijn DOM-parsers, met de overhead van het maken van objecten en het initialiseren van hun eigenschappen, doorgaans drie tot vijf keer langzamer dan SAX (en gebruiken ze veel meer geheugen om alle knooppunten op te slaan). Maar DOM-parsers zijn veel krachtiger in het verwerken van de gegevens: zodra deze zijn toegewezen aan native objecten, kan code binnen een mum van tijd toegang krijgen tot een bepaald knooppunt, terwijl een op SAX gebaseerde toegang de hele JSON-inhoud opnieuw moet lezen.
De meeste JSON-parsers die beschikbaar zijn in Delphi gebruiken een DOM-achtige aanpak. De DBXJSON-eenheid die sinds Delphi 2010 is opgenomen, of de SuperObject-bibliotheek, maken bijvoorbeeld een klasse-instantie die elk JSON-knooppunt in kaart brengt. Om de beste snelheid te bereiken, implementeert TALJsonDocument DOM-parser en ook een SAX-parser.
TALJsonDocument kan ook opmerkingen ondersteunen binnen de JSON-bron die een uitbreiding is op de JSON-specificaties
De syntaxis van TALJsonDocument lijkt sterk op TALXMLdocument / TXMLDocument
TALJsonDocument is beschikbaar in 2 varianten: TALJsonDocument dat bovenop ansiString wordt gemaakt (dus UTF-8) en TALJsonDocumentU dat bovenop een unicode-string wordt gemaakt (dus UTF-16)
Voorbeeld :
{
_id: 1, // opmerkingen
naam: {eerste: “John”, laatste: “Backus” },
geboorte: nieuwe datum(‘1999-10-21T21:04:54.234Z’),
bijdragen: [ “Fortran”, “ALGOL”, “Backus-Naur Form”, “FP” ],
onderscheidingen: [
{onderscheiding: “Nationale Medaille van de Wetenschap”,
jaar: 1975,
door: “Nationale Wetenschapsstichting” },
{ onderscheiding: “Turing-onderscheiding”,
jaar: 1977,
door: “ACM” }
],
echtgenoot: "",
adres: {},
telefoons: []
}
Om toegang te krijgen tot de documentknooppunten:
MyJsonDoc.loadFromJson(AJsonStr, False);
MyJsonDoc.ParseOptions := [poAllowComments]; // om opmerkingen binnen de JSON-bron toe te staan
MijnJsonDoc.childnodes[‘_id’].int32;
MyJsonDoc.childnodes[‘naam’].childnodes[‘eerste’].text;
MyJsonDoc.childnodes[‘naam’].childnodes[‘laatste’].text;
MyJsonDoc.childnodes[‘geboorte’].datetime;
for i:= 0 naar MyJsonDoc.childnodes[‘contribs’].ChildNodes.count – 1 doen
MyJsonDoc.childnodes[‘contribs’].childnodes[i].text;
for i:= 0 to MyJsonDoc.childnodes[‘awards’].ChildNodes.count – 1 begint
MyJsonDoc.childnodes[‘onderscheidingen’].childnodes[i].childnodes[‘onderscheiding’].text;
MyJsonDoc.childnodes[‘prijzen’].childnodes[i].childnodes[‘jaar’].text;
MyJsonDoc.childnodes[‘prijzen’].childnodes[i].childnodes[‘door’].text;
einde;
Of als u niet zeker bent van het bestaan van de knooppunten voordat u er toegang toe heeft, of als u deze niet wilt controleren, kunt u ook het volgende doen:
MyJsonDoc.GetChildNodeValueInt32(‘_id’, 0{standaard als knooppunt niet bestaat});
MyJsonDoc.GetChildNodeValueText([‘naam’,’eerste’], ”{standaard als knooppunt niet bestaat});
MyJsonDoc.GetChildNodeValueDateTime('geboorte', Now{standaard als knooppunt niet bestaat});
Om de documentknooppunten te maken:
MijnJsonDoc.addchild(‘_id’).int32 := 1;
met MyJsonDoc.addchild(‘name’, ntObject) beginnen
addchild(‘eerste’).text := ‘Jan’;
addchild(‘laatste’).text := ‘Backus’;
einde;
MyJsonDoc.addchild(‘geboorte’).dateTime := Nu;
met MyJsonDoc.addchild(‘contribs’, ntArray) beginnen
addchild.text := ‘Fortran’;
addchild.text := ‘ALGOL’;
addchild.text := ‘Backus-Naur-formulier’;
addchild.text := ‘FP’;
einde;
met MyJsonDoc.addchild(‘awards’, ntArray) beginnen
met addchild(ntObject) begin wel
addchild(‘onderscheiding’).text := ‘Nationale Medaille van de Wetenschap’;
addchild(‘jaar’).int32 := 1975;
addchild(‘door’).text := ‘Nationale Wetenschapsstichting’;
einde;
met addchild(ntObject) begin wel
addchild(‘prijs’).text := ‘Turing-prijs’;
addchild(‘jaar’).int32 := 1977;
addchild(‘door’).text := ‘ACM’;
einde;
einde;
MyJsonDoc.addchild(‘echtgenoot’);
MyJsonDoc.addchild(‘adres’, ntObject);
MyJsonDoc.addchild(‘telefoons’, ntArray);
U kunt knooppunten ook als volgt maken/bijwerken:
MyJsonDoc.SetChildNodeValueInt32(‘_id’, 0);
MyJsonDoc.SetChildNodeValueText([‘naam’,’eerste’], ‘John’);
MyJsonDoc.SetChildNodeValueDateTime('geboorte', nu);
Laden en opslaan vanuit BSON:
MyJsonDoc.LoadFromFile(aBSONFileName, False{saxMode}, True{BSON});
MyJsonDoc.SaveToFile(aBSONFileName, False{saxMode}, True{BSON});
Een JSON-document parseren in Sax-modus:
MyJsonDoc.onParseText := procedure (afzender: TObject;
const Pad: AnsiString;
const-naam: AnsiString;
const Args: array van const;
KnooppuntSubType: TALJSONNodeSubType)
beginnen
case NodeSubType van
nstFloat: Writeln(Pad + ‘=’ + ALFloatToStr(Args[0].VExtended^, ALDefaultFormatSettings));
nstText: Writeln(Pad + ‘=’ + ansiString(Args[0].VAnsiString));
nstObjectID: Writeln(Pad + ‘=’ + ‘ObjectId(“‘+ALBinToHex(ansiString(Args[0].VAnsiString))+'”)’);
nstBoolean: Writeln(Pad + ‘=’ + ALBoolToStr(Args[0].VBoolean,’true’,’false’));
nstDateTime: Writeln(Pad + ‘=’ + ALFormatDateTime(”’ISODate(“”jjjj”-”mm”-”dd”T”hh”:”nn”:”ss”.”zzz”Z”)”’, Args[0].VExtended^, ALDefaultFormatSettings));
nstNull: Writeln(Pad + ‘=’ + ‘null’);
nstRegEx: Writeln(Pad + ‘=’ + ansiString(Args[0].VAnsiString));
nstBinary: Writeln(Path + ‘=’ + ‘BinData(‘+inttostr(Args[1].VInteger)+’, “‘+ansiString(ALBase64EncodeStringNoCRLF(ansiString(Args[0].VAnsiString)))+'”)’);
nstJavascript: Writeln(Pad + ‘=’ + ansiString(Args[0].VAnsiString));
nstInt32: Writeln(Pad + ‘=’ + ‘NumberInt(‘+inttostr(Args[0].VInteger)+’)’);
nstTimestamp: Writeln(Pad + ‘=’ + ‘Tijdstempel(‘+inttostr(int64(kardinaal(Args[0].VInteger)))+’, ‘+inttostr(int64(kardinaal(Args[1].VInteger)))+’)’);
nstInt64: Writeln(Pad + ‘=’ + ‘NumberLong(‘+inttostr(Args[0].VInt64^)+’)’);
einde;
einde;
MyJsonDoc.LoadFromJSON(AJsonStr, true{saxMode});
ImageMagick-wrapper voor Delphi
Gebruik ImageMagick® om bitmapafbeeldingen te maken, bewerken, samenstellen of converteren. Het kan afbeeldingen lezen en schrijven in verschillende formaten (meer dan 200), waaronder PNG, JPEG, GIF, HEIC, TIFF, DPX, EXR, WebP, Postscript, PDF en SVG. Gebruik ImageMagick om afbeeldingen te vergroten of verkleinen, spiegelen, roteren, vervormen, schuintrekken en transformeren, afbeeldingskleuren aan te passen, verschillende speciale effecten toe te passen of tekst, lijnen, polygonen, ellipsen en Bézier-curven te tekenen.
Voorbeeld :
var aWand: PMagickWand;
beginnen
//Maak de ImageMagick-bibliotheek
alCreateImageMagickLibrary({alcinoe_rootdir} + ‘\lib\dll\imagemagick\win32\imagemagick’, min(2, System.CPUCount){aThreadLimit});
poging
//maak de toverstafaanwijzer
aWand:= ALImageMagickLib.NewMagickWand;
poging
//laad de afbeelding
if ALImageMagickLib.MagickReadImage(aWand, pansiChar(aInputFilename)) <> MagickTrue en vervolgens RaiseLastMagickWandError(aWand);
//Stel de compressiekwaliteit in
if ALImageMagickLib.MagickSetImageCompressionQuality(aWand,80) <> MagickTrue en vervolgens RaiseLastMagickWandError(aWand);
//autoriseer de afbeelding
als ALImageMagickLib.MagickAutoOrientImage(aWand) <> MagickTrue en vervolgens RaiseLastMagickWandError(aWand);
//Vergroot de afbeelding met het Lanczos-filter
if ALImageMagickLib.MagickResizeImage(aWand, 640, 480, LanczosFilter) <> MagickTrue en vervolgens RaiseLastMagickWandError(aWand);
// sla de afbeelding op
ALImageMagickLib.MagickWriteImage(aWand, pansiChar(aOutputBestandsnaam));
Eindelijk
ALImageMagickLib.DestroyMagickWand(aWand);
einde;
Eindelijk
alFreeImageMagickBibliotheek;
einde;
einde;
MongoDb-client
Delphi Client voor MongoDB-database. Een Delphi-stuurprogramma (met verbindingspool) voor toegang tot een mongoDB-server. een verbindingspool is een cache van databaseverbindingen die wordt bijgehouden zodat de verbindingen opnieuw kunnen worden gebruikt wanneer toekomstige verzoeken aan de database vereist zijn. Bij het poolen van verbindingen wordt een verbinding, nadat deze tot stand is gebracht, in de pool geplaatst en opnieuw gebruikt, zodat er geen nieuwe verbinding tot stand hoeft te worden gebracht. Als alle verbindingen worden gebruikt, wordt er een nieuwe verbinding gemaakt en aan de pool toegevoegd. Door het poolen van verbindingen hoeft de gebruiker ook minder lang te wachten voordat hij verbinding kan maken met de database.
Voorbeeld :
aJSONDoc := TALJSONDocument.create;
aMongoDBClient:= TAlMongoDBClient.create;
poging
aMongoDBClient.Connect(”, 0);
aMongoDBClient.SelectData(‘test.exemple’,
‘{fieldA:123}’, // de zoekopdracht
‘{fieldA:1, fieldB:1}’, // de selector voor retourvelden
aJSONdoc.node);
aMongoDBClient.disconnect;
for i:= 0 tot aJSONDoc.node.childnodes.count – 1 do
met aJSONDoc.node.childnodes[i] wel
writeln(aJSONDoc.node.childnodes[i].nodenaam + ‘=’ + aJSONDoc.node.childnodes[i].text)
Eindelijk
aMongoDBClient.free;
aJSONdoc.gratis;
einde;
Voorbeeld met aansluitpool:
aMongoDBConnectionPoolClient:= TAlMongoDBConnectionPoolClient.create(aDBHost, aDBPort);
poging
:: Draad1::
aMongoDBConnectionPoolClient.SelectData(‘test.voorbeeld’,
‘{fieldA:123}’, // de zoekopdracht
‘{fieldA:1, fieldB:1}’, // de selector voor retourvelden
aLocalVarJSONDOC.node);
:: Draad2::
aMongoDBConnectionPoolClient.SelectData(‘test.voorbeeld’,
‘{fieldA:999}’, // de zoekopdracht
‘{fieldA:1, fieldB:1}’, // de selector voor retourvelden
aLocalVarJSONDOC.node);
Eindelijk
aMongoDBClient.free;
einde;
Voorbeeld staartmonitoring:
aMongoDBTailMonitoringThread := TAlMongoDBTailMonitoringThread.Create(
aDBHost,
aDBPort,
‘test.cappedCollectionExemple’
‘{}’, // de zoekopdracht
‘{fieldA:1, fieldB:1}’, // de selector voor retourvelden
Procedure (afzender: TObject; JSONRowData: TALJSONNode)
beginnen
writeln(‘Nieuw item toegevoegd in cappedCollectionExemple: ‘ + JSONRowData.childnodes[‘fieldA’].text);
einde,
procedure (Afzender: TObject; Fout: Uitzondering)
beginnen
writeln(Foutbericht);
einde);
….
aMongoDBTailMonitoringThread.free;
WebSocket-client
WebSocket Client voor Delphi geïmplementeerd bovenop WinHTTP. De WebSocket is een communicatieprotocol dat het mogelijk maakt om een tweerichtingsinteractieve communicatiesessie te openen tussen de browser van de gebruiker en een server. Hiermee kunt u berichten naar een server sturen en gebeurtenisgestuurde reacties ontvangen zonder dat u de server om een antwoord hoeft te vragen.
Snelle TStringList
TALStringList Werkt hetzelfde als Delphi TStringList, behalve dat het mogelijk is om een naam=waarde te zoeken met behulp van een quicksort-algoritme wanneer de lijst is gesorteerd. Ook gebruikt TALStringList een locale-onafhankelijk algoritme (gebaseerd op de 8-bit ordinale waarde van elk teken) in plaats van de AnsiCompareText en AnsiCompareStr die worden gebruikt door de Delphi TStringList. uiteindelijk is het sorteren in TALStringList tot 10x sneller dan in Delphi TStringList. Ook is TALStringList geen Unicode TStringList maar een 100% Ansi StringList
TALNVStringList (NV voor NameValue) is hetzelfde als TALStringList (gebruik ook een quicksort-algoritme), behalve dat hier de optimalisatie is gericht op de naam/waardelijst in plaats van de tekenreekslijst.
TALHashedStringList TALHashedStringList is hetzelfde als TALStringList, behalve dat het een interne hashtabel gebruikt in plaats van een quicksort-algoritme. Door TALHashedStringList te gebruiken in plaats van TALStringList, kunt u de prestaties verbeteren wanneer de lijst een groot aantal tekenreeksen bevat (anders als uw lijst niet veel tekenreeksen bevat, zijn de prestaties lager dan die van TALStringList vanwege de kosten voor het berekenen van de hash)
PHP-loper
ALPHPRunnerEngine is een eenvoudige maar nuttige component voor het eenvoudig gebruiken van php (elke versie) als scripttaal in Delphi-applicaties. Met ALPhpRunnerEngine kunnen de PHP-scripts binnen het Delphi-programma worden uitgevoerd zonder een webserver. ALPHPRunnerEngine gebruikt de CGI/FastCGI-interface (php-cgi.exe) van PHP om te communiceren met de PHP-engine.
Gememoriseerde klant
Delphi Client voor opgeslagen database.
Wat is memcached? Gratis en open source, krachtig, gedistribueerd geheugenobjectcachingsysteem, generiek van aard, maar bedoeld voor gebruik bij het versnellen van dynamische webapplicaties door de databasebelasting te verlichten.
Memcached is een sleutel/waarde-opslag in het geheugen voor kleine stukjes willekeurige gegevens (tekenreeksen, objecten) uit resultaten van databaseaanroepen, API-aanroepen of paginaweergave.
Memcached is eenvoudig maar krachtig. Het eenvoudige ontwerp bevordert een snelle implementatie, gemakkelijke ontwikkeling en lost veel problemen op waarmee grote datacaches worden geconfronteerd.
GSM-component
De TAlGSMComm-component implementeert sms-berichten via de tekstmodusinterface die is gedefinieerd in de technische GSM-specificatie 07.05, versie 5.1.0, gedateerd december 1996. Er zijn verschillende varianten van deze specificatie, die worden gebruikt in modellen van Nokia, Siemens, Ericsson, enz. We hebben de Nokia 6230 in eigen huis getest, maar de modellen Nokia 7190, 8890, 6210 en 9110 zouden ook moeten werken. Telefoons van andere fabrikanten zullen ook werken, zolang ze de tekstmodusinterface implementeren. Ongeveer 1/4 van de huidige telefoons kan op een pc worden aangesloten (via IR of seriële kabel), ongeveer 1/3 daarvan is alleen in tekstmodus, 1/3 is alleen in PDU-modus en de andere 1/3 ondersteunt zowel tekst- als PDU-modus. Sommige telefoons (zoals de Nokia 5190) ondersteunen sms, maar gebruiken een eigen protocol dat TALGSMComm niet ondersteunt.
Om uw telefoon te testen, sluit u de telefoon aan op uw pc via de seriële kabel of het IR-apparaat (raadpleeg de documentatie van uw telefoon voor meer informatie over hoe u verbinding maakt). Voer “AT” in een terminalvenster in om te verifiëren dat de verbinding tot stand is gebracht (u zou “OK” van de telefoon moeten ontvangen) en voer vervolgens “AT+CMGF=?” in. Het antwoord moet een “1” bevatten, wat aangeeft dat het de tekstmodus ondersteunt. Als beide tests slagen, voldoet uw telefoon aan de basisvereisten.
SQLite3-client
Voer een query uit op de Sqlite3-database en ontvang het resultaat in XML-indeling of in Json/Bson-indeling.
En nog veel meer
CGI-loper
Http-client (WinInet/WinHTTP)
MySQL-client
NNTP-client
POP3-client
SMTP-client
XML-parser
WIN64
Helaas zijn we in win64 al het FastCode-erfgoed kwijtgeraakt. (dat was grotendeels gebaseerd op ASM). Dat betekent dat de meeste functies ongeveer 2x tot 10x langzamer zullen zijn. je kunt proberen /demo/ALStringBenchMark/ in win64 en Win32 te starten om het verschil in snelheid te zien.