Handbok Kommander
Copyright © 2008 Utvecklingsgruppen för Kommander
Härmed ges tillåtelse att kopiera, distribuera och/eller ändra detta dokument under villkoren i GNU Free Documentation License, Version 1.1 eller någon senare version publicerad av Free Software Foundation; utan invarianta avsnitt, utan framsidestexter och utan baksidestexter. En kopia av licensen inkluderas i avsnittet som heter "GNU Free Documentation License".
Denna dokumentation har varit delvis färdig under åratal, men inte alltid tillgänglig eller lätt att hitta. Från omkring 2002 har små ryck av arbete på Kommander producerat dramatiska resultat. Kommander är ett nytt sätt att utveckla, och det har förekommit ändringar i arbetssätt och funktioner. På grund av det är mycket av denna dokumentation föråldrad, men dock fortfarande användbar beroende på att stöd för gamla funktioner finns kvar. Se vår webbplats på http://kommander.kdewebdev.org för aktuell information, nyheter om utveckling för KDE 4, nya verktyg, insticksprogram, tips och handledningar.
Kommander är en samling verktyg som låter dig skapa dynamiska grafiska användargränssnitt med fönster, som har används till gränssnitt för kommandoradsprogram och databaser, enkla utökningar av program, med mera. Det bästa av allt? Det krävs inte att du skriver en enda kodrad! Nåja, det var den gamla beskrivningen ... Du kan faktiskt använda funktionsbläddraren och nästan inte skriva någon kod också med den nya tolken. Den inneboende skillnaden mellan Kommander och andra skriptverktyg för grafiska användargränssnitt är att Kommander inte bryr sig om hur fönstret ritas. Kommander skapades från det grafiska användargränssnittet ner till språkelementen, och kan anamma flera språk. Kommander använder inte skript för att rita upp ett fönster på skärmen som andra skriptverktyg för grafiska användargränssnitt. Allteftersom Kommander mognar, kommer alla interna funktioner exponeras för vilket skriptspråk man än vill aktivera. Vi välkomnar alla som vill förbättra stöd för något skriptspråk.
Innehållsförteckning
Kommander är ett verktyg för att bygga visuella dialogrutor som kan utökas för att skapa program med fullständiga huvudfönster, under förutsättning att fönstret från början skapas i Qt Designer eller från en mall i Kommander. Huvudsyftet är att skapa så mycket funktioner som möjligt med så liten användning av skriptspråk som möjligt. Det möjliggörs av följande funktioner:
Observera att dokumentet innehåller föråldrad dokumentation av kompatibilitetsorsaker. I korthet erbjuder Kommander mycket snabb utveckling med omfattande förmågor och möjligheter. Här följer en ny lista, och därefter det gamla innehållet.
Dugligt internt skriptspråk: Kommander erbjuder nu nästlade logiska strukturer, enkla fält och användbara funktioner.
Funktionsbläddrare: Man behöver aldrig veta den exakta syntaxen för någon funktion eller något kommando. Klicka bara på knappen, peka och klicka dig fram till ett funktionsprogram. Till och med projektledaren tycker det är enklare än stavfel nästan hela tiden.
Omfattande grafiska komponenter: Kommander har nu en grafisk träd- och detaljkomponent, kalkylarksliknande grafisk tabellkomponent, teckensnittsdialogruta, färgvalsdialogruta, dialogruta med programinformation, tidtagare, grafisk flikkomponent, verktygslåda, sammanhangsberoende menyer, datumväljare, med mera.
Insticksprogram: Kommander kan enkelt köras för att skapa insticksprogram. När detta skrivs är det insticksprogram för databaser som tillhandahåller en uppsättning icke-grafiska verktyg, ett HTTP-insticksprogram som tillhandahåller HTTPS och åtkomst till lösenordsskyddade områden, och en laddare av KPart-delprogram.
Stöd för skriptspråk: Möjlighet att köra flera olika skriptspråk i Kommander-skript, inne i dialogrutan.
Skapa KPart-delprogram: Möjlighet att skapa egna insticksprogram ... och ännu konstigare - man kan till och med få ett Kommander-fönster att ladda en dialogruta som ett KPart-delprogram och direkt komma åt den med funktioner i Kommander.
Se dokumentation med tips och trick om hur man får Kommander att verka använda programmeringstekniker som att inkludera en fil, skapa och använda egna grafiska komponenter, skapa hopfällbara rutor i fönster och andra trick man inte skulle förvänta sig. Nedan följer den gamla listan.
Specialvärden inleds med ett “@”, som @widgetText. De erbjuder specialfunktioner som en grafisk komponents värde, funktioner, alias, globala variabler och liknande.
Integrering med DCOP gör det möjligt för Kommander dialogrutor att styra och styras via kommunikation med andra KDE-program. Det är en mycket kraftfull funktion!
Signaler och slots är något mindre intuitivt för en ny användare. Hur saker behandlas är under granskning för den första huvudutgåvan. Dessa erbjuder en begränsad händelsemodell när en knapp trycks eller en komponent ändras. Kombinerat med “Ifyllnadstext” är det ganska kraftfullt.
Den centrala nyckelfunktionen i Kommander dialogrutor är att du kan koppla text (Kommander Text) till en grafisk komponent. Så om du har @komponent1 och @komponent2, och båda är radeditorer, kan du ställa in Kommander att visa innehållet genom att skriva @widgetText i deras Kommander textområde. Skriv därefter in "hello" i @komponent1 och "world" i @komponent2. En knapp kan ha strängen "Mitt första @komponent1 @komponent2 program" i Kommander. Om du kör dialogrutan från en terminal, skriver den ut "Mitt första hello world program" i Kommander.
Förhoppningsvis ser du nu en liten glimt av potentialen. Kommander möjliggör en mycket snabbare konstruktionsmodell för enkla program, eftersom det tillåter dig att sluta tänka så mycket på språket, och gå tillbaka till den mer grundläggande och naturliga begreppsmodellen. I datorer är ett språk ett sätt att definiera begrepp, och på så sätt är det ett lager mellan begrepp och implementering som kan hindra framsteg med petitesser. Kommander försöker att minimera detta lager.
Kommander försöker också bygga på standarder. Det är uppbyggt på ramverket i Qt™ Designer, och skapar *.ui-filer, som döps om till *.kmdr. Det kan enkelt importera vilken grafisk komponent från KDE som helst, och detta kan göras utan att behöva bygga om Kommander genom att använda insticksprogram.
Kommanders andra viktiga faktor är hur det möter kraven från språk. Datorspråk kan vara underbara ting, men de tenderar att ha sina egna dogmer och fanatiker försöker ofta bevisa framsteg i konstruktion av grafiska gränssnitt i en integrerad utvecklingsmiljö. Ironiskt nog är acceptansen av sådana integrerade utvecklingsmiljöer begränsad av antalet personer som är villiga att ta ett nytt språk i bruk för att få tillgång till en önskad funktion. Det är verkligen inte rimligt att förvänta sig att personer ska byta mellan dussintalet språk för att komma åt olika uppsättningar med funktioner. Genom att vara språkneutralt och tillåta att en Kommander dialogruta utökas av vilket skriptspråk som helst, positionerar sig Kommander på en unik plats för omfattande användning. Flera skriptspråk kan användas i en enda dialogruta och program kan tas över av personer som använder ett annat språk än den ursprungliga utvecklaren, och gradvis konverteras och utökas. Alla tillgängliga språk kan omedelbart dra nytta av nya grafiska komponenter och funktioner.
Vi hoppas att Kommander börjar få det stöd och erkännande från utvecklare som krävs för att uppnå potentialen det erbjuder. Vårt slutliga mål är att göra Kommander användbart för nybörjare för att utöka och sammanfoga deras program. Samtidigt bör det bli ett bra prototypverktyg. Det öppnar också dörren för möjligheter med öppen källkod på ett annat sätt. Vi vet att andra kan utöka våra GPL-program, men faktum kvarstår att mycket få har färdigheten. Med Kommander kan det antalet multipliceras enormt! Vissa program kan vara mest logiska som Kommander-program. Vi använder det redan för områden där vi vill ha möjlighet till utökningar i Quanta Plus.
Vi hoppas att du tycker om Kommander. Hjälp oss gärna med felrapporter och exempeldialogrutor, samt eventuella önskemål du har. Du kan gå med i vår användarlista för att få hjälp med att utveckla program för Kommander.
Vänliga hälsningar från utvecklingsgruppen för Kommander!
Kommander konstruerades ursprungligen baserat på ett enkelt begrepp som har visat sig vara i viss mån revolutionerande bland visuella designverktyg. Typiskt låter sådana verktyg dig skapa dialogrutor och kanske gränssnitt med huvudfönster. Ett gränssnitt med huvudfönster är huvudprogramfönstret som oftast har menyer, verktygsrader, statusrad och programområde. Dialogrutor är underordnade fönster som oftast inte har menyer och heter så eftersom deras syfte är att “utföra en dialog” eller utbyta information mellan dig och huvudprogrammet. Elementen i en dialogruta kallas för “grafiska komponenter”, och du kopplar ditt program till komponenterna. Kommander är annorlunda eftersom det i grunden är programmeringsfritt här. Det använder begreppet att associera text med de grafiska komponenterna i dialogrutan. Ursprungligen kallades detta “associerad text”, men nu kallas det “Kommander text”. Grafiska komponenter i Kommander dialogrutor kan inkludera innehållet i andra grafiska komponenter genom att referera till det, och en komponent kan referera till sitt eget innehåll med ett “Specialvärde” som ser ut så här: @widgetText. Specialvärden är kommandon med en speciell betydelse i Kommander. Om du skapade en dialogruta med två radeditorkomponenter och kallade den första “Förnamn” och den andra “Efternamn”, skulle du kunna skapa en knapp och ange dess Kommander text som “Mitt namn är @Förnamn @Efternamn”. Du skulle behöva ange @widgetText i komponenterna för förnamn och efternamn. Kommer du ihåg? Man måste tala om för Kommander att referera till texten i dem. Du skulle kunna köra det från en terminal och det skulle skriva ut strängen åt dig. Det skulle referera till förnamnet på följande sätt: @Förnamn -> hämta komponenten som heter Förnamn(@Förnamn) -> @widgetText -> hämta innehållet i radeditorkomponenten. I detta fall returnerar @Förnamn “Eric”.
Det är Kommanders enkla kärna. Vad du kan göra med det, är vad som är intressant. För det första är det värt att observera att jämfört med det vanliga angreppssättet i ett språkbaserat verktyg, behöver inte Kommander programsatser för att definiera operationerna. Det gör Kommander snabb för utvecklare. För slutanvändare är det mycket enklare än att lära sig språkkonstruktioner. För alla betyder det att det går att fokusera på uppgiften istället för att ständigt ha referensdokumentation tillhands. När någon stöter på ett verktyg som Kommander för första gången, är den vanliga frågan: “Var kan jag hitta en användning för det här häftiga verktyget?” I själva verket används behandling av strängar nästan var man än ser.
Vad kan Kommander alltså göra? Här är den renodlade listan med grundfunktionerna. Kommander kan:
Skicka strängar till det anropande programmet via standardutmatningen.
Anropa körbara program.
Använda DCOP för att kommunicera med KDE-program
Om du inte är en programmerare, kanske du vill ha det förklarat så en lekman förstår. I det första fallet, när du startar Kommander från en terminal, är terminalen det anropande programmet. Det finns ett förhållande mellan det anropande programmet och det skapade här. Att skicka ett meddelande till terminalen görs i det skapade programmet med standardutmatningen, som benämns så eftersom det också finns felutmatning. Detta är intressant eftersom vissa program, som Quanta Plus, använder standardutmatningen för att ta emot information från program som de startar. Så Kommander dialogrutor kan mata ut sina textsträngar direkt till editorn i Quanta Plus om de anropas från Quanta Plus. Det betyder att Kommander dialogrutor kan vara användbara utökningar för program.
Det andra fallet är att anropa ett körbart program. Alla program som kör på ditt system är körbara. Till och med ett skriptprogram körs av skriptets tolk, så tekniskt sett körs det också. Kommander kan köra kommandon precis som terminalen även om du kör från en meny. Så om du till exempel skulle vilja att det öppnade The GIMP, skulle du låta en knapp härleda strängen “gimp” och placera den i ett specialvärde så här: @exec(gimp). Med bara detta ser du att The GIMP startas när det används. Du skulle också kunna köra “ls -l”, men du skulle bara se utmatningen om du körde från en terminal.
Det tredje fallet är verkligen mycket intressant. DCOP är en förkortning av KDE:s Desktop COmmunication Protocol (protokoll för skrivbordskommunikation) och det är mycket kraftfullt. Ta och kör programmet kdcop och ta en titt. Du ser snabbt att alla KDE-program som följer standarden har saker på gång i DCOP, och de bra konstruerade har mycket på gång. Du kan begära alla typer av information i DCOP, samt ändra värden på grafiska komponenter med mera. Det finns ett avsnitt om hur DCOP används i den här handboken. Kommander kan skicka DCOP-anrop till alla KDE-program, samt styras från DCOP. I själva verket kan du skicka DCOP från kommandoraden till alla KDE-program. Så vad är vitsen med detta? Vitsen är att om du vill utföra en större mängd kommandon, inser du snart att DCOP från kommandoraden är tillräckligt för korta kommandon, men kan orsaka fördröjningar om det anropas flera hundra gånger från en snurra. Det är därför Kommander har ett @dcop specialvärde, eftersom det är ungefär 1000 gånger snabbare. Eftersom Kommander kan skicka och ta emot DCOP, kan DCOP användas för att styra Kommander. Det är därför det också finns ett specialvärde för lokal DCOP, @ldcop, som låter dig skriva betydligt mindre för att ge ett kommando.
Är det alla huvudbegrepp i Kommander? Nej, men det bör hjälpa dig att få en känsla för hur det fungerar, så att det som beskrivs inte ser ut som ett främmande språk för dig. Det finns några fler begrepp. Signaler och slots är sättet som Kommander hanterar händelser. En händelse i ett program betyder egentligen bara “något hände”, som att en grafisk komponent skapades eller dess text ändrades. Dessa ändringar “skickar ut signaler” och du kan ansluta signalerna till en mottagande slot som då utför något när händelsen inträffar. En användning av detta i Kommander är grannen till Kommander text, “Ifyllnadstext”. Ifyllnadstext fyller i en komponent när den anropas. Precis som Kommander text, kan ifyllnadstext innehålla textsträngar eller skript.
Det bör ha givit dig grundbegreppen för att kunna börja använda Kommander. Vi försöker hålla antalet specialvärden lågt, och vi använder DCOP i stor utsträckning. Idén är att vi vill hålla Kommanders styrka så konsekvent och strömlinjeformat som möjligt. Du kommer att märka att du kan inlemma vilket skriptspråk som helst i Kommander var du än behöver, och till och med flera skriptspråk i en dialogruta. Resten av informationen i det här dokumentet antar att du känner till begreppen och terminologin som presenterats här. Exemplen och handledningarna är också mycket användbara för att förstå vad som kan göras med Kommander.
Editorn är baserad på Qt™ Designer, ett verktyg för att konstruera och implementera användargränssnitt skapat av Trolltech. Vi har ändrat Qt™ Designer på följande sätt:
Dess gränssnitt är mycket enklare
Egna grafiska komponenter är inbyggda
Möjlighet att ange Kommander text är tillagd
Diverse andra ytliga ändringar
För de av er som redan är bekanta med att använda Qt™ Designer, är det trivialt att använda Kommander Editor.
Verktygsrader innehåller ett antal knappar för att ge snabb åtkomst till ett antal funktioner.
Filöversikten visar alla filer. Använd sökfältet för att snabbt byta mellan filer.
Objektutforskaren tillhandahåller en översikt över förhållandet mellan de grafiska komponenterna i ett formulär. Den är användbar för att markera grafiska komponenter i ett formulär med komplex layout.
Egenskapseditorn är platsen där den grafiska komponentens beteende och utseende ändras.
Dialogeditorn är stället där dialoger skapas och redigeras.
Skapar en ny dialogruta
Leta i filsystemet för att öppna en befintlig dialogruta.
Snabblista med de senaste filerna du har öppnad. Listan ändras varje gång du öppnar en fil som inte finns i den, och den äldsta filen försvinner först.
Stänger den aktiva dialogrutan
Sparar den aktiva dialogrutan
Sparar den aktiva dialogrutan med ett annat namn
Sparar alla öppna dialogrutor
Avslutar Kommander
Ångra den senaste åtgärden som utförts.
Gör om den senast ångrade åtgärden.
Klipp ut nuvarande objekt och placerar dess innehåll på klippbordet.
Kopiera nuvarande objekt till klippbordet.
Klistra in klippbordets innehåll på nuvarande markörposition.
Ta bort nuvarande objekt.
Markera alla objekt i nuvarande dialogruta.
Kontrollera att alla snabbtangenter bara används en gång.
Visar dialogrutan för att visa och redigera anslutningar.
Visar dialogrutan för formulärinställning.
Visar dialogrutan för inställningar.
Här listas alla grafiska komponenter i Kommander. Komponenterna är garanterat tillgängliga på alla system som kör samma (eller en senare) version av Kommander.
De grafiska komponenterna som tillhandahålls av insticksprogram kommer att anges under det här menyalternativet. Dialogrutorna som använder dessa grafiska komponenter kan bara köras om insticksprogrammet som tillhandahåller dem är installerat och inställt.
Stänger nuvarande dialogruta.
Stänger alla dialogrutor.
Titta på och ändra editorns snabbtangenter.
Lägg till eller ta bort insticksprogram för Kommander Editorn måste startas om efter ett nytt insticksprogram har lagts till.
Anpassa texteditorn som används för att ändra Kommandertext som hör ihop med grafiska komponenter.
Anpassa hur editorn ser ut och fungerar.
Startar KDE:s hjälpsystem med början på hjälpsidorna för Kommander (det här dokumentet).
Ändrar muspekaren till en kombination av en pil och ett frågetecken. Genom att klicka på objekt i Kommander öppnas ett hjälpfönster (om det finns ett för just det här objektet) som förklarar objektets funktion.
Öppnar dialogrutan för felrapportering där du kan rapportera ett fel eller lämna ett förbättringsförslag.
Det här visar information om version och upphovsmän.
Det här visar KDE:s version och annan grundläggande information.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Körprogrammet, som kallas kmdr-executor, kör Kommander skript. Det laddar .kmdr-filer och skapar dynamiskt en dialogruta med fullständig funktion.
Från och med version 1.3, varnar körprogrammet om skriptfilen inte är körbar. Det är en extra säkerhetsfunktion som försöker få användaren att tänka på de möjliga negativa konsekvenserna av att köra ett skript från en opålitlig källa. Användaren kan bekräfta att dialogrutan ska köras, eller om källan är pålitlig, kan skriptet göras körbart för att helt bli av med varningen.
Version 1.3 stöder inledningen med #!/sökväg/kmdr-executor i .kmdr-skriptfiler (ersätt sökväg med sökvägen till körprogrammet). Sådana filer, om de görs körbara, kan köras från kommandoraden precis som vilket annat körbart program som helst, utan behov att skicka skriptet till kmdr-executor som väljare.
Kom ihåg att när väl tecknen #! har lagts till i filens början, kan inte dialogrutan köras eller redigeras med äldre versioner av Kommander.
Den rekommenderade användningen är
#!/usr/bin/kommanderoch skapa en symbolisk länk från kmdr-executor till /usr/bin/kommander.
Teckenföljden #! kan läggas till i en dialogruta direkt från editorn, genom att ändra egenskaperna useShebang och shebang för huvuddialogrutan.
C++ utvecklare kan enkelt använda klassen Instance i sina C++ program, så att körfunktionerna är inbäddade i deras program, vilket gör det överflödigt att köra det externa programmet executor. För vanliga dialogrutor är den extra tid det tar att skapa dialogrutan minimal, men att skapa KDE-programmet kan fördröja dialogrutan omkring en sekund.
En annan metod är att använda kommander_part KReadOnlyPart. Detta KPart-delprogram kan ladda och köra vilken Kommander-dialogruta som helst inne i ett annat KDE-program.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
För att lära dig hur en dialogruta skapas, hur grafiska komponenter läggs till, hur en layout används, och hur komponentegenskaper ändras, titta i handboken för Qt™ Designer (version 3.x). Du kan komma åt den genom att köra designer från kommandoraden eller skrivbordsmenyn.
Extrafunktionen som Kommander erbjuder är Kommander Text som hör ihop med varje grafisk komponent. Texterna är den körbara delen av dialogrutan (skriptet), antingen skriven på ett skriptspråk (med den gamla Kommander-syntaxen) eller med det interna Kommander-språket, den så kallade nya tolken.
För att lära dig mer om språksyntax, kommandon och hur texteditorn används, läs följande kapitel och ta en titt på exemplen som levereras med Kommanders källkod.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Av säkerhetsskäl introducerade vi kravet på körbar bit i version 1.3. Vissa kommer att ge sitt bifall till detta, som sedan länge förväntat. Andra kommer att anse att det är hemskt irriterande, eller till och med för skrämmande för att använda. Problemet är att man kan ladda ner en Kommander-dialogruta var som helst, eller få en med e-post, och klicka på den och köra den av misstag. Eftersom Kommander kan köra skalskript har det på sätt och vis en ovanlig ställning. Medan andra program inte besvärar dig på detta sätt, var du faktiskt tvungen att installera dem, och alltså känner du dig säker och har för avsikt att köra dem. En enda rad i ett skalskript skulle kunna radera din hemkatalog permanent. Vår avsikt är att eliminera möjligheten att klicka på en opålitlig dialogruta av misstag. Vi ber om ursäkt för eventuella olägenheter, men det finns inget sätt att göra detta så att till och med utvecklaren är övertygad om att det inte irriterar dig medan du förblir säker.
Du förhindras inte att köra dialogrutan, utan blir bara påmind. Du kan få påminnelsen att försvinna genom att använda filhanteraren eller ett skal för att sätta den körbara biten. Högerklicka på dialogrutan i Konqueror, välj egenskaper i menyn, välj fliken Skydd och markera kryssrutan “Körbar”. Nu försvinner påminnelsen från dialogrutan för alltid. Titta på vår webbplats efter ett verktyg som söker efter Kommander-dialogrutor, låter dig granska dem, och välja om någon eller alla ska ha biten satt. Använd följande kommando för att göra alla Kommander-dialogrutor i en katalog körbara i en terminal:
chmod u+x *.kmdr
Ställ inte in dialogrutor som körbara om du inte är säker på deras ursprung.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Byggblocken i en Kommander dialogruta är de grafiska komponenterna. De är som alla andra grafiska komponenter i Qt™- och KDE-biblioteken, utom att de har en del extra funktioner som möjliggör att de har en “textassociation”. Text associeras med ett tillstånd hos den grafiska komponenten eller dess ifyllnadslot. Antal tillstånd beror på den grafiska komponenten. Om en komponent bara har ett tillstånd, kallas det förvalt.
Huvuddialogrutan har två specialtillstånd för Kommander text. De är Initialization och Destroy. De körs när dialogrutan initieras och när den förstörs. Dessa skyddar mot vad som är känt som “kapplöppningsproblem” vid öppning, och betyder att du inte behöver några speciella procedurer vid stängning för att hantera underhåll.
I fallet när ett program baserat på ett huvudfönster (skapat med Qt™ Designer) används, finns det inte tillstånden Initialization och Destroy, instället kan signalerna initialize och destroy användas för att få information om när programmet skapas eller stängs.
Nedan är Kommanders grafiska standardkomponenter. Var och en av dem har ett stort antal funktioner. Du kan ta reda på dem genom att titta på komponentfunktionerna i funktionsbläddraren. Många har dessutom signaler och slots. Dokumentation om dessa metoder finns i dokumentationen av programmeringsgränssnittet för Qt™ och KDE. Varje Kommander-komponent har en anmärkning om dess baskomponent.
Etikett En enkel grafisk komponent som innehåller en text. Komponenten låter dig också använda en punktavbildning.
Se dokumentationen av QLabel för att ta reda på mer om textetiketter i Qt™.
Punktavbildningsetikett En enkel grafisk komponent som innehåller en bild eller text. Punktavbildningen som ska visas anges i egenskapen pixmap. Texten anges i textegenskapen. Bara en av dessa egenskaper kan anges samtidigt (Tror jag. Jag kan inte få editorn att ange båda samtidigt). Om scaledContents sätts till true, skalas bilden så att den motsvarar den grafiska komponentens storlek. Textformatet kan anges med egenskapen textFormat.
Se dokumentationen av QLabel för att ta reda på mer om textetiketter i Qt™.
Radeditor En radeditorkomponent är enraders texteditor. Den låter användaren skriva in och ändra en enda textrad. Ursprunglig text för editorn kan anges med textegenskapen. Komponenten kan ställas in till enbart läsbar med egenskapen readOnly. Det finns tre lägen för komponenten, Normal, NoEcho och Password. Läget anges med egenskapen echoMode.
Radeditorn har ett tillstånd, det förvalda.
Komponenttexten för radeditorn är texten som finns i editorn.
Se dokumentationen av KLineEdit för att ta reda på mer om textetiketter i KDE.
Texteditor En enkel flerraders texteditor.
Se dokumentationen av KTextEdit för att ta reda på mer om flerraders texteditorer i KDE.
Textbläddrare En enkel bläddrare för rik text med hyperlänknavigering.
Se dokumentationen av KTextBrowser för att ta reda på mer om den.
Listruta En listruta tillhandahåller en lista med objekt som kan markeras. Normalt är ett eller inget element markerade. Beteendet kan ändras med egenskapen selectionMode. Objekt läggs till i listrutan genom att använda redigeringsfönstret.
En listruta har bara ett tillstånd, det förvalda.
Komponenttexten för en listruta är objekten som finns i listrutan. @selectedWidgetText returnerar bara de objekt som för närvarande är markerade.
Se dokumentationen av KListBox för att ta reda på mer om den.
Kombinationsruta Kombinationsruta är urvalskomponent som kombinerar en knapp och en meny. Den visar användarens nuvarande val i en lista med alternativ på minsta möjliga utrymme. Objekt läggs till i listan genom att använda redigeringsfönstret. Om egenskapen editable sätts till true, kan användaren skriva in godtyckliga strängar.
En kombinationsruta har ett tillstånd, det förvalda.
Komponenttexten för en kombinationsruta är texten i det valda objektet.
Se dokumentationen av KComboBox för att ta reda på mer om den.
Trädkomponent En komponent som tillhandahåller en lista i form av en trädstruktur. Man kan lägga till underobjekt och flerkolumnsdata. Nuvarande begränsning är att man inte kan ändra kolumner. För att lägga till ett underobjekt använd “/” som avskiljare. För att lägga till kolumndata använd tabulatortecknet “\t” mellan kolumner.
Se dokumentationen av KListView för att ta reda på mer om den.
Tabell En tabellkomponent som stöder olika grafiska komponenter i sina celler.
Se dokumentationen av QTable för att ta reda på mer om den.
Körknapp En knapp som kör sin associerade text när den klickas. Knappens rubrik ställs in med textegenskapen. Utmatning från textassociationen (hur säger man) ekas till standardutmatningen om egenskapen writeStdout sätts till true. Knappen kan vara dialogrutans standardåtgärd om egenskapen default sätts till true.
Körknapp har ett tillstånd, det förvalda.
Det finns inte någon komponenttext som hör till en körknapp.
Se dokumentationen av KPushButton för att ta reda på mer om den.
Stängknapp En knapp som kör sin associerade text när den klickas och därefter stänger dialogrutan. Knappens rubrik ställs in med textegenskapen. Utmatning från textassociationen (hur säger man) ekas till standardutmatningen om egenskapen writeStdout sätts till true. Knappen kan vara dialogrutans standardåtgärd om egenskapen default sätts till true.
En stängknapp har ett tillstånd, det förvalda.
Det finns inte någon komponenttext som hör till en stängknapp.
Se dokumentationen av KPushButton för att ta reda på mer om den.
Konsol En grafisk komponent som visar utmatningen från skript i en textbläddrare. Förvalt tillstånd körs, och utmatningen från dessa kommandon (interna och externa) visas i komponenten.
Filväljare Den grafiska komponenten filväljare kombinerar en radeditor med en knapp, som när den klickas visar användaren en dialogruta för att välja filer eller kataloger. Filen eller katalogen som väljes lagras i radeditorn. Filväljarens typ anges med egenskapen selectionType. Tillgängliga typer är Open, Save och Directory. Flera filer eller kataloger kan väljas om egenskapen selectionOpenMutliple sätts till true. En rubrik för filväljaren kan anges med egenskapen selectionCaption. Den visas i dialogrutans namnlist. Om en rubrik inte anges, visas väljarens typ i rubriken. Filerna som visas i dialogrutan kan begränsas med egenskapen selectionFilter.
Filväljaren har ett tillstånd, det förvalda.
Komponenttexten för en filväljare är texten som finns i radeditorn (filen som valts av användaren).
Kryssruta En knapp som kan markeras eller avmarkeras. Den kan också vara halvmarkerad om egenskapen tristate sätts till true. Rubriken som hör ihop med kryssrutan ställs in med textegenskapen. Sätts egenskapen checked, är kryssrutan markerad från början.
En kryssruta har tre tillstånd, markerad, halvmarkerad och omarkerad.
Komponenttexten för en kryssruta är värdet på egenskapen text.
Se dokumentationen av KCheckBox för att ta reda på mer om den.
Tryckknapp En knapp som kan markeras eller avmarkeras, som oftast används i en knappgrupp för att göra ett alternativval. En rubrik som hör ihop med knappen kan anges i textegenskapen. En knapp kan initieras som markerad genom att sätta egenskapen checked till true. Om alla alternativknappar i en knappgrupp har egenskapen checked satt till true, är det den sista knappen som blir markerad.
Alternativknappen har två tillstånd, markerad och omarkerad.
Det finns inte någon komponenttext som hör till en alternativknapp.
Se dokumentationen av KRadioButton för att ta reda på mer om den.
Knappgrupp En omslutande komponent för att organisera knappar i grupper. En valfri rubrik kan anges med egenskapen title. Ramen kan justeras med egenskapen lineWidth. Knappgruppen kan ställa in för alternativval genom att sätta egenskapen exclusive till true. Det betyder att om en växlande knapp klickas, avmarkeras alla andra växlande knappar med undantag för alternativknappar som alltid är ömsesidigt uteslutande även om gruppen inte är inställd för alternativval. Alternativknappar kan ställas in att inte använda alternativval med egenskapen radioButtonExclusive (Jag är inte helt säker på att egenskapen verkligen fungerar).
Knappgrupp har ett tillstånd, det förvalda.
Komponenttexten för en knappgrupp är texten som hör ihop med var och en av knapparna i den ordning de syns i knappgruppen.
Gruppruta En omslutande grafisk komponent som innehåller andra komponenter. Ramen kan justeras med egenskapen lineWidth. En rubrik kan läggas till genom att ange rubrikegenskapen.
Grupprutan har ett tillstånd, det förvalda.
Komponenttexten för grupprutan är de kombinerade textassociationerna för var och en av komponenterna som den innehåller. De är i den ordningen de syns i grupprutan.
Flikkomponent En grafisk komponent som tillhandahåller flera flikar, där var och en kan innehålla andra grafiska komponenter.
Se dokumentationen av KTabWidget för att ta reda på mer om den.
Nummerinmatningsruta En komponent som låter användaren ändra ett heltalsvärde genom att antingen trycka på uppåt- och neråtpilar eller skriva in ett värde i rutan. Minimum- och maximumvärden kan ställas in med egenskaperna minValue och maxValue. Egenskapen specialValueText används för att ange ett textvärde som visas istället för minimumvärdet.
Den här grafiska komponenten har bara ett tillstånd, det förvalda.
Komponenttexten för nummerinmatningsrutan är heltalet som för närvarande visas.
Se dokumentationen av QSpinBox för att ta reda på mer om den.
Skjutreglage En grafisk komponent som tillhandahåller ett horisontellt eller vertikalt skjutreglage.
Se dokumentationen av QSlider för att ta reda på mer om den.
Rik texteditor Den här grafiska komponenten tillhandahåller en texteditor som tillåter enkel textformatering.
Rik texteditor har ett tillstånd, det förvalda.
Komponenttexten för Rik texteditor är texten som finns i editorn med rik-textformat. Markerad text kan returneras med @selectedWidgetText.
Statusrad En grafisk komponent för att visa statusinformation, oftast använd längst ner i dialogrutor.
Se dokumentationen av KStatusBar för att ta reda på mer om den.
Förloppsrad En grafisk komponent för att visa förloppsinformation.
Se dokumentationen av KProgress för att ta reda på mer om den.
Skriptobjekt Detta är en pseudokomponent. Den visas inte när dialogrutan körs. Den kan betraktas som en funktion. Ett skriptobjekt innehåller kod som kan köras när som helst från dialogrutan genom att anropa funktionen execute. Argument kan skickas till skriptobjektet med metoden ovan och kommas åt inne i skriptobjektet som @Self.item(0), @Self.item(1), etc. med den gamla stilens tolk, eller Self.item(0, Self.item(1), etc. med den nya tolken.
Signaler kan dessutom anslutas till funktionen execute, eftersom den också fungerar som en slot.
Tidtagare Detta är en pseudokomponent. Den visas inte när dialogrutan körs. Den kan användas för att utföra en åtgärd en gång efter en angiven tid, eller regelbundet. Ställ in tidsgränsen interval i millisekunder, välj om den ska köras en gång (singleShot) eller inte. Anslut signalen timeout till en slot, som kommer att köras när den angivna tiden har gått ut.
Tidtagningen startas inte av sig själv. Kör funktionen execute för att starta den.
Se dokumentationen av QTimer för att ta reda på mer om den.
Datumväljare En grafisk komponent använd för att välja ett datum. Förvalt datum kan ställas in med egenskapen date eller med funktionen setText med ISO-format: ÅÅÅÅ-MM-DD.
Komponenttexten för är datumet som för närvarande visas.
Se dokumentationen av KDatePicker för att ta reda på mer om den.
Nytt i Kommander 1.3.
Om-dialogruta Detta är en pseudokomponent. Den visas inte när dialogrutan körs. Den lagrar information om programmet, upphovsmannen och licensen. Den visar om-dialogrutan när funktionen execute anropas.
Funktionen initialize måste anropas innan någonting annat, inklusive funktionen execute.
Nytt i Kommander 1.3.
Teckensnittsdialogruta En pseudokomponent som kan användas för att visa en dialogruta för att välja teckensnitt. Förvalt teckensnitt kan ställas in med funktionen setFont, och det valda teckensnittets egenskaper hämtas med funktionerna family, pointSize, bold, italic. Dialogrutan visas när funktionen execute anropas.
Nytt i Kommander 1.3.
Sammanhangsberoende meny En pseudokomponent som kan användas för att visa en meny. Använd funktionerna insert... för att lägga till menyalternativ. Så fort användaren klickar på ett menyalternativ, körs funktionen execute i den angivna executeWidget. Det är möjligt att ansluta menyalternativ till den sammanhangsberoende menyns egen execute-funktion, vilket leder till att texten som är tilldelad tillståndet default körs. När menyalternativ läggs till kan du tilldela dem ett index, och hantera alla objekt i en meny i menykomponenten, eftersom en begäran skickar tillbaka detta index. För att se hur det fungerar, titta på det aktuella exemplet keyvaluecombo.kmdr.
Använd popup för att visa menyn. Oftast ansluts den till signalen contextMenuRequested i en annan komponent.
En meny kan innehålla andra sammanhangsberoende undermenyer.
Nytt i Kommander 1.3.
Verktygslåda En omslutande komponent, liksom flikkomponenten. Den har flera sidor, där varje sida kan innehålla andra komponenter.
Komponenten har ett fel i editorn, som inte påverkar dess användning vid körning, men påverkar dess användning i editorn. Om du försöker lägga till sidor i editorn blir den oläsbar. Gör inte det. Om du vill använda verktygslådan, fyll i komponenten i farten med kommandot addWidget. Om det finns tid, kommer ett exempel läggas till i utgåva 1.3, titta annars på webbplatsen.
Se dokumentationen av QToolBox för att ta reda på mer om den.
Nytt i Kommander 1.3.
Specialvärden är funktioner som behandlas av Kommander. Du bör vara medveten om att när den gamla tolken används, utförs alla Kommander specialvärden först och därefter körs skriptet. I det flesta fall är det inte något problem, men i några enstaka fall (särskilt i snurror och villkor) kan det vara det.
Listan nedan kan vara något föråldrad. Du rekommenderas att använda funktionsbläddraren för att få hjälp om tillgängliga funktioner. Funktionsbläddraren kan nås inne i editorn Kommander Text, genom att klicka på knappen Funktion....
@dcop(pgmId, objekt, funktion, argument)Gör ett DCOP-anrop, @dcop(“kmail”, “KMailIface”, “checkMail()”, “”)
@dcopidDCOP-id för processen (kmdr-executor-@pid)
@dialog(dialogruta[,parametrar])Startar angiven Kommander dialogruta. Dialogrutan letas efter i katalogen med dialogrutor och i arbetskatalogen, i den ordningen. Det här lägger till anropet till Executor i början och ändrar standardkatalog till den som Kommander programmet finns i. Parametrar kan skickas som vanligt i Unix, eller så kan namngivna parametrar som “variabel=värde” skickas. Därefter hittar du skickade parametrar i den globala uppsättningen. @global(variabel) skulle returnera “värde”.
@env(miljövariabel)Ersätts med den angivna miljövariabeln. @env(PWD) ersätts med $PWD. Kom ihåg att “$” ingår i skalet, och ska inte användas.
@exec(kommando)Returnerar utmatningen från körningen av det angivna kommandot. @exec(ls -l).
@execBegin ... @execEndSamma som @exec, men stöder inledning med "#!" och skript med flera rader. Det fungerar med diverse skriptspråk antingen genom att deklarera dem eller genom att använda "#!".
@execBegin(php)
@execBegin(#!/usr/bin/php)
Det första exemplet använder namnet på det körbara programmet PHP. Kommander söker i PATH efter php och om det inte hittas kontrollerar om det är registrerat i Kommander på en plats som inte finns i sökvägen. Om inte får användaren reda på att det inte kan hittas. Det andra exemplet använder den klassiska inledningen “!#”, som både kan ha fördelar men också problem. Om du till exempel har en betaversion av PHP5 i /usr/local/bin hittas den inte eftersom en annan hittas i /usr/bin, är det användbart. Om du dock distribuerar dialogrutan till någon som bara har PHP i /usr/local/bin hittas den inte med inledningen som används. Alltså varnas för att använda en inledning, och det rekommenderas att använda det körbara namnet om du delar filer.
@global(variabel)Ersätts med värdet på den angivna globala variabeln.
@nullReturnerar null. Nu när Kommander kontrollerar om widgetText är tom vid körning, förhindrar detta felaktiga fel med fallet då en grafisk komponent har ett tillstånd som inte är angivet.
@parentPidProcess-id för överliggande process.
@pidProcess-id för processen.
@readSetting(nyckel, förvalt värde)Läser ett värde från kommanderrc. Se också @writeSetting.
@selectedWidgetTextDet markerade innehållet i en grafisk komponent som kan visa mer än ett värde, som listkomponenter.
@setGlobal(variabel, värde)Tilldelar den globala variabeln det angivna värdet.
@widgetTextInnehållet i en grafisk komponent.
@writeSetting(nyckel, värde)Skriv värde till kommanderrc. Alla Kommander-dialogrutor delar samma kommanderrc-fil, och var och en har sin egen sektion i den.
@Array.values(fält)Returnerar en lista åtskild med nyrader med alla värden i fältet. Kan användas för att gå igenom ett fält.
@Array.keys(fält)Returnerar en lista med alla nycklar i fältet åtskilda med nyrader.
@Array.setValue(fält, nyckel, värde)Anger en nyckel och värde för ett element i ett fält. Om fältet inte finns, skapas det.
@Array.clear(fält)Ta bort alla element från fältet.
@Array.count(fält)Returnera antal element i fältet.
@Array.value(fält,nyckel)Returnera värdet som hör ihop med den givna nyckeln.
@Array.remove(fält,nyckel)Ta bort elementet med den givna nyckeln från fältet.
@Array.fromString(fält,sträng)Lägger till alla element i strängen till fältet. Strängen ska har formatet nyckel\tvärde\n.
@Array.toString(fält,sträng)Returnerar alla element i fältet på formatet nyckel\tvärde\n.
@File.read(fil)Returnera innehållet i den givna filen.
@File.write(fil,sträng)Skriv given sträng till en fil.
@File.append(fil,sträng)Skriv given sträng i slutet på en fil.
@String.length(sträng)Returnera antalet tecken i strängen.
@String.contains(sträng,delsträng)Kontrollera om strängen innehåller en given delsträng.
@String.find(sträng)Returnera en delsträngs position i strängen, eller -1 om den inte hittas.
Det här kommer att ha ett valfritt heltal med startposition, för användning för att söka igen i version alfa 6.
@String.left(sträng, heltal)Returnerar de första n tecknen i strängen.
@String.right(sträng, heltal)Returnerar de sista n tecknen i strängen.
@String.mid(sträng, heltal start, heltal slut)Returnerar en delsträng av strängen, med början på angiven position.
@String.remove(sträng, delsträng)Ta bort alla förekomster av en given delsträng.
@String.replace(sträng, delsträng sök, delsträng ersätt)Ersätt alla förekomster av en given delsträng med en given ersättning.
@String.upper(sträng)Konvertera strängen till stora bokstäver.
@String.lower(sträng)Konvertera strängen till små bokstäver.
@String.compare(sträng, sträng)Jämför två strängar. Returnera 0 om de är lika, -1 om den första är tidigare, 1 om den första är senare.
@String.isEmpty(sträng)Kontrollera om strängen är tom.
@String.isNumber(sträng)Kontrollera om strängen är ett giltigt tal.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Kommander började med att komma åt grafiska komponenter internt med DCOP, vilket utvecklades till komponentfunktioner. DCOP är fortfarande tillgängligt och kan användas för att dela information mellan dialogrutor. Det kan också användas för att utöka och integrera nästan alla befintliga KDE-program. DCOP kan anropas på flera sätt i Kommander. Det första är terminalmetoden. Öppna en Kommander-dialogruta och en terminal, och pröva det här.
Detta är till största delen fokuserat på den gamla tolken. Om du letar efter interna grafiska komponentfunktioner, se den nya tolken. Informationen här är särskilt relevant för kommunikation mellan dialogrutor och program, eller när andra skriptspråk används inne i Kommander för skript.
dcop | grep kmdr dcop `dcop | grep kmdr` dcop `dcop | grep kmdr` KommanderIf
Det visar vilka dialogrutor som kör, och vilka gränssnitt som är tillgängliga, samt vad som är tillgängligt att anropa i det särskilda gränssnittet för interna funktioner i Kommander. Vid förklaringen av DCOP här, kom ihåg att DCOP används internt av KDE-program (ersatt av D-Bus i KDE 4) och är mycket användbart. Ta en titt på kdcop genom att trycka på Alt+F2 och skriva det i kördialogrutan. Här kan du utforska allt som kör. Nu åter till DCOP i Kommander.
dcop kmdr-executor-@pid KommanderIf setText minKomponent “ny text”
Det här antar att du är inne i en Kommander fil och har tillgång till specialvärdet @pid, som innehåller process-id. Det är i själva verket enklare att ersätta “kmdr-executor-@pid” med @dcopid. Du kan dock använda syntaxen (men förstås utan specialvärden) från kommandoraden eller vilket externt skript som helst för att ändra Kommander-fönstret.
Kommander utvecklade den mycket snabbare interna DCOP-funktionen. Att använda den från ett annat programfönster (DCOP via terminalen är mycket långsamt) är mer komplicerat, eftersom du måste ange mycket information, inklusive anropets prototyp. Anropet ovan skulle bli (observera att @dcopid i själva verket är internt till dialogrutan, men det skulle kunna ersättas med giltigt processid):
@dcop(@dcopid, KommanderIf, “enableWidget(QString, bool)”, komponent, true)
I tidiga versioner av Kommander använde lokala DCOP-anrop inne i skriptspråkstrukturer (som bash) anrop med terminalmetoder. Om du använder intern DCOP körs alla Kommander specialvärden först och därefter körs skriptet. Läs föregående mening igen, eftersom det kommer att ge dig många sorger och bekymmer med en bash-snurra som använder Kommander-specialvärden.
Det finns ett nytt förenklat sätt att använda DCOP inne i Kommander genom att använda en objektsyntax. Låt oss anta att du vill ändra texten i den grafiska komponenten @Radeditor1. Det skulle se ut så här:
@Radeditor1.setText(Ny text)
Som du kan se är den nya syntaxen mycket enkel, samt visuellt överensstämmande med funktionsgrupper. Alla DCOP-referenser här använder den nya objektsyntaxen som listas ovan. Observera att om du hänvisar till en grafisk komponent via DCOP från ett annat fönster eller ett annat program är den första parametern alltid komponentnamnet. Alla funktioner listas här med början från den andra parametern.
Returnerar den angivna globala variabelns värde. När ett skript körs från ett fönster i Kommander upphör alla (icke-globala) variabler som anges i skriptet att existera efter skriptet är färdigt, och är därför inte tillgängliga för andra skriptprocesser eller i en ny instans av den anropande processen. Det globala “omfattningen” betyder att variabeln existerar för alla fönstrets processer ända till fönstret stängs. Du kan ändra variablerna när som helst med ett nytt anrop till @setGlobal.
Skapar en variabel som är global i fönsterprocessen och tilldelar värdet till den. Värdet kan hämtas med global(QString variabelnamn) eller tilldelas igen.
Följande lista är gammal, och finns bara kvar i referenssyfte. Titta i funktionsbläddraren för en fullständig och aktuell referens till alla grafiska komponentfunktioner, som är tillgänglig från alla texteditorfönster i Kommander genom att klicka på knappen längst ner till vänster. De är nu komponentfunktioner, inte DCOP-funktioner, men DCOP-funktionerna är publicerade i DCOP-gränssnittet KommanderIf som beskrivs ovan. Dialogrutor för att lista och skapa anrop till dessa funktioner är tillgängliga på vår webbplats.
Det här tar bort texten som visas i den grafiska komponenten och ersätter den med den angivna texten.
Aktiverar eller inaktiverar en grafisk komponent.
Returnerar texten som är associerad med den angivna grafiska komponenten. Det är inte samma som texten som visas. Det skulle vara “@widgetText” eller texten och/eller skriptet som används för att erhålla det visade värdet.
Det här tilldelar den förvalda strängen för Kommander text. Den tilldelas typiskt värdet “@widgetText” för att visa vad som skrivs in i komponenten. Det är inte troligt att du har mycket nytta av det, men om du gör det finns det där. Gäller alla grafiska komponenter som kan innehålla data.
Lägger till ett objekt i en listruta på angivet index. Listindex börjar på noll. För att lägga till i slutet på listan, använd -1.
Det här lägger till en stränglista på en gång. Listan ska avdelas av nyrader (\n - nyrader). Det är bekvämt eftersom du kan använda bash för att ganska enkelt få fram listan. Att till exempel använda @exec(s -l ~/projects | grep kmdr) som objekt, ger en kataloglistning med Kommander filer i din projektkatalog. Listindex börjar med 0. Använd -1 för att lägga till sist i listan.
addUniqueItem lägger till ett objekt i slutet på listan, men bara om det är unikt.
Tar bort alla objekt.
Tar bort objektet vid angivet index.
Returnerar texten för objektet på angivet index.
Tilldela nuvarande (eller markerat) objekt till angivet index. Gäller de grafiska komponenterna listruta och kombinationsruta.
Markerar/avmarkerar en kryssruta eller alternativknapp.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Copyright © 2005-2008 Michal Rudolf, Eric Laffoon
Härmed ges tillåtelse att kopiera, distribuera och/eller ändra detta dokument under villkoren i GNU Free Documentation License, Version 1.1 eller någon senare version publicerad av Free Software Foundation; utan invarianta avsnitt, utan framsidestexter och utan baksidestexter. En kopia av licensen inkluderas i avsnittet som heter "GNU Free Documentation License".
Den nya tolken introducerades i Kommander med version 1.2, utgiven tillsammans med KDE 3.4. Detta dokumentet gavs ursprungligen ut för att visa alla funktioner i den nya tolken. Den nya tolken är förval från och med Kommander 1.3, utgiven med KDE 3.5.9, utom för program med huvudfönster skapade i Qt™ Designer. Eftersom den nya tolken har så mycket rikare möjligheter, saknar den gamla tolkens begränsning av nästling och lägger till så många nya funktioner, rekommenderar vi starkt att den används.
Kommander själv beskrivs inte här. Se övriga dokument för att ta reda på vad Kommander är till för, hur man skapar dialogrutor och hur grafiska komponenter hanteras under körning.
Här jämför vi de två tolkarna. Även om vi förordar den nya för nästan alla syften, stöds den gamla fortfarande och är användbar, i synnerhet vid arbete med andra skriptspråk.
Den gamla tolken var i själva verket en makrotolk. Bara strängar som börjande med @ kändes igen, tolkades lokalt och expanderades.
@LineEdit1.setText(@ListBox.selection)
Alla underliggande funktioner (lokala variabler, uttryck, filhantering) var nödvändigt att göra i ett annat skriptspråk, som Bash. Även om avsikten med Kommander är att stödja alla andra skriptspråk, vilket för närvarande är i viss mån möjligt, fanns det behov av ett snabbt, inbyggt skriptspråk som var garanterat flyttbart. Det största problemet med den gamla tolken är att Kommander specialvärden utvärderas innan koden skickas till skriptspråket, vilket gör det omöjligt att använda dem i snurror och villkor.
Utvecklarna ansåg att Bash var långsamt och inte vänligt för nya användare, och den gamla tolken var ursprungligen Bash med DCOP-anrop. Paradoxalt nog orsakade det faktum att Kommander är språkneutralt ett behov av att kunna göra mer än bara använda funktioner internt.
Den nya tolken är en fullständig tolk. Den tolkar hela skriptet, inte bara funktionerna. Eftersom vårt intresse är interaktion med det grafiska användargränssnittet, inte att sprida skriptspråk, gjorde vi vissa kompromisser. Resultatet är att Kommanders skriptspråk bör vara användbart för de flesta grundläggande uppgifter, samt naturligt och enkelt att använda. Det finns också en funktionsbläddrare, som hjälper till att foga samman satser. Funktionsbläddraren är avsedd att göra Kommander tillgängligt för fullständiga noviser i programmering. Det liknar vad man finner i Kspread för att hjälpa till att välja en funktion och fylla i parametrarna.
Om du vill använda utökade funktioner som finns i andra språk, kan du infoga dem i Kommander-skriptobjekt inledda med teckenföljden #!. I dessa skript hjälper funktionsbläddraren till att infoga referenser till grafiska komponenter. Kom bara ihåg när funktionen används, att tolken utför en genomläsning för den gamla tolkens funktioner och en genomläsning för skriptet. Om du försöker ändra något i en grafisk komponent och läser den i mitten av ett skript, kanske du inte får vad du förväntar dig.
#!/usr/bin/php
Följande funktionslista kommer från version 1.2
lokala och globala variabler och associativa fält
numeriska uttryck
stränghantering
diverse strukturella kommandon: if, while, for, foreach
de flesta funktionerna från den gamla tolken
direkt hantering av grafiska komponenter
många ytterligare funktioner
rimlig körningshastighet
mottagning av parametrar från signaler i skriptslots
Denna listan är från version 1.3
skicka parametrar och ta emot dem med skriptkörningsanrop
returnera ett värde från ett skript
skapa grafiska komponenter i farten
ansluta signaler och slots i farten
använda variabelalias för namn på en grafisk komponent
enkla funktioner för indexerade fält
direkt åtkomst av slots i en grafisk komponent
För att aktivera den nya tolken, ställ in egenskapen useInternalParser i dialogrutan till true. Man kan också aktivera den nya tolken i ett enskilt skript genom att skriva
#!kommanderpå första raden i skriptet. Observera också, att om du använder ett annat skriptspråk i ett skript med teckenföljden #!, aktiverar Kommander automatiskt den gamla tolken för att kommunicera med dialogrutan.
#!/bin/bash echo @Self.item(0) # returnerar första parametern som skickas till skriptet # echo $returvärde återgår till det anropande skriptet
Varje värde har en av tre typer: sträng, heltal eller dubbelt flyttal. Typkonvertering är automatisk, och väljer den lämpligaste typen (om du till exempel adderar ett flyttal med ett heltal, blir resultatet ett flyttal). Om ett av värdena är en sträng, blir också resultatet det.
Ställen du kan råka ut för problem här är när ett numeriskt värde hämtas från en grafisk komponent och du försöker använda en matematisk funktion med det. Eftersom Kommander använder + för att sammanfoga två textsträngar, kan det behandla LineEdit1.text + 2 som 22 istället för 2. Se konverteringsfunktionerna bland strängfunktioner för att undvika problem.
Följande matematiska operatorer stöds: +, -, *, mod, . Vanliga parenteser stöds förstås också.
Alla sorters jämförelser stöds: <, >, <=, >=, ==, !=. I stället för != kan du också använda <>. Dessutom stöds de logiska operatorerna and, or, not, samt deras motsvarighet i C (&&, ||, !).
För strängar kan operatorn + användas för sammanfogning av strängar.
Några exempel på giltiga uttryck:
2+3 -5 * (2 - 13 mod 3) "Listan har " + 12 + "objekt."
Variabler behöver inte deklareras. Så fort en variabel har används, anses den vara deklarerad. Typen hos en variabel känns igen automatiskt, och kan ändras senare.
Dessutom stöds associativa fält. De avbildar strängar till värden av godtycklig typ. För att deklarera ett sådant fält kan du helt enkelt lägga till några element i det, till exempel: A["Quanta"] = "Webbeditor". Fält hanteras också av kommandot foreach och fältfunktioner.
Lokala och globala variabler stöds. Globala variabler markeras med ett inledande understreck. Alltså är min_var en lokal variabel, medan _min_var är global. Samma sak gäller för fält.
a = 5 b = 2 * 5 - (a + 1) c = "[Objekt " + b + "]" d["Min_nyckel"] = "Mitt_värde" d["Min_nyckel_2"] = 5
Att använda variabler för grafiska komponenter fungerar i stort sett som man kan förvänta sig. Det är användbart när grafiska komponenter läggs till i en tabell med en snurra.
for i=0 to 10 do min_kombinationsruta = "ComboTable"+i createWidget(min_kombinationsruta, "ComboBox", "Form1") end
Du kan använda kommentarer i Kommander med två traditionella kommentarformer från programspråk för radkommentarer. För användare som är noviser när det gäller programmering och som undrar vad “traditionella former” är, se nedan. Du kan kopiera och klistra in texten nedan i en initiering av en knapp eller dialogruta, och se hur kommentarer beter sig vid användning.
// detta är en kommentar på en rad
message_info("Hej allihop") // traditionellt första program
// ovanstående kommentar ignoreras också - meddelanderutan gör det inte
# detta är också en kommentar
message_info("Detta meddelande visas")
Att använda följande flerraderskommentar fungerar inte, och gör att resten av komponentens körning misslyckas.
/* Hej, det är meningen att detta ska vara en kommentar Ingenting i skriptet efter detta kommer att köras ANVÄND INTE DENNA KOMMENTARTYP I KOMMANDER! */
Kommander har några inbyggda globala variabler som kan vara praktiska.
_ARGS - argumentsträngarna som skickas till dialogrutan när den visas.
_ARGCOUNT - antal argument som skickades. De kan hämtas som ARG1 till ARGn där n är det totala antalet argument som skickades.
_KDDIR - katalogen där dialogrutan kördes. Kommander använder normalt din hemkatalog, eller en ändrad katalog om tillfrågad om dess arbetskatalog. Det är användbart för att spara och läsa filer med Kommander-filen.
_NAME - det finns ingen anledning att använda denna, gör alltså inte det
_PID - processidentifierare som den aktuella dialogrutan körs med - också tillgänglig som bara pid. Undvik användning av detta namn för dina egna variabler!
_VERSION - praktiskt om du vill visa vilken version av Kommander som kör
Du kan skicka argument via skriptparametrar, signaler och slots, kommandoradsparametrar och DCOP. Låt oss ta en titt på skript. Anropa skript på följande vis:
resultat = Skriptobjekt1.execute("Hej allihop")
debug(resultat) Inne i skriptet kan det se ut så här:var = str_upper(Self.Item(0)) return(var)Nu får du ett returvärde i meddelandeloggen via standardfelutmatningen som är HEJ ALLIHOP.
Att ta emot en signal som är ansluten till en skriptslot fungerar på samma sätt. Self.Item(0) är parameter ett och så vidare. Du kan hämta antal argument som skickas via Skriptobjekt.count.
Kommandoradsparametrar tillåter namngivna eller namnlösa argument. Namnlösa ser ut som
kmdr-executor mitt_program.kmdr 100 rödHär blir _ARG1 = 100 och _ARG2 = röd. En konstighet är att när strängar med mellanslag skickas som argument måste de citeras. Används dialogkommandot blir saker och ting mer komplicerade, eftersom hela argumentsträngen måste skickas som en sträng, alltså inom citationstecken.
dialog("min_dialog.kmdr", 100+" \"Hej allihop\"") Det returnerar _ARG1 = 100 och _ARG2 = Hej allihop. Utan skyddade citationstecken hade du fått _ARG2 = Hej och _ARG3 = allihop. Att använda namngivna parametrar är rätt trevligt, och potentiellt mindre förvirrande. dialog("min_dialog.kmdr", "xantal=100 xcitat=Hej allihop") Nu kan du komma åt dem med de globala variablerna _xantal och _xcitat. DCOP kan vara komplicerat, vilket är orsaken till att vi rekommenderar att använda de verktyg vi utvecklar för att göra det möjligt att skapa DCOP för Kommander-fjärrdialogrutor med något som liknar en funktionsbläddrare. Här är ett exempel på ett DCOP-anrop som skickas från en dialogruta öppnad av ett Kommander-fönster. Eftersom den vet vem som skapat den, kan den skicka tillbaka information medan den är öppen, och fritt komma åt alla fönstrets funktioner med undantag av slots. Det kan naturligtvis göras internt med ett skript som kan anropas externt, så i praktiken finns det inga begränsningar av vad som är möjligt.
dcop("kmdr-executor-"+parentPid, "KommanderIf", "setText(QString,QString)", "StatusBar8", "Hej") Låt oss titta på detta en del i taget. Först av allt lägger vi till parentPid to "kmdr-executor-" eftersom vi inte antar att ett Kommander-fönster gjorde anropet. Du skulle kunna använda det med Quanta, Kspread eller vad som helst. Därefter adresserar vi KommanderIf, som är ett bra gränssnitt för slutanvändare som har städats. Vi hoppas att fler program till sist börjar använda ett bra gränssnitt för integrering när KDE går från DCOP till DBUS i KDE4. Nästa parameter, "setText(QString,QString)", är viktig eftersom den anger prototyp för tillåtna parametrar. Annars skulle inte Kommander kunna validera anropet. Utan definitionen av DCOP-anropet som används får du ett fel. Återstående parametrar är förstås de som skickas. Vi rekommenderar att du tittar på program med kdcop för att se hur det fungerar, och övar på att skicka DCOP-anrop från skalet för att få rätt syntax. Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Diverse strukturkommandon stöds. De kan nästlas fritt.
Det finns också tre särskilda kommandon: exit, break och continue. Det första avsluta skriptets körning och återgår. Det andra avslutar pågående block (while, for eller foreach), och det tredje avslutar bara pågående varv, och fortsätter från snurrans början.
Kommandot if har följande syntax:
if villkor then kod elseif villkor then kod else kod endif
Både delarna elseif och else är valfria. Villkor är vilket uttryck som helst. Kod utförs om villkoret är sant. Det betyder:
skilt från noll för heltal och flyttal
inte tom för strängar
if a * 2 > 7 then b = 1 elseif a < 0 then b = 2 elseif b = 0 endif
while villkor do kod end
Villkor beräknas om varje gång snurran utförs.
while i < 15 do i = i + a end
Kommandot for har följande syntax:
for variabel = startvärde to slutvärde step uttryck do kod end
Snurran utförs med början på startvärde och avslutas när variabelns värde är större än slutvärde. Om step anges, ökas variabelns värde med det angivna värdet istället för 1.
for i = 1 to 20 step 5 do a = a + 2 * i end
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
De flesta av den gamla tolkens funktioner stöds av den nya tolken. Dessutom har några nya funktioner lagts till.
Strängfunktionerna är samma som i den gamla tolken, den enda skillnaden är att deras namn inleds med str_ istället för @String.
str_length(sträng) - returnerar längden av sträng
str_contains(sträng, text) - returnerar 1 om sträng innehåller text
str_find(sträng, text, start) - returnerar positionen för den första förekomsten av text i sträng, det valfria värdet start anger sökningens början
str_find(sträng, text, start) - returnerar positionen för den sista förekomsten av text i sträng, det valfria värdet start anger sökningens början
str_left(sträng, antal) - returnerar första antal tecken av sträng
str_right(sträng, antal) - returnerar sista antal tecken av sträng
str_right(sträng, start, antal) - returnerar delsträngen av sträng med början på start som innehåller antal tecken (eller allt till strängens slut om den sista parametern inte anges)
str_remove(sträng, text) - returnerar sträng med alla delsträngar som är lika med text borttagna
str_replace(sträng, text, text2) - returnerar sträng med alla delsträngar som är lika med text ersatta med text2
str_lower(sträng) - returnerar sträng konverterad till små bokstäver
str_upper(sträng) - returnerar sträng konverterad till stora bokstäver
str_section(sträng, avdelare, start, slut) - returnerar delsträngen som innehåller lämpliga delar av sträng bestämda av avdelare. Om inget slut anges, returneras en ensam del från start
str_args(sträng, ...) - returnerar sträng med %1, %2, %3 ersatta med efterföljande parametrar.
str_isnumber(sträng) - returnerar 1 om sträng är ett giltigt tal
str_isempty(sträng) - returnerar 1 om sträng är tom
str_toint(sträng, förval) - returnerar sträng konverterad till ett heltal. Om konverteringen inte är möjlig, returneras det valfria värdet förval
str_todouble(sträng, förval) - returnerar sträng konverterad till ett flyttal. Om konverteringen inte är möjlig, returneras det valfria värdet förval
De flesta Kommander-funktioner stöds. Vissa (som expr) blev föråldrade av den nya tolken och är inte tillgängliga.
debug(sträng, ...) - skriver ut alla parametrar på standardfelutmatningen
echo(sträng, ...) - skriver ut alla parametrar på standardutmatningen
dcop(sträng, ...) - anropar en DCOP-funktion
exec(sträng, skal) - kör ett externt program (med användning av valfritt skal), blockerar körningen av aktuell dialogruta till programmet som skickas som parameter avslutas, returnerar programmets utmatning
i18n(sträng) - markerar sträng för framtida översättning
env(sträng) - returnerar värdet av en miljövariabel
readSetting(nyckel, förval) - returnerar ett värde lagrat i inställningsfilen med angiven nyckel. Om ett sådant värde inte finns, returneras förval
writeSetting(nyckel, värde) - skriver paret nyckel och värde i inställningsfilen
Nytt i Kommander 1.3
execBackground(sträng, skal) - kör ett externt program (med användning av valfritt skal) i bakgrunden, utan att blockera aktuell dialogruta, i motsats till funktionen exec ovan, returnerar den inte programmets utmatning.
return(värde) - returnerar ett värde till anropande objekt (skript, knapp ...)
createWidget(komponentnamn, komponenttyp, skapare) - skapar en ny grafisk komponent. Därefter kan du till exempel lägga till den i en tabell eller verktygslåda, och använda min_komponent.show(true) för att göra den synlig. Om du lägger till en ny grafisk komponent i formuläret, måste du ta hänsyn till layout. Kommander skapar inte en layout i farten, eller justerar positioner bildpunkt för bildpunkt (i de flesta fall). Det är förvirrande till och med vid utveckling med C++. Vi rekommenderar att du använder en gruppruta och skapar en layout i dialogrutan för att få bäst kontroll.
connect(avsändare, signal, mottagare, slot) - anslut en signal i en grafisk komponent till en slot. Se anslutningsdialogrutan och välj liknande komponenter för att se möjligheterna. Om en signal till exempel ser ut som execute(const QString&) är det exakt vad som måste finnas här inom citationstecken.
disconnect(avsändare, signal, mottagare, slot) - ta bort anslutningen som anges ovan. Återigen är exakt riktig syntax helt nödvändig.
widgetExists(komponentnamn) - kom ihåg att du nu kan använda ett variabelnamn för att ange en grafisk komponent . Använd det när grafiska komponenter som skapats ska kommas åt, för att försäkra dig om att de finns. Att anropa en grafisk komponent som inte finns orsakar naturligtvis ett fel.
De flesta fältfunktioner stöds. Vissa (som value) blev föråldrade av den nya tolken och är inte tillgängliga. Den enda skillnaden är att deras namn inleds med array_ istället för @Array.
På grund av begränsningar i tolken, måste fältnamn för närvarande anges som strängar, till exempel array_count("Mitt_fält").
array_clear(fält) - tar bort alla element från fält
array_count(fält) - returnerar antal element i fält
array_keys(fält) - returnerar en sträng som innehåller nycklarna i fält åtskilda med radslut. Observera att om du importerade en skalär (nycklar utan värden) i ett fält med Kommander skulle du inte kunna komma åt den med array_values("mitt_fält") som du kanske förväntade dig (eftersom den bara verkar ha värden) utan skulle istället behöva använda array_keys("mitt_fält"). Du kanske finner att ett bättre val i detta fall är att använda de nya indexerade fälten som beskrivs nedan.
array_values(fält) - returnerar en sträng som innehåller värden i fält åtskilda med radslut
array_tostring(fält) - returnerar en sträng som innehåller hela fält som rader med par av nyckel och värden åtskilda med tabulatortecken
array_fromstring(fält, sträng) - läser fält från sträng (oftast skapad av funktionen array_tostring)
array_remove(fält, nyckel) - tar bort objektet med nyckel från fält
Här är ett exempel på fälthantering:
array_fromstring("mitt_fält", "1\tA\nandra\tB\n3\tC")
foreach key in mitt_fält do
debug("mitt_fält[" + key + "]= " + mitt_fält[key])
end
Det skriver ut följande på standardfelutmatningen. Det syns att det inte finns någon garanti om elementens ordning i fältet, samt att nycklarna är strängar, inte tal.
mitt_fält[1]= A mitt_fält[3]= C mitt_fält[andra]= B
Ett annat exempel på fält utan nycklar:
array_fromstring("mitt_fält", "A\nB\nC")
foreach nyckel in mitt_fält do
debug(nyckel)
end
debug("Fältelement:\n" + array_keys("mitt_fält"))
Det ger resultatet:
A B C Fältelement: A B C
Nytt i Kommander 1.3
array_indexedFromString(fält, sträng, avdelare) - Det här kompenserar för att Kommander inte har indexerade fält. Den skapar ett fält med ett nollbaserat sekvensiellt index. Kom ihåg att använda citationstecken för fältnamnet och eventuella strängar som inte representeras av en variabel. Argumentet avdelare är valfritt och har det förvalda värdet "\t" (tabulator), och används för att åtskilja fält vid läsning och skrivning av tabeller, fält eller grafiska detaljkomponenter. Kom ihåg att fältindex inte själv tvingar att några regler följs, det är precis som om du skapade det med en for-snurra, bara bekvämare.
array_indexedInsertElements(fält, nyckel, sträng, avdelare) - Funktionen ingår i uppsättningen med funktioner för indexerade fält, och gör det möjligt att infoga element i fältet och samtidigt behålla ett index som är sekventiellt, i en följd, och unikt. Ange indexnyckel att börja, textsträng och hur den skiljs åt. Elementen läggs till och alla efterföljande indexnummer skiftas med antalet tillagda element.
array_indexedRemoveElements(fält, nyckel, antal) - Det här gör det möjligt att ta bort element från ett indexerat fält och undvika indexhål. Ange nyckel att börja med och valfritt hur många element som ska tas bort. Förvalt antal är ett. Slutresultatet blir ett omindexerat fält utan de borttagna elementen.
array_indexedToString(fält, avdelare) - Det här gör det möjligt att konvertera ett indexerat fält tillbaka till en sträng, vilket är särskilt användbart för grafiska detaljkomponenter. Om du till exempel visar resultatet av en databasfråga i Trädkomponent1 med sex kolumner, kan du använda Trädkomponent1.selection för att hämta den markerade raden. Den är avdelad med tabulatortecken, och du skulle kunna titta på det femte elementet genom att använda str_section(Trädkomponent1.selection, "\t", 4) (kom ihåg att den är nollbaserad). Det är bra för att läsa ett värde, men om du vill ändra det märker du att du måste göra en hel del ytterligare arbete. Efter strängen har delats, måste du sätta ihop den igen med val1+"\t"+val2.... Genom att använda indexerade fält kan du redigera det femte elementet på följande sätt:
idx = Trädkomponent1.currentItem
array_indexedFromString("z", Trädkomponent1.selection)
z[4] = "nytt värde"
Trädkomponent1.removeItem(idx)
Trädkomponent1.insertItem(array_indexedToString("z"), idx)
Observera att bara två korta rader har lagts till för att åstadkomma det. Det är mycket välkommet vid databasanvändning. Alla filfunktioner stöds. Den enda skillnaden är att deras namn inleds med file_ istället för @File.
file_read(namn) - returnerar innehållet i filen namn
file_write(namn, ...) - skriver alla argument till filen namn
file_append(namn, ...) - lägger till alla argument sist i filen namn
Dessa funktioner visar en dialogruta som låter användaren mata in ett värde. De kan kommas åt genom att använda @Input. i den gamla tolken. För de flesta funktioner är alla parametrar valfria, undantagen är input_text som kräver 2 parametrar och input_value som kräver 5 parametrar.
input_color(rubrik, förval) - returnerar färg på formatet #RRGGBB
input_text(rubrik, beteckning, förval) - returnerar text inmatad av användaren
input_value(rubrik, beteckning, förval, min, max, steg) - returnerar värden som matas in av användaren
input_direktory(startkatalog, filter) - returnerar en katalog som valts av användaren
input_openfile(rubrik, beteckning, förval) - returnerar en befintlig fil som matas in av användaren
input_savefile(rubrik, beteckning, förval) - returnerar en fil som matas in av användaren (om filen redan finns, krävs en bekräftelse)
input_openfiles(rubrik, beteckning, förval) - returnerar en sträng med befintliga filer som matas in av användaren åtskilda med radslut
Dessa funktioner visar meddelanden för användaren, eller ber användaren bekräfta en åtgärd. Använd istället @Message. i den gamla tolken.
message_info(text, rubrik) - visar informationstext
message_error(text, rubrik) - visar feltext
message_warning(text, rubrik, knapp1, knapp2, knapp3) - visar en fråga med en varning och upp till tre knappar. Numret på den valda knappen returneras. Om inga knappnamn anges, visas Ja och Nej
message_question(text, rubrik, knapp1, knapp2, knapp3) - visar en fråga och upp till tre knappar. Numret på den valda knappen returneras. Om inga knappnamn anges, visas Ja och Nej
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Du kan ganska enkelt skapa nya grafiska komponenter med Kommander som är baserade på komponenter som inte tillhör Kommander.
Det finns två sätt att lägga till nya komponenter i Kommander: genom att skapa insticksprogram, eller genom att direkt lägga till dem i Kommanders källkod.
Det första steget är att skapa komponentklassen. Metoden baseras på att härleda den nya Kommander komponentklassen från Qt™- eller KDE-komponenten som du vill integrera med Kommander, och dessutom från klassen KommanderWidget. Genom att överskrida metoder från denna klass, ger Kommander komponenten sin funktion.
Det mesta av koden i en Kommander-komponent är bara mallkod. Därför kan du använda KDevelops mall för Kommander-insticksprogram för att skapa det mesta av Kommander-komponentens kod åt dig. För att göra det kör KDevelop (3.5 rekommenderas), välj , markera kryssrutan Visa alla projektmallar, välj mallen C++/Kommander/KommanderPlugin. Ge insticksprogrammet ett namn och följ instruktionerna i guiden.
Allt du behöver göra är fylla i de viktiga delarna som hör till din grafiska komponent, liksom eventuell tillståndsinformation, komponenttext, etc.
Låt oss anta att vi vill skapa en ny radeditorkomponent för Kommander baserat på KDE-komponenten KLineEdit. Genom att använda dialogrutan för att skapa Kommander-komponenter, får vi något som liknar det här i den skapade deklarationsfilen:
#include <kommanderwidget.h>
class QShowEvent;
class KomLineEdit : public KLineEdit, public KommanderWidget
{
Q_OBJECT
Q_PROPERTY(QString populationText READ populationText WRITE setPopulationText DESIGNABLE false)
Q_PROPERTY(QStringList associations READ associatedText WRITE setAssociatedText DESIGNABLE false)
Q_PROPERTY(bool KommanderWidget READ isKommanderWidget)
public:
KomLineEdit(QWidget *a_parent, const char *a_name);
~KomLineEdit();
virtual QString widgetText() const;
virtual bool isKommanderWidget() const;
virtual void setAssociatedText(const QStringList&);
virtual QStringList associatedText() const;
virtual QString currentState() const;
virtual QString populationText() const;
virtual void setPopulationText(const QString&);
public slots:
virtual void setWidgetText(const QString &);
virtual void populate();
protected:
void showEvent( QShowEvent *e );
signals:
void widgetOpened();
void widgetTextChanged(const QString &);
};
Det mesta av detta är bara mallkod som du inte behöver bry dig om. De enda två saker du måste försäkra dig om är att filen kommanderwidget.h inkluderas längst upp, och att klassen först härleds från komponenten vi önskar integrera med Kommander och därefter från KommanderWidget.
Det finns några delar i cpp-filen som är viktiga för varje enskild komponent.
KomLineEdit::KomLineEdit(QWidget *a_parent, const char *a_name)
: KLineEdit(a_parent, a_name), KommanderWidget(this)
{
QStringList states;
states << "default";
setStates(states);
setDisplayStates(states);
}
Vi anger tillstånden komponenten kan ha i konstruktorn. Vår radeditor har ingen form av tillstånd, så vi ger den bara tillståndet default. Om du skapar en komponent som har olika tillstånd, som en kryssruta, kan du ange tre tillstånd unchecked, semichecked och checked här.
QString KomLineEdit::currentState() const
{
return QString("default");
}Vi angav tillstånden i konstruktorn ovan, och detta returnerar bara komponentens nuvarande tillstånd. För vår komponent är det alltid default, men du bör lägga till kod här som kontrollerar vilket tillstånd komponenten för närvarande har, och returnerar lämplig sträng här.
QString KomLineEdit::widgetText() const
{
return KLineEdit::text();
}
void KomLineEdit::setWidgetText(const QString &a_text)
{
KLineEdit::setText(a_text);
emit widgetTextChanged(a_text);
}
Detta är de två viktigaste metoderna, där den största delen av koden som utgör funktionen finns. Metoden QString KomLineEdit::widgetText() const returnerar komponenttexten (texten som @widgetText expanderas till i textassociationer). Komponenttexten i vår komponent är helt enkelt texten i radeditorn, så vi returnerar den. På liknande sätt, när komponenttexten ändras, ändrar vi bara texten i radeditorn. Vi skickar signalen widgetTextChanged() efter komponenttexten har ändrats, så att andra komponenter kan får reda på det faktum att komponenten har uppdaterats.
För att lägga till funktioner i komponenten, måste du registrera några funktioner och lägga till kod för att hantera dem. Här är koden som används för att registrera dem. Lägg den i början av cpp-filen, ovanför konstruktorn.
#include <klocale.h> // för i18n
#include "kommanderplugin.h"
#include "specials.h"
enum Functions {
FirstFunction = 1159,
Function1,
Function2,
LastFunction
};
KomLineEdit::KomLineEdit(QWidget *a_parent, const char *a_name)
: KLineEdit(a_parent, a_name), KommanderWidget(this)
{
... // kod som beskrivs ovan
KommanderPlugin::setDefaultGroup(Group::DCOP);
KommanderPlugin::registerFunction(Function1, "function1(QString widget, QString arg1, int arg2)", i18n("Call function1 with two arguments, second is optional."), 2, 3);
KommanderPlugin::registerFunction(function2, "function2(QString widget)", i18n("Get a QString as a result of function2."), 1);
}
Detta registrerar två funktioner: function1 och function2 Numren som tilldelas funktionerna (här 1160 och 1161) måste vara unika, och inte användas av några andra insticksprogram eller inne i Kommander. function1 har två argument, ett valfritt, function2 har inget argument och returnerar en sträng. Argumentet QString widget i signaturerna anger att funktionerna arbetar med en grafisk komponent, som: KomLineEdit.function1("komponent", 1).
För att lära Kommander att komponenten stöder dessa funktioner, lägg till en metod på följande sätt:
bool KomLineEdit::isFunctionSupported(int f)
{
return (f > FirstFunction && f < LastFunction) || f == DCOP::text;
}
Det betyder att KomLineEdit stöder funktionerna ovan, och den vanliga funktionen text. Funktionskoden ska hanteras inne i metoden handeDCOP:
QString KomLineEdit::handleDCOP(int function, const QStringList& args)
{
switch (function)
{
case function1:
handleFunction1(arg[0], arg[1].toInt()); // anropa din hantering av function1
break;
case function2:
return handleFunction2(); // anropa function2
break;
case DCOP::text:
return text(); // anropa den vanliga metoden KLineEdit::text()
break;
default:
return KommanderWidget::handleDCOP(function, args);
}
return QString::null;
}
Det finns tillfällen då komponenten ska se annorlunda ut i editorn än när den körs, vilket är fallet för skriptobjekt, om-dialogruta, etc. Den vanliga lösningen är att visa en QLabel istället för komponenten. För att göra det måste komponenten härledas från QLabel, och använda följande i konstruktorn:
if (KommanderWidget::inEditor)
{
setPixmap(KGlobal::iconLoader()->loadIcon("iconname", KIcon::NoGroup, KIcon::SizeMedium));
setFrameStyle(QFrame::Box | QFrame::Plain);
setLineWidth(1);
setFixedSize(pixmap()->size());
}
else
setHidden(true);
Du kan skapa själva komponenten (om en komponent över huvud taget behövs, kanske "komponenten" bara tillhandahåller funktioner för att t.ex. komma åt en databas) i en av dina funktioner, som i funktionen execute. Här är ett exempel från komponenten om-dialogruta:
QString AboutDialog::handleDCOP(int function, const QStringList& args)
{
switch (function) {
...
case DCOP::execute:
{
if (m_aboutData)
{
KAboutApplication dialog(m_aboutData, this);
dialog.exec();
}
break;
}
...
}
Nu har du en fullständig Kommander-komponent. Allt som återstår att göra är att göra den tillgänglig i Kommander-systemet via insticksprogram.
Alla komponenter i Kommander tillhandahålls via insticksprogram. De vanliga komponenterna laddas som komponentinsticksprogram, men Kommanders editor är också länkat med biblioteket, eftersom vissa mekanismer i editorn är specifikt knutna till standardkomponenterna.
Ett insticksprogram i Kommander är helt enkelt ett delat bibliotek som har symbolen 'kommander_plugin'. Symbolen är en funktion som returnerar en pekare till en instans av klassen KommanderPlugin.
Kommander gör det enkelt att skapa ett insticksprogram för dina komponenter, så att du inte behöver bekymra dig om lågnivåsaker. Grundidén är att härleda en ny insticksklass för dina komponenter från basklassen KommanderPlugin och implementera några få specifika detaljer. Mallkod skapas av KDevelops projektmall som beskrivs ovan.
Följande kod fortsätter exemplet om hur man skapar en radeditorkomponent för Kommander.
#include <kommanderplugin.h> /* WIDGET INCLUDES */ #include "komlineedit.h"
Det första vi gör är att inkludera kommanderplugin.h. Den innehåller definitionen av klassen KommanderPlugin. Vi inkluderar också alla deklarationsfiler för komponenter som insticksprogrammet tillhandahåller - bara komlineedit.h i detta fall.
class MyKomPlugin : public KommanderPlugin
{
public:
MyKomPlugin();
virtual QWidget *create( const QString &className, QWidget *parent = 0, const char *name = 0 );
};
Därefter skapar vi delklassen KommanderPlugin som kallas MyKomPlugin. Klassen har helt enkelt en konstruktor och den överskridna metoden create.
MyKomPlugin::MyKomPlugin()
{
addWidget( "KomLineEdit", "My Widget Group", i18n("A Kommander line edit widget") new QIconSet(KGlobal::iconLoader()->loadIcon("iconname", KIcon::NoGroup, KIcon::SizeMedium)));
// lägg till mina andra komponenter här
}
I insticksprogrammets konstruktor, anropar vi addWidget()för varje komponent vi vill tillhandahålla i insticksprogrammet. addWidget() har sex argument, men bara de fyra första krävs. I ordning är argumenten, komponentklassens namn, grupp, verktygstips, en ikonuppsättning för ikonen som används i editorns verktygsrad, vad är det här-information, och en Boolean som anger om komponenten är omgivande komponent för andra komponenter eller inte. Informationen används av editorn när komponenten grupperas i menyer, tillhandahåller hjälpinformation, etc.
När det gäller ikonen, så laddar exemplet ovan en ikon av medelstorlek som kallas iconname från KDE:s vanliga ikonplats.
QWidget *MyKomPlugin::create( const QString &className, QWidget *parent, const char *name )
{
if( className == "KomLineEdit" )
return new KomLineEdit( parent, name );
// skapa mina andra komponenter här
return 0;
}
create() är stället där instanser av våra komponenter verkligen skapas. Så snart Kommander behöver en instans av en av klasserna som tillhandahålls av vårt insticksprogram, anropas create() med namnet på klassen som behövs, överliggande komponent och namnet som ska användas. Om className matchar någon komponent vi känner till, returnerar vi en ny instans av den klassen, men annars returnerar vi 0.
Till sist exporterar vi insticksprogrammet. Det tillhandahåller bara en anropspunkt för insticksprogrammet så att Kommander-systemet kan komma åt den. Utan det känner inte Kommander igen biblioteket som ett Kommander-insticksprogram.
KOMMANDER_EXPORT_PLUGIN(Mitt_Kom_insticksprogram)
För att kompilera den nya utökningen till Kommander, ska du kompilera alla filer som ett delat bibliotek, och länka med kommanderplugin, kommanderwidget och eventuella lämpliga KDE-bibliotek. Med radeditorexemplet, om vi har komlineedit.h, komlineedit.cpp och mykomplugin.cpp, skulle kompilering och installering av insticksprogrammet omfatta något som liknar följande kommandon:
libtool --mode=compile g++ -$KDEDIR/include -IQTDIR/include \ -I. -fPIC -c komlineedit.cpp libtool --mode=compile g++ -$KDEDIR/include -IQTDIR/include \ -I. -fPIC -c mykomplugin.cpp libtool --mode=link g++ -shared -L$KDEDIR/lib -lkdeui -lkommanderwidget \ -lkommanderplugin komlineedit.cppkomlineedit.o mykomplugin.o -o libmykomplugin.so
Om du vill installera det nya insticksprogrammet för hela systemet, som systemadministratör, använd då:
su -c "cp libmykomplugin.so $KDEDIR/lib"
Om du använder KDevelops projekthantering, behöver du inte göra ovanstående, utan anpassa istället Makefile.am för att länka med extra bibilotek. Normalt länkar den med Qt™- och KDE-biblioteken och skapar alla objektfiler som behövs. Kör bara make för att bygga och su -c make install för att installera.
Nu när insticksprogrammet är installerat, kör programmet kmdr-plugins eller välj i editorn. Listan i programmet visar insticksprogrammen som för närvarande är laddade av Kommander. Lägg till det nya insticksprogrammet i listan genom att klicka på knappen Lägg till i verktygsraden och välja ditt insticksprogram. När programmet avslutas sparas ändringarna.
Om du nu startar om Kommanders editor, ska de grafiska komponenterna som det nya insticksprogrammet tillhandahåller vara tillgängliga i menyer och verktygsrader.Du kan nu använda dina nya komponenter i Kommander-dialogrutor.
Det här avsnittet är till för utvecklare av Kommander, och beskriver hur en ny komponent läggs till direkt i Kommander.
Ironiskt nog är detta mer komplicerat, särskilt om komponenten behöver extra redigeringsmetoder. Först skapas komponenten som ovan. Därefter måste du registrera komponenten i editorn och för körning. Lägg till den i editor/widgetdatabase.cpp för att registrera den i editorn:
...
#include "mywidget.h"
...
void WidgetDatabase::setupDataBase( int id )
{
...
r = new WidgetDatabaseRecord;
r->name = "MyWidgetName";
r->iconName = "icon.png";
r->group = widgetGroup( "Kommander" );
r->toolTip = i18n("My new widget");
append(r);
...
}
Du måste dessutom lägga till följande i editor/widgetfactory.cpp:
...
#include "mywidget.h"
...
QWidget *WidgetFactory::createWidget( const QString &className, QWidget *parent, const char *name, bool init,
const QRect *r, Qt::Orientation orient )
{
...
else if (className == "MyWidgetName")
return new MyWidget(parent, name);
...
}
För att registrera för körning (i själva verket i instickssystemet), lägg till följande i widgets/plugin.cpp:
KomStdPlugin::KomStdPlugin()
{
...
addWidget("MyWidgetName", group, "", new QIconSet(KGlobal::iconLoader()->loadIcon("iconname", KIcon::NoGroup, KIcon::SizeMedium)));
...
}
Det liknar hur komponenten registreras via instickssystemet i det första fallet.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Kommander dialogrutor kan översättas till olika språk. Mekanismen liknar översättningen av andra KDE-program. Dialogrutan skrivs på engelska, och texterna som behöver översättas markeras särskilt. Ett verktyg extraherar dessa strängar, och ett annat verktyg kan användas för att översätta dem. Översättningen kan därefter kompileras och installeras, så känner dialogrutan automatiskt igen den och använder den.
Här är en kort beskrivning av stegen som behövs för att göra en dialogruta översättningsbar och för att översätta den:
Hur förbereder man dialogrutan för att bli översatt?
Använd alltid @i18n("This is my text") när du skriver text på engelska. Det markerar "This is my text" som text att översätta.
Hur extraherar man meddelanden och skapar .po-filen?
Använd skriptet kmdr2po för att extrahera strängarna. Skriptet finns i katalogen working i den utgivna källkodens komprimerade arkiv, och ska dessutom vara installerat i $KDEDIR/share/apps/kommander/translating.
Kör bara:
kmdr2po <din-kommander-dialog.kmdr>En lämplig fil kallad <din-kommander-dialog.po > kommer att skapas.
Hur översätter man den?
Använd Kbabel för att översätta den. Använd msgfmt för att kompilera översättningen. Se http://i18n.kde.org för hjälp om detta område.
Hur installerar man översättningen?
Placera antingen den kompilerade *.mo-filen i
$KDEDIR/share/locale/<ditt språk >/LC_MESSAGES/ (allmänt tillgängligt för alla användare)
eller i katalogen
$HOME/.kde/share/locale/<ditt språk >/LC_MESSAGES/ (bara tillgängligt för aktuell användare)
.
För att öppna en annan katalog (översatt *.mo-fil) för en dialogruta, använd väljaren -c i kmdr-executor. Exemplet nedan tar översättningen från Quantas översättningsfil:
kmdr-executor min_dialog.kmdr -c quanta
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
I det här avsnittet går vi vidare från att bara lista grafiska komponenter till att verkligen använda Kommander. Om du vill skaffa dig god erfarenhet kommer det här avsnittet att vara till stor hjälp.
Vid en första titt ser editorn ganska självklar ut, och på många sätt är den det. Klicka på ikonen för att skapa ett nytt formulär, klicka därefter på en grafisk komponent och klicka, eller klicka och dra, på formuläret. Komponentgreppen finns där, som är bekanta för alla som någonsin lagt till en bild i ett dokument i en ordbehandlare. Vad som inte är lika uppenbart är småsaker. En sak som bör nämnas från början är namngivning av komponenter. Namn måste vara unika, och Kommander använder en namngivningsmetod med det formella komponentnamnet och ett nummer unikt för komponenttypen. Du kan ändra namn på en komponent, och Kommander tillåter inte ett duplicerat namn. Om du dock skapar en komplex dialogruta och bestämmer dig för att börja ändra namn, kommer du att få problem. Signaler och slots hanterar namngivning åt dig, och alla komponenter du ändrar kommer att speglas i anslutningarna av signaler och slots. Tyvärr har den funktionen aldrig lagts till i komponentfunktionerna. Alltså blir alla anrop till komponenten fel. Du skulle kunna stänga dialogrutan och öppna den i en texteditor som Kwrite och använda sök och ersätt. En bättre lösning är att börja med en viss idé om vilka beskrivande namn du vill ge till nyckelkomponenter. Det kan vara slöseri med tid att namnge etiketter, men det visar sig snabbt vara ett misstag att inte namnge skript och omgivande komponeter. Du kan också ange ikoner för skript, vilket gör det ännu snabbare att identifera dem visuellt.
Det första du märker är ett egenskapsfönster, i allmänhet placerat till vänster. Utforska det! Här hittar du många användbara inställningar av formulär och grafiska komponenter. Vissa av dem är layoutinställningar, ikoner, om någonting är aktivt, text med mera. Om du till exempel lägger till en trädkomponent i ett formulär kan du ändra förvald sökvägsavskiljare, vilket är användbart om den innehåller data. Det är lätt hänt att ett snedstreck skapar ett delobjekt av misstag. Här hittar du också väljarlägen, om hela raden i komponenter med flera kolumner ska markeras, med mera.
Om du leker med en layout och förlorar en grafisk komponent bakom en annan, eller utanför formuläret, är objektutforskaren praktisk. Den är också bra för att se strukturen. Nästa mycket användbara vy är loggvyn, som visar standardutmatning och standardfelutmatning. Felvyn är ovärderlig. Det är här dina debug()-kommandon skrivs ut, och stället där du får detaljerad information. Exempelvis, när du använder databasinsticksprogrammet ger det ytterligare information vid datafel. Det visar också alla skalanrop med mera. Standardutmatningsvyn låter dig se vad som skulle visas av skalet eller ett program som använder detta, som Quanta. Dialogvyn är inte särskilt användbar, om du inte har många dialogrutor öppna. Åtgärdsvyn är bara aktiv vid användning med ett huvudfönster, och är i detta fall det enda sättet att lägga till åtgärder, menyer och objekt i verktygsrader.
Kommander gör det enkelt att lägga till egna verktyg i editorn, som du kan utveckla med Kommander. Vi kommer att leverera några med Kommander, samt göra några tillgängliga för nerladdning. Du kan enkelt lägga till egna. Ta först en titt och se var de finns. Om de är installerade, finns de i verktygsmenyn under avdelaren. Menyn i Kommander ger tillgång till grafiska komponenter. Menyn Egna ger tillgång till installerade insticksprogram. Menyn Editor är stället där dina egna verktyg hamnar. För att lägga till ett verktyg för hand, bestäm dig först för om det ska vara tillgängligt för hela systemet eller bara ditt skrivbord. För hela systemet används katalogen som KDE är installerad i. För skrivbordet används den dolda KDE-katalogen i din hemkatalog, oftast ~/.kde. Därifrån är sökvägen /share/apps/kmdr-editor/editor/ i båda fallen. Om dialogrutan du lägger till behöver komma åt verktyg eller filer, kan du lägga dem i en underkatalog. Vilka Kommander-dialogrutor du än lägger till där, kommer att kännas igen och läggas till i menyn vid start. Genom att klicka på menyalternativet laddas dialogrutan. Du bör också notera att det finns en mallkatalog där, och du kan lägga till nya mallar för nya dialogrutor.
Flera verktyg ingår i den här utgåvan, och är redan installerade i editorns verktygsmeny. Fler verktyg för projekthantering, gränssnitt för databasutveckling, kodsnuttar, med mera, håller på att utvecklas. Det viktigaste och mest användbara verktyget att titta på är dialogrutan med exempel. Eftersom editorn inte längre utvecklas för KDE3, kan den inte infoga en dialogruta i den aktuella editorn, utan dialogruta som väljes öppnas i en ny instans av editorn. Det finns gamla dialogrutor från Kommanders barndom, handledningar från senare utveckling och det aktuella avsnittet, som visar nya funktioner i den här utgåvan. Att titta på dessa bör vara till hjälp. Håll ett öga på vår webbsida för mer.
Många tycker om att dela med sig av sina Kommander-dialogrutor. Nästan utan undantag, känner de inte till hur man hanterar layouter. Skapa en dialogruta och försök därefter ändra storleken, så ser du vad som händer. Vore det inte trevligare om den skulle bete sig som den borde istället för att lämna de grafiska komponenterna oförändrade? Det blir värre när du delar med dig av den, och skillnader i teckensnitt, bildskärm och upplösning i bildpunkter samverkar för att få ditt mästerverk att se ut som om det var ihopsatt av en treåring med tuggummi och häftstift. Använd alltid, alltid, alltid en layout i dina dialogrutor!
Ok, du är övertygad, och vill inte få besviken e-post från mig som ber dig att använda en layout i din dialogruta. Hur gör man det då? Det finns layoutknappar i verktygsraden och alternativ i den sammanhangsberoende menyn. Eftersom Kommander är baserad på en äldre version av Qt Designer, kan du titta på Qt Designers dokumentation och handledningar. Några grunder och ett antal tips är allt som nämns här.
Använd rutnätet. Det placerar allting på platser som är “goda gissningar”.
Kom ihåg att omgivande komponenter är separata. En flikkomponent, gruppruta eller layoutgrupp har sin egen layout. Glöm alltså inte bort fönstret.
Komponenter som inte är synliga under körning kan orsaka att en layout verkar mer utmanande. Vad ska man göra med dem? Jag rekommenderar att de grupperas i en egen layout intill eller under huvudlayouten. De synliga komponenterna knuffar helt enkelt undan dem, och ger dig ett förutsägbart resultat.
Titta på egenskaperna, där du kan ställa in en komponent att expanderas eller andra saker, samt minimal och maximal storlek. Några experiment lär dig en hel del. Du kan också ställa in mindre mellanrum här.
Nu följer ett antal trick och tips.
Tillsammans med grundläggande layouter kan du använda avdelare. När dialogrutan kör kan du dra avdelaren uppåt och neråt, eller åt höger och åt vänster för att se saker bättre. Det kan verka som om det finns en begränsning här eller att det inte fungerar, men det fungerar och har inga begränsningar. Försäkra dig bara om att placera olika komponenter i två layouter, och högerklicka för att få layouten och inte bara en underliggande komponent. Du har full frihet att skapa en labyrint med avdelare, under förutsättning att du följer reglerna.
Dolda rutor kan användas. Skapa en gruppruta och släpp komponenter på den. Placera den i layouten så att andra komponenter eller layouter expanderas för att uppta dess plats när den är dold. Ändra nu synligheten med en knapp eller en meny.
Trick med verktygslådan: Verktygslådan har ett fel i editorn som gör att man inte kan lägga till komponentrutor i editorn utan att bli tokig. Resultatet är att man måste lägga till dem vid körning. Dock letar den efter en komponent, och om du vill ha någonting komplicerat bör du använda en gruppruta med en layout, och skapa en layout i dialogrutan med grupprutan längst ut, även om den hamnar utanför fönstrets kanter. Ladda den nu vid initiering i verktygslådan. Fönsterlayouten hoppar då på plats.
Layoutproblem kan uppstå där komponenter som är inställda till något som liknar minimalt/expanderande kan råka bli dolda innan fönstrets layout är klar. Layoutsystemet lyder dina konstigheter, och kan krympas så att rullningslister och annat döljs. Försäkra dig om att allt är synligt innan du gör färdigt layouten, och fundera på att inte använda minimalt i detta fall.
För mer om detta slå upp Qt Designer dokumentation för Qt 3.x.
En av de många användbara funktionerna som ärvdes av Qt Designer är signaler och slots. Naturligtvis har gränssnittet konstruerats om i ett försök att göra det lämpligt för Kommander. Signaler och slots hanterar styrning av interna händelser i Qt- och KDE-program. Vi försöker anpassa det så att du inte behöver kunna skillnaden mellan datatyper i C++, men om du använder de nya funktionerna för att skapa anslutningar i farten är det praktiskt att kunna kopiera informationen från anslutningsverktyget. Låt oss ta en titt på vad det betyder. Någonting inträffar i en av dina komponenter. Den kanske tar emot ett klick, ett dubbelklick, får sitt värde ändrat, något markeras, eller en meny begärs. Det är bara några av de möjliga händelser som skulle göra att en signal skickas. Du kanske vill ändra listan i en listruta om en ny markering görs i en kombinationsruta. Det är en användbar funktion i ett avancerat program, och det enda sättet att göra det utan att därefter behöva klicka på en knapp, är att ha en signal ansluten till en slot. En sådan slot kan vara i ett skript eller en knapp. När en signal tas emot ser denna slot till att göra vad den blev ombedd. Det finns ett verktyg för att redigera anslutningarna. Var uppmärksam när du gör detta, eftersom det finns ett stort antal ärvda signaler och slots. Att tala om för ett skript, som är osynligt när dialorgutan körs, att justera sin storlek när du istället ville köra det, får dig säkert att undra vad som hände.
Du kan öppna anslutningsverktyget genom att högerklicka var som helst i dialogrutan och välja det i menyn. Klicka på menyn så ser du en lista med gjorda anslutningar längst ner. Ovanför visas två listor med signaler och slots, och ovanför dem respektive sändare och mottagare som är vald. Ett enkelt sätt att skapa anslutningar är visuellt. Titta i verktygsraden eller i verktygsmenyn. Där finns tre objekt i en grupp. En pekare, anslutningar av signaler och slots, och flikordningen eller komponenterna. För de nyfikna: att välja den ställer in anslutningsläget. Klicka på komponenten för att skicka signalen och dra den till komponenten som ska ta emot den i en slot. När du gör det ser du en linje och en indikering om var du släpper på komponenten under musen. Editorns statusrad talar om för dig vad som kommer att anslutas.
I Kommander version 1.3 finns funktionen connect() som låter dig ansluta signaler och slots i farten. Det är användbart om du just har använt createWidget. Naturligtvis kan du inte använda dialogrutan för något som Kommander ännu inte vet existerar. Tyvärr finns det för många kombinationer för att lista, så du måste skriva in signaler och slots. De måste skrivas exakt rätt, annars fungerar de inte. Här är anslutningsverktyget återigen praktiskt. Öppna det och välj två komponenter som motsvarar de du vill ansluta, och läs av anslutningsinformationen. Om den lyder execute(const QString&), är det exakt vad du måste skriva in.
Från Kommander version 1.3 har slot-funktioner lagts till. Det kan du se i funktionsbläddraren, som ovanligt nog inte ger så bra beskrivningar i detta fall. Vad Kommander gör är att läsa in varje slot som är registrerad i en given komponent, och direkt göra dem tillgängliga. Det är mycket användbart. Tabellkomponenten har till exempel inte en standardmetod för att automatiskt justera kolumnbredden. Du kan tycka att det är irriterande, men titta bara under slots så hittar du den. Texteditorn saknar också inbyggda funktioner för någon verklig redigering, men titta under slots så finns allt du kan önska. Du kan behöva titta i några dokument, eller bara experimentera. Det är helt enkelt för svårt att dokumentera varje slot tillgänglig i inbyggda komponenter och insticksprogram. De flesta är dock självförklarliga.
Det mesta av informationen i det här avsnittet är baserat på dialogrutor med exempel från länge sedan, vilka tyvärr inte var allmänt tillgängliga, eftersom de levererades med källkoden men inte installerades. Du hittar dem i verktygsmenyn under exempel i “handledningsdelen”. Kom ihåg att de flesta av dessa exempel använder den gamla tolken. Det är varken bra eller dåligt. De flesta av funktionerna i Kommander delas mellan båda tolkarna. Nu använder Kommander normalt den nya tolken, men du kan ställa in vilken som helst. Se dokumentationen om den nya tolken för mer information om de två tolkarna.
När du betraktar exempeldialogrutorna, kom då ihåg att titta på följande ställen för att se hur saker är gjorda.
Dialoginitiering: Klicka med mittenknappen på dialogrutans yta, eller högerklicka och välj Kommander text. Här ser du vad som körs när dialogrutan startar.
Knappar: Klicka med mittenknappen på knappen, eller högerklicka. Typiskt finns det skript här.
Komponenter: Vissa komponenter som tidtagning och konsol innehåller instruktioner.
Signaler och slots: Det är sättet som Qt- och KDE-program kommunicerar internt.
Följande lista med dialogrutor kan vara korta för att fokusera på var mer information krävs för att förklara mer komplexa uppgifter som är möjliga med Kommander. De är kopierade från Michals anteckningar.
Visar hur DCOP-anropen global och setGlobal används för att tillhandahålla globala variabler för skript.
Funktioner, koncept: global - setGlobal - changeWidgetText
Visar hur både lokala och externa DCOP-anrop används för att kommunicera med externa program (här Kmail).
Funktioner, koncept: extern DCOP - addListItem - enableWidget - @selectedWidgetText - @widgetText
Visar hur anslutningar och slots används för att hantera händelser. Både ifyllnads- och vanliga slots används.
Ifyllnadstext utvecklades ursprungligen innan DCOP, specialvärden och skript i Kommander. Eftersom allt den gör kan göras på andra sätt, och att det är lätt att glömma bort att leta efter problem här, samt den inneboende svårigheten att introducera ett ytterligare beteende att förklara, avråds funktionen från att användas. Den finns kvar av illustrationssyfte, och även om det kommer att vara enkelt att anpassa Kommander dialogrutor till KDE 4, garanteras inte att den här funktionen kommer att fortsätta fungera i framtiden. Använd den inte!
Vanliga slots används. slots och anslutningar - populate()
Visar hur funktionerna @readSetting och @writeSetting används för att skriva och återställa komponentinnehåll. Visar också hur ifyllnadslots används för att initiera komponentinnehåll.
Funktioner, koncept: @readSetting - @writeSetting - populate() - slots och anslutningar - destroy
Visar hur du kan lägga till text i Texteditor och hur du kan använda den för att visa formaterad text. Se också nyare exempel på hur slots används för att editera formaterad text samt nya dialogrutor för teckensnitt och färg.
Funktioner, koncept: changeWidetText - RichTextEdit
Visar hur du kan skicka parametrar till Kommander dialogrutor via kommandoraden. Visar också hur innehåll i listor och knapptexter kan ändras. Se avsnittet om hur man skickar argument med den nya tolken för mer om detta.
Funktioner, koncept: kommandoradsväljare - global - changeWidgetText - addListItem - clearList
Visar hur du använder skripten 'initialization' och 'destroy' i huvuddialogrutan för att initiera och lagra vissa inställningar.
Funktioner, koncept: initialization - destroy - readSetting - writeSetting
Visar hur associativa fält används för att lagra och återställa information som hör ihop med omgivande objekt.
Funktioner, koncept: @Array funktioner
Visar hur funktioner för stränghantering används
Funktioner, koncept: @String funktioner - rik texteditor
Visar hur funktionen @expr används för att göra några beräkningar
expr - String.replace
Funktionen @expr() behövs inte längre i den nya tolken eftersom uttryck direkt kan tolkas var som helst där du logiskt vill använda dem.
Visar hur komponenten punktavbildningsetikett använder funktionen populate()
punktavbildningsetikett - populate - filväljare - slots och anslutningar
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Följande exempel speglar de senaste utvecklingarna av Kommander. I dess nuvarande skick har Kommander få begränsningar vid utveckling av små till medelstora program. Det är definitivt inte lämpad att utveckla en ny version av Kword, men för en enkel editor, ett databasgränssnitt, ett grafiskt gränssnitt för ett kommandoradsprogram eller något annat program som följer andemeningen i Unix och Linux med små program, är det ett bra val. Avsikten med de exempel som presenteras här är att visa potentialen, samt hur man går runt begränsningar. Några användbara trick ingår i dem, om du vill skapa ett mer kapabelt program med Kommander. Kom ihåg att Kommander inte är avsett att göra allt, utan att göra det mesta. Med detta i åtanke, bör du kunna bygga något i Kommander snabbare än med andra alternativ, och lägga till ett grafiskt gränssnitt till skriptspråk som inte stöds på annat sätt i KDE.
Exemplen är installerade under $KDEDIR/share/apps/kmdr-editor/editor. Ifall du inte har dem där, hämta dem på vår hemsida, genom att ladda ner den senaste utgåvan.
Den lilla dialogrutan som växte till ett huvudfönster. Eftersom Kommander inte har en inbyggd grafisk komponent för huvudfönster har det antagits att bara dialogrutor kan hanteras. I själva verket stöds bara dialogrutor officiellt, men du kan köra huvudfönster i Kommander. Det här är ett exempel på en editor. Om du vill skapa ett program med ett huvudfönster i Kommander, starta bara Qt Designer och skapa ett. Byt därefter namn på *.ui-filen till en *.kmdr-fil. Öppna den nu i Kommander och gör vad du skulle gjort i vanliga fall.
När det här skrivs är det känt att det inte fungerar att skriva eller läsa inställningar under Kommander. Initialize och Destroy finns inte, eftersom det inte finns någon Kommander-text, men det finns dock signaler för dem i fönstret, så funktionen är intakt. Under huvudfönstret är det inte möjligt att använda några åtgärder via DCOP, eftersom de är QActions från Designer, och KActions härleds inte från QActions i KDE 3.x. Det betyder att ett DCOP-anrop för att lista åtgärder eller ange tillstånd inte fungerar. Det är inte heller möjligt att komma åt statusraden. Inte heller undermenyer i menyraden eller kombinationsåtgärder i verktygsraden fungerar. Även om detta inte är en grafisk komponent i Kommander, eller något som officiellt stöds, verkar det lämpligt för användning i många små program.
Det finns en dialogruta för snabbhjälp som editorn visar, som grundligt beskriver vad som händer inuti.
Kommander kan användas med databaser, och har ett valfritt databasinsticksprogram. En svaghet är att man inte kan lagra par av nycklar och värden i kombinationsrutan. Ett klurigt trick hanterar detta. Det kräver bara att innehållet i kombinationsrutan inte ändras utan att det görs via fälten som hör ihop med den. Eftersom detta oftast används med SQL i små datamängder, går det rätt snabbt att till och med ladda om hela kombinationsrutan. Det inneboende problemet är att Kommander normalt inte har internt indexerade fält. Det förvärras av det faktum att för att hantera skalkommandon som returnerar rader åtskilda med nyradstecken, laddar Kommanders fältfunktioner vad som i själva verket är ett fält av nycklar. Sådana fält kan bara kommas åt via en foreach-snurra. Det är orsaken att nya indexerade fältfunktioner har lagts till. Det är viktigt att komma ihåg att dessa fält inte hanteras av sig självt, men deras funktioner för att infoga och ta bort värden hjälper dig med det.
För att återgå till kombinationsrutan, så returnerar den markerad text, men den returnerar också aktuellt index. Den hanterar strikt ett nollbaserat fält i en följd. Det är nyckeln. Vi går igenom en datamängd med en nollbaserad indexräknare och skapar två fält, eftersom Kommander inte heller kan skapa fält bestående av fält. Den kan dock använda ett fältvärde för att representera en nyckel, precis som vilket värde som helst skulle kunna göra. Om du tar en titt på dialogrutan som ingår, finns koden som faktiskt hanterar detta i “ScriptObject36”. Vi visar ett utdrag av koden här.
c = ListBox1.count-1
for i = 0 to c do
array_indexedFromString("x", ListBox1.item(i))
_a[x[0]] = x[1]
_b[i] = x[0]
ComboBox10.insertItem(_a[_b[i]], i)
end
Det är mer som sker, som kontroll av duplicerade nycklar, men detta är kärnan. Du kan högerklicka på listrutan och prova menyalternativen. Slutresultatet är att den använder nyckelindex via en proxy, och returnerar både nyckel och värde. Använd koden om du vill vara 100 % säker på att förhållandet mellan nyckel och värde är exakt.
Från Kommander 1.3, skapar Kommander automatiskt KPart-delprogram med libkommander_part.la. Förutom det finns ett KPart-insticksprogram som låter Kommander ladda insticksprogram. Eftersom vi är nyfikna utvecklare, försökte vi ladda ett Kommander-delprogram i Kommander. Varför ska man göra det? Ja, varför inte? Resultatet var intressant, och demonstreras här. En intressant sak är att det omgivande delprogrammet direkt kan komma åt allt i det inladdade delprogrammet. Även om det är praktiskt, har det en nackdel. Alla underliggande komponenter med samma namn som i det omgivande delprogrammet orsakar en låsning. Dessutom skapas DCOP-gränssnittet om igen för delprogrammet, vilket suddar ut gränssnittet i det omgivande delprogrammet, och inaktiverar stora delar av den gamla tolkens funktion, samt Kommander-specifik DCOP för det omgivande delprogrammet. Det är för svårt att rätta under KDE 3-versionens återstående livstid. Även med dessa begränsningar och varningar, kan det vara användbart, om det används med försiktighet. Exempelfilerna som använder sig av det finns bland de aktuella exemplen i kpartmwframe.kmdr och kpartpart.kmdr. Kom ihåg att du behöver KPart-insticksprogrammet för att kunna köra exemplet fullständigt.
Du kan också ladda Kmail, Korganizer och många andra KDE-program direkt i Kommander, naturligtvis utan problem. KHTML och KDE:s filhanteringskomponenter verkar inte ha vissa funktioner, men det finns ett särskilt KHTML-insticksprogram om du verkligen vill inkludera en webbläsare.
Från Kommander 1.3 kan du skicka och returnera variabler med skript. Den här dialogrutan demonstrerar det. Titta noga på knapparnas innehåll. Du märker att ingen av knapparna skriver direkt i någon av radeditorrutorna som tar emot text från skriptet. Medan en skrivs direkt från skriptet, skrivs en annan med innehållet som skickas från knappen. Den tredje skrivs inte alls, men skickas tillbaka med funktionen return(), där den tas emot av knappen och skrivs. Det visas också på höger sida med PHP, så du ser hur det skulle kunna fungera med Python, Ruby, Perl eller till och med ett mindre vanligt språk som Rexx. Språk som hanterar DCOP kan också göra mycket mer i Kommander. Demonstrationens syfte är att visa friheten som erbjuds. Kommander har inte funktioner, men ändå finns de. Skapa ett skript, deklarera några globala variabler om du vill, skicka några parametrar till ett annat skript och returnera ett värde. För ett med avsikt förenklat skriptverktyg för grafiska användargränssnitt är det ett kapabelt beteende. Beteendet finns bara i den nya tolken, och dokumenteras här.
Exemplet demonstrerar hur den nya markeringsfunktionen används i tabellkomponenten. Det är nu möjligt att få fyra koordinater för att göra det möjligt att markera ett block. Det visar också hur man hade varit tvungen att göra innan den nya funktionen, och hur parametrarna som skickas till ett skript används. Dessutom demonstrerar det en enkel blockkopierings- och inklistringsfunktion för en tabell, samt en sammanfattning av ett block.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Listan med vanliga frågor finns på vår hemsida.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Utvecklingsgruppen för Kommander
(consume AT optusnet.com.au)Utvecklare och dokumentation
(tik AT acm.org)Dokumentation
(sequitur AT kde.org)Projektledare och dokumentation
(amantia AT kde.org)Utvecklare
(mrudolf AT kdewebdev.org)Utvecklare
Kommander © 2004 - 2008 Utvecklingsgruppen för Kommander
Handbok Kommander © 2004 - 2008 Utvecklingsgruppen för Kommander
Översättning Stefan Asserhäll (stefan.asserhall AT comhem.se)
Den här dokumentationen licensieras under villkoren i GNU Free Documentation License.
Det här programmet licensieras under villkoren i GNU General Public License.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Innehållsförteckning
Kommander är en del av KDE-projektet http://www.kde.org/.
Kommander finns i kdewebdev-paketet på ftp://ftp.kde.org/pub/kde/, KDE-projektets huvudsakliga FTP-plats.
Det finns en egen hemsida för Kommander på http://kommander.kdewebdev.org.
Kommander kräver den senaste versionen av KDE 3-serien, för närvarande 3.5.9. Den kan fungera med tidigare versioner av 3.5, men det har inte provats utförligt.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
För att kompilera och installera Kommander på ditt system, skriv följande i baskatalogen för distributionen av Kommander:
%./configure%make%make install
Eftersom Kommander använder autoconf och automake bör du inte ha några problem med att kompilera det. Skulle du stöta på problem, var snäll rapportera dem till KDE:s e-postlistor.
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team
Would you like to make a comment or contribute an update to this page?
Send feedback to the KDE Docs Team