curses — Terminalhantering för tecken-cell-displayer

Källkod: Lib/curses

---

Modulen curses ger ett gränssnitt till curses-biblioteket, de facto-standarden för portabel avancerad terminalhantering.

Även om curses används mest i Unix-miljön finns det versioner för Windows, DOS och eventuellt andra system. Denna tilläggsmodul är utformad för att matcha API:et i ncurses, ett curses-bibliotek med öppen källkod som finns på Linux och BSD-varianterna av Unix.

Tillgänglighet: not Android, not iOS, not WASI.

Denna modul stöds inte på mobile platforms eller WebAssembly platforms.

Anteckning

Närhelst dokumentationen nämner ett tecken kan det anges som ett heltal, en Unicode-sträng med ett tecken eller en byte-sträng med en byte.

När dokumentationen nämner en teckensträng kan den anges som en Unicode-sträng eller en byte-sträng.

Se även

Modul curses.ascii

Verktyg för att arbeta med ASCII-tecken, oberoende av dina lokala inställningar.

Modul curses.panel

En panel stack extension som ger djup till curses-fönster.

Modul curses.textpad

Redigerbar textwidget för curses med stöd för Emacs-liknande bindningar.

Curses-programmering med Python

Handledningsmaterial om hur man använder curses med Python, av Andrew Kuchling och Eric Raymond.

Funktioner

Modulen curses definierar följande undantag:

exception curses.error

Undantag som uppstår när en funktion i curses-biblioteket returnerar ett fel.

Anteckning

När x eller y argument till en funktion eller en metod är valfria, används de som standard till den aktuella markörpositionen. När attr är valfritt, är det standardvärdet A_NORMAL.

Modulen curses definierar följande funktioner:

curses.assume_default_colors(fg, bg, /)

Tillåt användning av standardvärden för färger på terminaler som stöder denna funktion. Använd detta för att stödja transparens i din applikation.

• Tilldela terminalens standardfärger för förgrund/bakgrund till färgnumret -1. Så init_pair(x, COLOR_RED, -1) initierar paret x som rött på standardbakgrund och init_pair(x, -1, COLOR_BLUE) initierar paret x som standardförgrund på blått.

• Ändra definitionen av färgparet 0 till (fg, bg).

Tillagd i version 3.14.

curses.baudrate()

Returnerar terminalens utmatningshastighet i bitar per sekund. På mjukvaruterminalemulatorer kommer den att ha ett fast högt värde. Inkluderad av historiska skäl; förr i tiden användes den för att skriva utmatningsloopar för tidsfördröjningar och ibland för att ändra gränssnitt beroende på linjehastigheten.

curses.beep()

Avge ett kort uppmärksamhetsljud.

curses.can_change_color()

Returnerar True eller False, beroende på om programmeraren kan ändra färgerna som visas av terminalen.

curses.cbreak()

Gå till cbreak-läge. I cbreak-läge (ibland kallat ”rare”-läge) stängs den normala buffringen av tty-linjer av och tecken kan läsas ett efter ett. Till skillnad från raw-läget behåller dock specialtecken (interrupt, quit, suspend och flow control) sina effekter på tty-drivrutinen och det anropande programmet. Om du först anropar raw() och sedan cbreak() lämnas terminalen i cbreak-läge.

curses.color_content(color_number)

Returnerar intensiteten för de röda, gröna och blå (RGB) komponenterna i färgen color_number, som måste ligga mellan 0 och COLORS - 1. Returnerar en 3-tupel som innehåller R,G,B-värdena för den angivna färgen, som kommer att ligga mellan 0 (ingen komponent) och 1000 (maximal mängd komponent).

curses.color_pair(pair_number)

Returnerar attributvärdet för visning av text i det angivna färgparet. Endast de första 256 färgparen stöds. Detta attributvärde kan kombineras med A_STANDOUT, A_REVERSE och de andra A_*-attributen. pair_number() är motsvarigheten till denna funktion.

curses.curs_set(visibility)

Ställer in markörens tillstånd. visibility kan sättas till 0, 1 eller 2, för osynlig, normal eller mycket synlig. Om terminalen stöder den begärda synligheten, returneras det tidigare markörtillståndet; annars uppstår ett undantag. På många terminaler är läget ”synlig” en understruken markör och läget ”mycket synlig” en blockmarkör.

curses.def_prog_mode()

Sparar det aktuella terminalläget som ”program”-läge, det läge då det program som körs använder curses. (Dess motsvarighet är ”shell”-läget, för när programmet inte använder curses.) Efterföljande anrop till reset_prog_mode() kommer att återställa detta läge.

curses.def_shell_mode()

Spara det aktuella terminalläget som ”shell”-läge, det vill säga det läge då det program som körs inte använder curses. (Dess motsvarighet är ”program”-läget, när programmet använder curses-funktioner) Efterföljande anrop till reset_shell_mode() kommer att återställa detta läge.

curses.delay_output(ms)

Infoga en ms millisekunds paus i utmatningen.

curses.doupdate()

Uppdatera den fysiska skärmen. Curses-biblioteket har två datastrukturer, en som representerar det aktuella fysiska skärminnehållet och en virtuell skärm som representerar det önskade nästa tillståndet. Med doupdate() uppdateras den fysiska skärmen så att den matchar den virtuella skärmen.

Den virtuella skärmen kan uppdateras genom ett noutrefresh()-anrop efter att skrivoperationer som addstr() har utförts på ett fönster. Det normala refresh()-anropet är helt enkelt noutrefresh() följt av doupdate(); om du måste uppdatera flera fönster kan du öka prestandan och kanske minska skärmflimmer genom att utfärda noutrefresh()-anrop på alla fönster, följt av en enda doupdate().

curses.echo()

Gå till ekoläge. I ekoläge ekas varje tecken som matas in på skärmen när det matas in.

curses.endwin()

Avinitialisera biblioteket och återställ terminalen till normal status.

curses.erasechar()

Returnerar användarens aktuella raderingstecken som ett objekt på en byte. Under Unix-operativsystem är detta en egenskap hos den tty som styr curses-programmet, och ställs inte in av själva curses-biblioteket.

curses.filter()

Rutinen filter(), om den används, måste anropas innan initscr() anropas. Effekten är att, under dessa anrop, LINES sätts till 1; funktionerna clear, cup, cud, cud1, cuu1, cuu, vpa inaktiveras; och strängen home sätts till värdet av cr. Effekten blir att markören begränsas till den aktuella raden, och det gäller även skärmuppdateringar. Detta kan användas för att göra det möjligt att redigera en rad med ett tecken i taget utan att röra resten av skärmen.

curses.flash()

Flasha skärmen. Det vill säga, ändra till omvänd video och sedan ändra tillbaka igen med kort intervall. Vissa människor föredrar en sådan ”synlig klocka” framför den hörbara uppmärksamhetssignal som produceras av beep().

curses.flushinp()

Töm alla inmatningsbuffertar. Detta kastar bort all typahead som har skrivits av användaren och som ännu inte har bearbetats av programmet.

curses.getmouse()

Efter att getch() returnerar KEY_MOUSE för att signalera en mushändelse, bör denna metod anropas för att hämta den köade mushändelsen, representerad som en 5-tupel (id, x, y, z, bstate). id är ett ID-värde som används för att särskilja flera enheter, och x, y, z är händelsens koordinater. (z är för närvarande oanvänd.) bstate är ett heltalsvärde vars bitar ställs in för att ange händelsetyp och är det bitvisa ELLER-värdet av en eller flera av följande konstanter, där n är knappnumret från 1 till 5: BUTTONn_PRESSED, BUTTONn_RELEASED, BUTTONn_CLICKED, BUTTONn_DOUBLE_CLICKED, BUTTONn_TRIPLE_CLICKED, BUTTON_SHIFT, BUTTON_CTRL, BUTTON_ALT.

Ändrad i version 3.10: Konstanterna BUTTON5_* exponeras nu om de tillhandahålls av det underliggande curses-biblioteket.

curses.getsyx()

Returnerar de aktuella koordinaterna för den virtuella skärmens markör som en tupel (y, x). Om leaveok för närvarande är True, returneras (-1, -1).

curses.getwin(file)

Läser fönsterrelaterade data som lagrats i filen genom ett tidigare window.putwin()-anrop. Rutinen skapar och initialiserar sedan ett nytt fönster med hjälp av dessa data och returnerar det nya fönsterobjektet.

curses.has_colors()

Returnerar True om terminalen kan visa färger; annars returneras False.

curses.has_extended_color_support()

Returnerar True om modulen stöder utökade färger, annars returneras False. Utökat färgstöd tillåter fler än 256 färgpar för terminaler som stöder fler än 16 färger (t.ex. xterm-256color).

För utökat färgstöd krävs ncurses version 6.1 eller senare.

Tillagd i version 3.10.

curses.has_ic()

Returnerar True om terminalen har funktioner för att infoga och ta bort tecken. Denna funktion är endast med av historiska skäl, eftersom alla moderna mjukvaruterminalemulatorer har sådana funktioner.

curses.has_il()

Returnerar True om terminalen har funktioner för att infoga och radera rader, eller kan simulera dem med hjälp av rullningsområden. Denna funktion är endast med av historiska skäl, eftersom alla moderna mjukvaruterminalemulatorer har sådana funktioner.

curses.has_key(ch)

Ta ett nyckelvärde ch och returnera True om den aktuella terminaltypen känner igen en nyckel med det värdet.

curses.halfdelay(tenths)

Används för halvfördröjningsläge, som liknar cbreak-läge genom att tecken som skrivs av användaren omedelbart är tillgängliga för programmet. Men efter att ha blockerat i tendelar tiondelar av sekunder, ska ett undantag uppstå om inget har skrivits. Värdet på tenths måste vara ett tal mellan 1 och 255. Använd nocbreak() för att lämna halvfördröjningsläget.

curses.init_color(color_number, r, g, b)

Ändra definitionen av en färg genom att ta numret på den färg som ska ändras följt av tre RGB-värden (för mängden röda, gröna och blå komponenter). Värdet på color_number måste ligga mellan 0 och COLORS - 1. Var och en av r, g, b måste vara ett värde mellan 0 och 1000. När init_color() används, ändras alla förekomster av den färgen på skärmen omedelbart till den nya definitionen. Denna funktion är inte tillgänglig på de flesta terminaler; den är endast aktiv om can_change_color() returnerar True.

curses.init_pair(pair_number, fg, bg)

Ändrar definitionen av ett färgpar. Den tar tre argument: numret på det färgpar som ska ändras, numret på förgrundsfärgen och numret på bakgrundsfärgen. Värdet på pair_number måste vara mellan 1 och COLOR_PAIRS - 1 (färgparet 0 kan endast ändras med use_default_colors() och assume_default_colors()). Värdet på argumenten fg och bg måste vara mellan 0 och COLORS - 1, eller, efter anrop av use_default_colors() eller assume_default_colors(), -1. Om färgparet tidigare har initialiserats uppdateras skärmen och alla förekomster av färgparet ändras till den nya definitionen.

curses.initscr()

Initialiserar biblioteket. Returnerar ett window-objekt som representerar hela skärmen.

Anteckning

Om det uppstår ett fel när terminalen öppnas kan det underliggande curses-biblioteket göra att tolken avslutas.

curses.is_term_resized(nlines, ncols)

Returnerar True om resize_term() skulle ändra fönsterstrukturen, False annars.

curses.isendwin()

Returnerar True om endwin() har anropats (det vill säga, curses-biblioteket har deinitialiserats).

curses.keyname(k)

Returnerar namnet på nyckeln numrerad k som ett bytesobjekt. Namnet på en nyckel som genererar ett utskrivbart ASCII-tecken är nyckelns tecken. Namnet på en kontrolltangentkombination är ett bytesobjekt på två byte som består av en caret (b'^') följt av motsvarande utskrivbara ASCII-tecken. Namnet på en alt-key-kombination (128–255) är ett bytesobjekt som består av prefixet b'M-' följt av namnet på motsvarande ASCII-tecken.

curses.killchar()

Returnerar användarens aktuella radavbrytningstecken som ett objekt med en byte. Under Unix-operativsystem är detta en egenskap hos den tty som styr curses-programmet och ställs inte in av själva curses-biblioteket.

curses.longname()

Returnerar ett bytesobjekt som innehåller terminfo long name-fältet som beskriver den aktuella terminalen. Den maximala längden på en utförlig beskrivning är 128 tecken. Den definieras endast efter anropet till initscr().

curses.meta(flag)

Om flag är True tillåts 8-bitars tecken att matas in. Om flag är False tillåts endast 7-bitars tecken.

curses.mouseinterval(interval)

Ställ in den maximala tid i millisekunder som kan förflyta mellan press- och releasehändelser för att de ska uppfattas som ett klick och returnera det tidigare intervallvärdet. Standardvärdet är 200 millisekunder, eller en femtedel av en sekund.

curses.mousemask(mousemask)

Ställ in vilka mushändelser som ska rapporteras och returnera en tupel (availmask, oldmask). availmask anger vilka av de angivna mushändelserna som kan rapporteras; vid fullständigt misslyckande returneras 0. oldmask är det tidigare värdet för det angivna fönstrets mushändelsemask. Om denna funktion aldrig anropas rapporteras aldrig några mushändelser.

curses.napms(ms)

Sömn i ms millisekunder.

curses.newpad(nlines, ncols)

Skapa och returnera en pekare till en ny pad-datastruktur med det angivna antalet rader och kolumner. Returnera en pad som ett window-objekt.

En pad är som ett fönster, förutom att den inte begränsas av skärmens storlek och inte nödvändigtvis är kopplad till en viss del av skärmen. Pads kan användas när ett stort fönster behövs och endast en del av fönstret visas på skärmen samtidigt. Automatiska uppdateringar av pads (t.ex. från scrollning eller eko av inmatning) sker inte. Metoderna refresh() och noutrefresh() för en pad kräver 6 argument för att specificera den del av padden som ska visas och den plats på skärmen som ska användas för visningen. Argumenten är pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol; p-argumenten hänvisar till det övre vänstra hörnet av den pad-region som ska visas och s-argumenten definierar en klippbox på skärmen inom vilken pad-regionen ska visas.

curses.newwin(nlines, ncols)

curses.newwin(nlines, ncols, begin_y, begin_x)

Returnerar ett nytt fönster, vars vänstra övre hörn är vid (begin_y, begin_x), och vars höjd/bredd är nlines/ncols.

Som standard kommer fönstret att sträcka sig från den angivna positionen till skärmens nedre högra hörn.

curses.nl()

Starta newline-läge. Detta läge översätter returtangenten till newline vid inmatning och översätter newline till retur och radmatning vid utmatning. Newline-läget är initialt aktiverat.

curses.nocbreak()

Lämna cbreak-läget. Återgå till normalt ”cooked”-läge med linjebuffring.

curses.noecho()

Lämna ekoläget. Ekot av inmatningstecken stängs av.

curses.nonl()

Lämna newline-läget. Inaktivera översättning av retur till ny rad vid inmatning och inaktivera lågnivåöversättning av ny rad till ny rad/retur vid utmatning (men detta ändrar inte beteendet hos addch('\n'), som alltid gör motsvarande retur och radmatning på den virtuella skärmen). Med översättning avstängd kan curses ibland snabba upp den vertikala rörelsen lite; den kommer också att kunna upptäcka return-tangenten på inmatningen.

curses.noqiflush()

När rutinen noqiflush() används, sker ingen normal rensning av in- och utmatningsköerna i samband med tecknen INTR, QUIT och SUSP. Du kanske vill anropa noqiflush() i en signalhanterare om du vill att utdata ska fortsätta som om avbrottet inte hade inträffat, efter att hanteraren har avslutats.

curses.noraw()

Lämna rått läge. Återgå till normalt ”cooked”-läge med linjebuffring.

curses.pair_content(pair_number)

Returnerar en tupel (fg, bg) som innehåller färgerna för det begärda färgparet. Värdet på pair_number måste ligga mellan 0 och COLOR_PAIRS - 1.

curses.pair_number(attr)

Returnerar numret på det färgpar som anges av attributvärdet attr. color_pair() är motsvarigheten till denna funktion.

curses.putp(str)

Motsvarar tputs(str, 1, putchar); ger ut värdet av en angiven terminfo-kapacitet för den aktuella terminalen. Observera att utdata från putp() alltid går till standardutdata.

curses.qiflush([flag])

Om flag är False är effekten densamma som att anropa noqiflush(). Om flag är True, eller om inget argument anges, kommer köerna att tömmas när dessa kontrolltecken läses.

curses.raw()

Gå till raw-läge. I raw mode är normal linjebuffring och bearbetning av avbrott, quit, suspend och flödeskontrollknappar avstängda; tecken presenteras för curses inmatningsfunktioner en efter en.

curses.reset_prog_mode()

Återställ terminalen till ”program”-läge, som tidigare sparats av def_prog_mode().

curses.reset_shell_mode()

Återställer terminalen till ”shell”-läge, som tidigare sparats av def_shell_mode().

curses.resetty()

Återställer tillståndet för terminallägena till vad det var vid det senaste anropet till savetty().

curses.resize_term(nlines, ncols)

Backend-funktion som används av resizeterm() och som utför det mesta av arbetet; vid ändring av fönsterstorlek fyller resize_term() i de områden som utökas. Den anropande applikationen bör fylla i dessa områden med lämpliga data. Funktionen resize_term() försöker ändra storlek på alla fönster. På grund av anropskonventionen för pads är det dock inte möjligt att ändra storlek på dessa utan ytterligare interaktion med applikationen.

curses.resizeterm(nlines, ncols)

Ändrar storlek på standardfönstret och det aktuella fönstret till de angivna dimensionerna och justerar andra bokföringsdata som används av curses-biblioteket som registrerar fönsterdimensionerna (i synnerhet SIGWINCH-hanteraren).

curses.savetty()

Spara det aktuella tillståndet för terminallägena i en buffert, som kan användas av resetty().

curses.get_escdelay()

Hämtar det värde som ställdes in av set_escdelay().

Tillagd i version 3.9.

curses.set_escdelay(ms)

Ställer in antalet millisekunder som ska vänta efter att ett escape-tecken har lästs, för att skilja mellan ett enskilt escape-tecken som skrivs in på tangentbordet och escape-sekvenser som skickas med markör- och funktionstangenter.

Tillagd i version 3.9.

curses.get_tabsize()

Hämtar det värde som ställdes in av set_tabsize().

Tillagd i version 3.9.

curses.set_tabsize(size)

Anger antalet kolumner som används av curses-biblioteket när ett tabbtecken konverteras till mellanslag när tabben läggs till i ett fönster.

Tillagd i version 3.9.

curses.setsyx(y, x)

Ställ in markören på den virtuella skärmen till y, x. Om y och x båda är -1, sätts leaveok <window.leaveok>`() till True.

curses.setupterm(term=None, fd=-1)

Initialiserar terminalen. term är en sträng som anger terminalens namn, eller None; om den utelämnas eller None, kommer värdet för miljövariabeln TERM att användas. fd är filbeskrivaren till vilken initialiseringssekvenser skickas; om den inte anges eller om -1, används filbeskrivaren för sys.stdout.

curses.start_color()

Måste anropas om programmeraren vill använda färger, och innan någon annan färgmanipuleringsrutin anropas. Det är god praxis att anropa denna rutin direkt efter initscr().

start_color() initierar åtta grundfärger (svart, röd, grön, gul, blå, magenta, cyan och vit) och två globala variabler i modulen curses, COLORS och COLOR_PAIRS, som innehåller det maximala antalet färger och färgpar som terminalen kan stödja. Den återställer också färgerna på terminalen till de värden de hade när terminalen precis hade slagits på.

curses.termattrs()

Returnerar ett logiskt ELLER av alla videoattribut som stöds av terminalen. Denna information är användbar när ett curses-program behöver fullständig kontroll över skärmens utseende.

curses.termname()

Returnera värdet för miljövariabeln TERM, som ett bytesobjekt, trunkerat till 14 tecken.

curses.tigetflag(capname)

Returnerar värdet för den booleska egenskapen som motsvarar terminfo-egenskapsnamnet capname som ett heltal. Returnerar värdet -1 om capname inte är en boolesk egenskap, eller 0 om den är avbruten eller saknas i terminalbeskrivningen.

curses.tigetnum(capname)

Returnerar värdet för den numeriska kapacitet som motsvarar terminfo-kapacitetsnamnet capname som ett heltal. Returnerar värdet -2 om capname inte är en numerisk kapacitet, eller -1 om den är avbruten eller saknas i terminalbeskrivningen.

curses.tigetstr(capname)

Returnerar värdet för strängkapaciteten som motsvarar terminfo-kapacitetsnamnet capname som ett bytesobjekt. Returnerar None om capname inte är en terminfo ”string capability”, eller är avbruten eller saknas i terminalbeskrivningen.

curses.tparm(str[, ...])

Instansiera bytesobjektet str med de angivna parametrarna, där str ska vara en parameteriserad sträng som hämtas från terminfo-databasen. T.ex. kan tparm(tigetstr("cup"), 5, 3) resultera i b'\033[6;4H', det exakta resultatet beror på terminaltyp.

curses.typeahead(fd)

Ange att filbeskrivaren fd ska användas för typhuvudkontroll. Om fd är -1 görs ingen typhuvudkontroll.

Curses-biblioteket gör ”line-breakout optimization” genom att leta efter typeahead med jämna mellanrum när skärmen uppdateras. Om inmatning hittas och den kommer från en tty, skjuts den aktuella uppdateringen upp tills refresh eller doupdate anropas igen, vilket ger snabbare svar på kommandon som skrivits i förväg. Den här funktionen gör det möjligt att ange en annan filbeskrivare för typahead-kontroll.

curses.unctrl(ch)

Returnerar ett bytesobjekt som är en utskriftsvänlig representation av tecknet ch. Kontrolltecken representeras av en caret följt av tecknet, t.ex. b'^C'. Utskriftstecken lämnas som de är.

curses.ungetch(ch)

Tryck ch så att nästa getch() returnerar den.

Anteckning

Endast en ch kan skjutas innan getch() anropas.

curses.update_lines_cols()

Uppdatera modulvariablerna LINES och COLS. Användbar för att upptäcka manuell skärmstorleksändring.

Tillagd i version 3.5.

curses.unget_wch(ch)

Tryck ch så att nästa get_wch() returnerar den.

Anteckning

Endast en ch kan skjutas innan get_wch() anropas.

Tillagd i version 3.3.

curses.ungetmouse(id, x, y, z, bstate)

Lägg till en händelse av typen KEY_MOUSE i indatakön och associera den med de angivna tillståndsuppgifterna.

curses.use_env(flag)

Om denna funktion används bör den anropas innan initscr() eller newterm anropas. När flag är False kommer värdena för rader och kolumner som anges i terminfo-databasen att användas, även om miljövariablerna LINES och COLUMNS (används som standard) är inställda, eller om curses körs i ett fönster (i vilket fall standardbeteendet skulle vara att använda fönsterstorleken om LINES och COLUMNS inte är inställda).

curses.use_default_colors()

Motsvarar assume_default_colors(-1, -1).

curses.wrapper(func, /, *args, **kwargs)

Initialiserar curses och anropar ett annat anropsbart objekt, func, som bör vara resten av din curses-användande applikation. Om programmet ger upphov till ett undantag kommer den här funktionen att återställa terminalen till ett sunt tillstånd innan undantaget ges upphov till ett nytt undantag och en spårning genereras. Det anropbara objektet func får sedan huvudfönstret ’stdscr’ som sitt första argument, följt av alla andra argument som skickas till wrapper(). Innan func anropas slår wrapper() på cbreak-läget, stänger av echo, aktiverar terminalens knappsats och initialiserar färger om terminalen har färgstöd. När programmet avslutas (normalt eller genom undantag) återställs cooked mode, echo slås på och terminalens knappsats inaktiveras.

Fönsterobjekt

Fönsterobjekt, som returneras av initscr() och newwin() ovan, har följande metoder och attribut:

window.addch(ch[, attr])

window.addch(y, x, ch[, attr])

Måla tecknet ch på (y, x) med attributen attr, och skriv över alla tecken som tidigare målats på den platsen. Som standard är teckenpositionen och attributen de aktuella inställningarna för fönsterobjektet.

Anteckning

Skrivning utanför fönstret, underfönstret eller padden ger upphov till ett curses.error. Om du försöker skriva till det nedre högra hörnet av ett fönster, underfönster eller block kommer ett undantag att uppstå efter att tecknet har skrivits ut.

window.addnstr(str, n[, attr])

window.addnstr(y, x, str, n[, attr])

Måla högst n tecken i teckensträngen str vid (y, x) med attributen attr och skriv över allt som tidigare visats på skärmen.

window.addstr(str[, attr])

window.addstr(y, x, str[, attr])

Måla teckensträngen str vid (y, x) med attributen attr och skriv över allt som tidigare visats på skärmen.

Anteckning

• Skrivning utanför fönstret, underfönstret eller dynan ger upphov till curses.error. Om du försöker skriva till det nedre högra hörnet av ett fönster, underfönster eller block kommer ett undantag att uppstå efter att strängen har skrivits ut.

• En bugg i ncurses, backend för denna Python-modul, kan orsaka SegFaults vid ändring av fönsterstorlek. Detta är åtgärdat i ncurses-6.1-20190511. Om du sitter fast med en tidigare ncurses kan du undvika att utlösa detta om du inte anropar addstr() med en str som har inbäddade nya linjer. Anropa istället addstr() separat för varje rad.

window.attroff(attr)

Ta bort attributet attr från ”background”-uppsättningen som används för alla skrivningar till det aktuella fönstret.

window.attron(attr)

Lägg till attributet attr från ”background”-uppsättningen som används för alla skrivningar till det aktuella fönstret.

window.attrset(attr)

Ställ in ”bakgrunds”-uppsättningen av attribut till attr. Denna uppsättning är initialt 0 (inga attribut).

window.bkgd(ch[, attr])

Ställ in fönstrets bakgrundsegenskap till tecknet ch, med attribut attr. Ändringen tillämpas sedan på varje teckenposition i det fönstret:

• Attributet för varje tecken i fönstret ändras till det nya bakgrundsattributet.

• Varhelst den tidigare bakgrundskaraktären dyker upp byts den ut mot den nya bakgrundskaraktären.

window.bkgdset(ch[, attr])

Ställ in fönstrets bakgrund. Ett fönsters bakgrund består av ett tecken och en valfri kombination av attribut. Attributdelen av bakgrunden kombineras (OR’ed) med alla icke-tomma tecken som skrivs in i fönstret. Både karaktärs- och attributdelen av bakgrunden kombineras med de tomma tecknen. Bakgrunden blir en egenskap hos tecknet och flyttas med tecknet genom alla skrollningar och operationer för att infoga/ta bort rader/tecken.

window.border([ls[, rs[, ts[, bs[, tl[, tr[, bl[, br]]]]]]]])

Rita en kant runt fönstrets kanter. Varje parameter anger vilket tecken som ska användas för en viss del av kanten; se tabellen nedan för mer information.

Anteckning

Ett värde 0 för en parameter innebär att standardtecknet används för den parametern. Nyckelordsparametrar kan inte användas. Standardvärdena anges i denna tabell:

Parameter	Beskrivning	Standardvärde
ls	Vänster sida	ACS_VLINE
rs	Höger sida	ACS_VLINE
ts	Topp	ACS_HLINE
bs	Botten	ACS_HLINE
tl	Övre vänstra hörnet	ACS_ULCORNER
tr	Övre högra hörnet	ACS_URCORNER
bl	Nedre vänstra hörnet	ACS_LLCORNER
br	Nedre högra hörnet	ACS_LRCORNER

window.box([vertch, horch])

Liknar border(), men både ls och rs är vertch och både ts och bs är horch. Standardhörntecknen används alltid av denna funktion.

window.chgat(attr)

window.chgat(num, attr)

window.chgat(y, x, attr)

window.chgat(y, x, num, attr)

Ställ in attributen för num tecken vid den aktuella markörpositionen, eller vid position (y, x) om den anges. Om num inte anges eller är -1, kommer attributet att sättas på alla tecken till slutet av raden. Denna funktion flyttar markören till position (y, x) om den anges. Den ändrade raden kommer att beröras med metoden touchline() så att innehållet visas igen vid nästa fönsteruppdatering.

window.clear()

Som erase(), men gör också att hela fönstret målas om vid nästa anrop till refresh().

window.clearok(flag)

Om flag är True kommer nästa anrop till refresh() att rensa fönstret helt och hållet.

window.clrtobot()

Radera från markören till slutet av fönstret: alla rader under markören raderas, och sedan utförs motsvarande clrtoeol().

window.clrtoeol()

Raderar från markören till slutet av raden.

window.cursyncup()

Uppdaterar den aktuella markörpositionen för alla fönstrets förfäder så att den återspeglar fönstrets aktuella markörposition.

window.delch([y, x])

Ta bort valfritt tecken vid (y, x).

window.deleteln()

Radera raden under markören. Alla följande rader flyttas upp med en rad.

window.derwin(begin_y, begin_x)

window.derwin(nlines, ncols, begin_y, begin_x)

En förkortning för ”derive window”, derwin() är samma sak som att anropa subwin(), förutom att begin_y och begin_x är relativa till fönstrets ursprung, snarare än relativa till hela skärmen. Returnerar ett fönsterobjekt för det härledda fönstret.

window.echochar(ch[, attr])

Lägg till tecken ch med attributet attr, och anropa omedelbart refresh() i fönstret.

window.enclose(y, x)

Testar om det givna paret av skärmrelativa teckencellskoordinater innesluts av det givna fönstret och returnerar True eller False. Det är användbart för att avgöra vilken delmängd av skärmens fönster som omsluter platsen för en mushändelse.

Ändrad i version 3.10: Tidigare returnerade den 1 eller 0 istället för True eller False.

window.encoding

Kodning som används för att koda metodargument (Unicode-strängar och -tecken). Kodningsattributet ärvs från moderfönstret när ett underfönster skapas, t.ex. med window.subwin(). Som standard används den aktuella locale-kodningen (se locale.getencoding()).

Tillagd i version 3.3.

window.erase()

Töm fönstret.

window.getbegyx()

Returnerar en tupel (y, x) av koordinaterna för det övre vänstra hörnet.

window.getbkgd()

Returnerar det givna fönstrets aktuella bakgrundskaraktär/attributpar.

window.getch([y, x])

Hämta ett tecken. Observera att det returnerade heltalet inte behöver ligga inom ASCII-området: funktionstangenter, knappsatser och så vidare representeras av tal högre än 255. I läget utan fördröjning returneras -1 om det inte finns någon inmatning, annars väntar man tills en tangent trycks in.

window.get_wch([y, x])

Hämta ett brett tecken. Returnerar ett tecken för de flesta tangenter, eller ett heltal för funktionstangenter, knappsatser och andra specialtangenter. I läget utan fördröjning uppstår ett undantag om det inte finns någon inmatning.

Tillagd i version 3.3.

window.getkey([y, x])

Hämta ett tecken och returnera en sträng i stället för ett heltal, som getch() gör. Funktionstangenter, knappsatser och andra specialtangenter returnerar en multibyte-sträng som innehåller tangentens namn. I läget utan fördröjning, gör ett undantag om det inte finns någon inmatning.

window.getmaxyx()

Returnerar en tupel (y, x) av fönstrets höjd och bredd.

window.getparyx()

Returnerar startkoordinaterna för detta fönster i förhållande till dess föräldrafönster som en tupel (y, x). Returnerar (-1, -1) om fönstret inte har någon förälder.

window.getstr()

window.getstr(n)

window.getstr(y, x)

window.getstr(y, x, n)

Läs ett bytesobjekt från användaren, med primitiv radredigeringskapacitet. Det maximala värdet för n är 2047.

Ändrad i version 3.14: Maxvärdet för n höjdes från 1023 till 2047.

window.getyx()

Returnerar en tupel (y, x) av aktuell markörposition i förhållande till fönstrets övre vänstra hörn.

window.hline(ch, n)

window.hline(y, x, ch, n)

Visa en horisontell linje som börjar vid (y, x) med längden n och som består av tecknet ch.

window.idcok(flag)

Om flag är False, överväger curses inte längre att använda terminalens maskinvarufunktion för att infoga/radera tecken; om flag är True, aktiveras användning av infogning och radering av tecken. När curses initieras första gången är användning av teckeninsättning/radering aktiverad som standard.

window.idlok(flag)

Om flag är True kommer curses att försöka använda hårdvarans funktioner för radredigering. Annars är radinklädning/radradering inaktiverat.

window.immedok(flag)

Om flag är True kommer varje förändring i fönsterbilden automatiskt att leda till att fönstret uppdateras; du behöver inte längre anropa refresh() själv. Det kan dock försämra prestandan avsevärt på grund av upprepade anrop till wrefresh. Detta alternativ är avaktiverat som standard.

window.inch([y, x])

Returnerar tecknet på den angivna positionen i fönstret. De nedre 8 bitarna är själva tecknet och de övre bitarna är attributen.

window.insch(ch[, attr])

window.insch(y, x, ch[, attr])

Måla tecken ch vid (y, x) med attribut attr, flytta linjen från position x höger med ett tecken.

window.insdelln(nlines)

Infoga nlines rader i det angivna fönstret ovanför den aktuella raden. De nedersta nlines-raderna går förlorade. För negativa nlines, ta bort nlines rader som börjar med den under markören, och flytta de återstående raderna uppåt. De nedersta nlines-raderna rensas. Den aktuella markörpositionen förblir densamma.

window.insertln()

Infoga en tom rad under markören. Alla följande rader flyttas ned en rad.

window.insnstr(str, n[, attr])

window.insnstr(y, x, str, n[, attr])

Infoga en teckensträng (så många tecken som får plats på raden) före tecknet under markören, upp till n tecken. Om n är noll eller negativt infogas hela strängen. Alla tecken till höger om markören förskjuts åt höger, varvid de tecken som ligger längst till höger på raden försvinner. Markörens position ändras inte (efter förflyttning till y, x, om detta anges).

window.insstr(str[, attr])

window.insstr(y, x, str[, attr])

Infoga en teckensträng (så många tecken som får plats på raden) före tecknet under markören. Alla tecken till höger om markören flyttas till höger, och de tecken som ligger längst till höger på raden försvinner. Markörens position ändras inte (efter att ha flyttats till y, x, om detta har angetts).

window.instr([n])

window.instr(y, x[, n])

Returnerar ett bytesobjekt med tecken, extraherade från fönstret med början vid den aktuella markörpositionen, eller vid y, x om så anges. Attribut tas bort från tecknen. Om n anges returnerar instr() en sträng som är högst n tecken lång (exklusive det efterföljande NUL). Det maximala värdet för n är 2047.

Ändrad i version 3.14: Maxvärdet för n höjdes från 1023 till 2047.

window.is_linetouched(line)

Returnerar True om den angivna raden har ändrats sedan det senaste anropet till refresh(); annars returneras False. Utlöser ett curses.error undantag om line inte är giltig för det angivna fönstret.

window.is_wintouched()

Returnerar True om det angivna fönstret har ändrats sedan det senaste anropet till refresh(); annars returneras False.

window.keypad(flag)

Om flag är True, kommer escape-sekvenser som genereras av vissa tangenter (knappsats, funktionstangenter) att tolkas av curses. Om flag är False kommer escape-sekvenser att lämnas som de är i inmatningsflödet.

window.leaveok(flag)

Om flag är True, lämnas markören där den är vid uppdateringen, istället för att vara på ”markörpositionen” Detta minskar markörens rörelse där det är möjligt. Om möjligt kommer markören att göras osynlig.

Om flag är False kommer markören alltid att vara på ”markörpositionen” efter en uppdatering.

window.move(new_y, new_x)

Flytta markören till (new_y, new_x).

window.mvderwin(y, x)

Flytta fönstret inuti dess föräldrafönster. De skärmrelativa parametrarna för fönstret ändras inte. Denna rutin används för att visa olika delar av det överordnade fönstret på samma fysiska position på skärmen.

window.mvwin(new_y, new_x)

Flytta fönstret så att dess övre vänstra hörn ligger vid (new_y, new_x).

window.nodelay(flag)

Om flag är True, kommer getch() att vara icke-blockerande.

window.notimeout(flag)

Om flag är True kommer escape-sekvenser inte att tidsbegränsas.

Om flag är False kommer en escape-sekvens efter några millisekunder inte att tolkas utan lämnas kvar i inmatningsflödet som den är.

window.noutrefresh()

Markera för uppdatering men vänta. Denna funktion uppdaterar datastrukturen som representerar det önskade tillståndet för fönstret, men tvingar inte fram en uppdatering av den fysiska skärmen. För att åstadkomma detta, anropa doupdate().

window.overlay(destwin[, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])

Överlagra fönstret ovanpå destwin. Fönstren behöver inte vara lika stora, endast den överlappande regionen kopieras. Denna kopiering är icke-destruktiv, vilket innebär att det aktuella bakgrundstecknet inte skriver över det gamla innehållet i destwin.

För att få finkornig kontroll över den kopierade regionen kan den andra formen av overlay() användas. sminrow och smincol är de övre vänstra koordinaterna i källfönstret, och de andra variablerna markerar en rektangel i målfönstret.

window.overwrite(destwin[, sminrow, smincol, dminrow, dmincol, dmaxrow, dmaxcol])

Skriv över fönstret ovanpå destwin. Fönstren behöver inte vara lika stora, i så fall kopieras endast den överlappande regionen. Denna kopiering är destruktiv, vilket innebär att det aktuella bakgrundstecknet skriver över det gamla innehållet i destwin.

För att få finkornig kontroll över den kopierade regionen kan den andra formen av overwrite() användas. sminrow och smincol är de övre vänstra koordinaterna i källfönstret, de andra variablerna markerar en rektangel i målfönstret.

window.putwin(file)

Skriver all data som är kopplad till fönstret till det angivna filobjektet. Denna information kan senare hämtas med hjälp av funktionen getwin().

window.redrawln(beg, num)

Anger att antal rader på skärmen, med början på rad beg, är skadade och bör ritas om helt vid nästa refresh()-anrop.

window.redrawwin()

Rör vid hela fönstret, vilket gör att det ritas om helt och hållet vid nästa refresh()-anrop.

window.refresh([pminrow, pmincol, sminrow, smincol, smaxrow, smaxcol])

Uppdatera visningen omedelbart (synkronisera den faktiska skärmen med tidigare ritnings-/raderingsmetoder).

De 6 valfria argumenten kan endast anges när fönstret är en pad som skapats med newpad(). De ytterligare parametrarna behövs för att ange vilken del av padden och skärmen som är inblandad. pminrow och pmincol anger det övre vänstra hörnet av den rektangel som ska visas i padden. sminrow, smincol, smaxrow och smaxcol anger kanterna på den rektangel som ska visas på skärmen. Det nedre högra hörnet på den rektangel som ska visas i padden beräknas utifrån skärmkoordinaterna, eftersom rektanglarna måste vara lika stora. Båda rektanglarna måste vara helt inneslutna i sina respektive strukturer. Negativa värden av pminrow, pmincol, sminrow eller smincol behandlas som om de vore noll.

window.resize(nlines, ncols)

Omallokerar lagring för ett curses-fönster för att justera dess dimensioner till de angivna värdena. Om någon av dimensionerna är större än de aktuella värdena fylls fönstrets data med blanksteg som har den aktuella bakgrundsrenderingen (enligt bkgdset()) sammanfogad i dem.

window.scroll([lines=1])

Skrolla skärmen eller skrollområdet uppåt med linjer linjer.

window.scrollok(flag)

Styr vad som händer när markören i ett fönster flyttas från kanten av fönstret eller rullningsområdet, antingen som ett resultat av en ny rad på den nedre raden eller genom att skriva det sista tecknet på den sista raden. Om flag är False, lämnas markören kvar på den nedersta raden. Om flag är True rullas fönstret upp en rad. Observera att för att få den fysiska scrollningseffekten på terminalen är det också nödvändigt att anropa idlok().

window.setscrreg(top, bottom)

Ställ in rullningsregionen från rad överst till rad nederst. Alla skrollningar kommer att ske i denna region.

window.standend()

Stäng av det utmärkande attributet. På vissa terminaler har detta som bieffekt att alla attribut stängs av.

window.standout()

Slå på attributet A_STANDOUT.

window.subpad(begin_y, begin_x)

window.subpad(nlines, ncols, begin_y, begin_x)

Returnerar ett underfönster, vars övre vänstra hörn är vid (begin_y, begin_x), och vars bredd/höjd är ncols/nlines.

window.subwin(begin_y, begin_x)

window.subwin(nlines, ncols, begin_y, begin_x)

Returnerar ett underfönster, vars övre vänstra hörn är vid (begin_y, begin_x), och vars bredd/höjd är ncols/nlines.

Som standard kommer underfönstret att sträcka sig från den angivna positionen till fönstrets nedre högra hörn.

window.syncdown()

Rör vid varje plats i fönstret som har rörts vid i något av dess förfädersfönster. Denna rutin anropas av refresh(), så det bör nästan aldrig vara nödvändigt att anropa den manuellt.

window.syncok(flag)

Om flag är True, anropas syncup() automatiskt närhelst det sker en förändring i fönstret.

window.syncup()

Tryck på alla platser i fönstrets förfäder som har ändrats i fönstret.

window.timeout(delay)

Ställ in blockerande eller icke-blockerande läsbeteende för fönstret. Om delay är negativ används blockerande läsning (som väntar på indata på obestämd tid). Om delay är noll används icke-blockerande läsning och getch() returnerar -1 om ingen indata väntar. Om delay är positiv kommer getch() att blockera i delay millisekunder och returnera -1 om det fortfarande inte finns någon indata efter den tiden.

window.touchline(start, count[, changed])

Låtsas att count rader har ändrats, med början från rad start. Om changed anges, anger det om de berörda raderna markeras som ändrade (changed=True) eller oförändrade (changed=False).

window.touchwin()

Låtsas att hela fönstret har ändrats för att optimera ritningen.

window.untouchwin()

Markera alla rader i fönstret som oförändrade sedan det senaste anropet till refresh().

window.vline(ch, n[, attr])

window.vline(y, x, ch, n[, attr])

Visa en vertikal linje som börjar vid (y, x) med längden n och som består av tecknet ch med attributen attr.

Konstanter

Modulen curses definierar följande datamedlemmar:

curses.ERR

Vissa curses-rutiner som returnerar ett heltal, t.ex. getch(), returnerar ERR om de misslyckas.

curses.OK

Vissa curses-rutiner som returnerar ett heltal, t.ex. napms(), returnerar OK när de lyckas.

curses.version

curses.__version__

Ett bytesobjekt som representerar den aktuella versionen av modulen.

curses.ncurses_version

En namngiven tupel som innehåller de tre komponenterna i ncurses-bibliotekets version: major, minor och patch. Alla värden är heltal. Komponenterna kan också nås via namn, så curses.ncurses_version[0] är likvärdigt med curses.ncurses_version.major och så vidare.

Tillgänglighet: om biblioteket ncurses används.

Tillagd i version 3.8.

curses.COLORS

Det maximala antalet färger som terminalen kan stödja. Det definieras först efter anropet till start_color().

curses.COLOR_PAIRS

Det maximala antalet färgpar som terminalen kan stödja. Det definieras först efter anropet till start_color().

curses.COLS

Skärmens bredd, d.v.s. antalet kolumner. Den definieras först efter anropet till initscr(). Uppdateras av update_lines_cols(), resizeterm() och resize_term().

curses.LINES

Skärmens höjd, d.v.s. antalet rader. Den definieras först efter anropet till initscr(). Uppdateras av update_lines_cols(), resizeterm() och resize_term().

Vissa konstanter finns tillgängliga för att ange teckencellens attribut. Exakt vilka konstanter som är tillgängliga är systemberoende.

Attribut	Betydelse
curses.A_ALTCHARSET	Läge för alternativ teckenuppsättning
curses.A_BLINK	Blink-läge
curses.A_BOLD	Fet stil
curses.A_DIM	Dim-läge
curses.A_INVIS	Osynligt eller tomt läge
curses.A_ITALIC	Kursivt läge
curses.A_NORMAL	Normalt attribut
curses.A_PROTECT	Skyddat läge
curses.A_REVERSE	Omvända bakgrunds- och förgrundsfärger
curses.A_STANDOUT	Utmärkande läge
curses.A_UNDERLINE	Understrykningsläge
curses.A_HORIZONTAL	Horisontell markering
curses.A_LEFT	Vänster markering
curses.A_LOW	Låg höjdpunkt
curses.A_RIGHT	Höger höjdpunkt
curses.A_TOP	Högsta höjdpunkt
curses.A_VERTICAL	Vertikal markering

Tillagd i version 3.7: A_ITALIC lades till.

Flera konstanter finns tillgängliga för att extrahera motsvarande attribut som returneras av vissa metoder.

Bit-mask	Betydelse
curses.A_ATTRIBUTES	Bit-mask för att extrahera attribut
curses.A_CHARTEXT	Bit-mask för att extrahera ett tecken
curses.A_COLOR	Bit-mask för att extrahera information om färgparsfält

Nycklar refereras till av heltalskonstanter med namn som börjar med KEY_. Exakt vilka tangentbord som är tillgängliga är systemberoende.

Nyckel konstant	Nyckel
curses.KEY_MIN	Minsta nyckelvärde
curses.KEY_BREAK	Bryt nyckel (opålitlig)
curses.KEY_DOWN	Pil nedåt
curses.KEY_UP	Pil upp
curses.KEY_LEFT	Vänster pil
curses.KEY_RIGHT	Pil höger
curses.KEY_HOME	Hemknapp (uppåt+vänsterpil)
curses.KEY_BACKSPACE	Backspace (opålitlig)
curses.KEY_F0	Funktionstangenter. Upp till 64 funktionsknappar stöds.
curses.KEY_Fn	Värde för funktionsknapp n
curses.KEY_DL	Radera rad
curses.KEY_IL	Infoga rad
curses.KEY_DC	Radera tecken
curses.KEY_IC	Infoga tecken eller gå till infogningsläge
curses.KEY_EIC	Avsluta insättning av char-läge
curses.KEY_CLEAR	Rensa skärmen
curses.KEY_EOS	Rensa till slutet av skärmen
curses.KEY_EOL	Rensa till slutet av raden
curses.KEY_SF	Bläddra 1 rad framåt
curses.KEY_SR	Bläddra 1 rad bakåt (bakåt)
curses.KEY_NPAGE	Nästa sida
curses.KEY_PPAGE	Föregående sida
curses.KEY_STAB	Ställ in fliken
curses.KEY_CTAB	Rensa fliken
curses.KEY_CATAB	Rensa alla flikar
curses.KEY_ENTER	Skriv in eller skicka (opålitlig)
curses.KEY_SRESET	Mjuk (partiell) återställning (otillförlitlig)
curses.KEY_RESET	Återställning eller hård återställning (otillförlitlig)
curses.KEY_PRINT	Skriv ut
curses.KEY_LL	Startsida nedåt eller nedåt (längst ned till vänster)
curses.KEY_A1	Övre vänstra delen av knappsatsen
curses.KEY_A3	Övre högra delen av knappsatsen
curses.KEY_B2	Knappsatsens mitt
curses.KEY_C1	Nedre vänstra delen av knappsatsen
curses.KEY_C3	Nedre högra delen av knappsatsen
curses.KEY_BTAB	Bakre fliken
curses.KEY_BEG	Beg (början)
curses.KEY_CANCEL	Avbryt
curses.KEY_CLOSE	Stäng
curses.KEY_COMMAND	Cmd (kommando)
curses.KEY_COPY	Kopiera
curses.KEY_CREATE	Skapa
curses.KEY_END	Slut
curses.KEY_EXIT	Avsluta
curses.KEY_FIND	Hitta
curses.KEY_HELP	Hjälp
curses.KEY_MARK	Markera
curses.KEY_MESSAGE	Meddelande
curses.KEY_MOVE	Flytta
curses.KEY_NEXT	Nästa
curses.KEY_OPEN	Öppen
curses.KEY_OPTIONS	Alternativ
curses.KEY_PREVIOUS	Prev (föregående)
curses.KEY_REDO	Gör om
curses.KEY_REFERENCE	Ref (referens)
curses.KEY_REFRESH	Uppdatera
curses.KEY_REPLACE	Ersätt
curses.KEY_RESTART	Starta om
curses.KEY_RESUME	Återuppta
curses.KEY_SAVE	Spara
curses.KEY_SBEG	Shifted Beg (början)
curses.KEY_SCANCEL	Shifted Avbryt
curses.KEY_SCOMMAND	Förskjutet kommando
curses.KEY_SCOPY	Förskjuten kopia
curses.KEY_SCREATE	Shifted Create
curses.KEY_SDC	Skiftad Delete-symbol
curses.KEY_SDL	Skiftad Delete-linje
curses.KEY_SELECT	Välj
curses.KEY_SEND	Förskjutet slut
curses.KEY_SEOL	Förskjutet Fri linje
curses.KEY_SEXIT	Skiftad utgång
curses.KEY_SFIND	Förskjutet fynd
curses.KEY_SHELP	Förskjuten hjälp
curses.KEY_SHOME	Förflyttad hem
curses.KEY_SIC	Skiftad inmatning
curses.KEY_SLEFT	Skiftad vänsterpil
curses.KEY_SMESSAGE	Förskjutet meddelande
curses.KEY_SMOVE	Skiftad rörelse
curses.KEY_SNEXT	Shifted Nästa
curses.KEY_SOPTIONS	Förskjutna alternativ
curses.KEY_SPREVIOUS	Förskjuten Prev
curses.KEY_SPRINT	Shifted Print
curses.KEY_SREDO	Shifted Redo
curses.KEY_SREPLACE	Skiftad ersättning
curses.KEY_SRIGHT	Skiftad högerpil
curses.KEY_SRSUME	Förskjutet CV
curses.KEY_SSAVE	Shifted Save
curses.KEY_SSUSPEND	Shifted Suspend
curses.KEY_SUNDO	Shifted Undo
curses.KEY_SUSPEND	Pausa
curses.KEY_UNDO	Ångra
curses.KEY_MOUSE	En mushändelse har inträffat
curses.KEY_RESIZE	Händelse för storleksändring av terminal
curses.KEY_MAX	Maximalt nyckelvärde

På VT100 och deras mjukvaruemuleringar, t.ex. X-terminalemulatorer, finns det normalt minst fyra funktionstangenter (KEY_F1, KEY_F2, KEY_F3, KEY_F4) tillgängliga, och piltangenterna mappas till KEY_UP, KEY_DOWN, KEY_LEFT och KEY_RIGHT på det uppenbara sättet. Om din maskin har ett PC-tangentbord är det säkert att förvänta sig piltangenter och tolv funktionstangenter (äldre PC-tangentbord kanske bara har tio funktionstangenter); dessutom är följande knappsatsmappningar standard:

Nyckelkap	Konstant
Infoga	KEY_IC
Delete	KEY_DC
Home	KEY_HOME
Slut	KEY_END
Sida upp	KEY_PPAGE
Sida ner	NYCKELSIDA

I följande tabell listas tecken från den alternativa teckenuppsättningen. Dessa är ärvda från VT100-terminalen och kommer i allmänhet att vara tillgängliga på programvaruemuleringar som X-terminaler. När det inte finns någon grafik tillgänglig använder curses en grov approximation av ASCII för utskrift.

Anteckning

Dessa är tillgängliga först efter att initscr() har anropats.

ACS-kod	Betydelse
curses.ACS_BBSS	alternativt namn för övre högra hörnet
curses.ACS_BLOCK	massivt fyrkantigt block
curses.ACS_BOARD	bräda av rutor
curses.ACS_BSBS	alternativt namn för horisontell linje
curses.ACS_BSSB	alternativt namn för övre vänstra hörnet
curses.ACS_BSSS	alternativt namn för topptee
curses.ACS_BTEE	nederdel tee
curses.ACS_BULLET	kula
curses.ACS_CKBOARD	rutmönster (stipple)
curses.ACS_DARROW	pil som pekar nedåt
curses.ACS_DEGREE	gradsymbol
curses.ACS_DIAMOND	diamant
curses.ACS_GEQUAL	större än eller lika med
curses.ACS_HLINE	horisontell linje
curses.ACS_LANTERN	symbol för lykta
curses.ACS_LARROW	vänster pil
curses.ACS_LEQUAL	mindre än eller lika med
curses.ACS_LLCORNER	nedre vänstra hörnet
curses.ACS_LRCORNER	nedre högra hörnet
curses.ACS_LTEE	vänster tee
curses.ACS_NEQUAL	tecken som inte är lika med
curses.ACS_PI	bokstaven pi
curses.ACS_PLMINUS	plus-eller-minus-tecken
curses.ACS_PLUS	stort plustecken
curses.ACS_RARROW	pil höger
curses.ACS_RTEE	rätt tee
curses.ACS_S1	scanningslinje 1
curses.ACS_S3	scanningslinje 3
curses.ACS_S7	scanningslinje 7
curses.ACS_S9	scanningslinje 9
curses.ACS_SBBS	alternativt namn för nedre högra hörnet
curses.ACS_SBSB	alternativt namn för vertikal linje
curses.ACS_SBSS	alternativt namn för höger tee
curses.ACS_SSBB	alternativt namn för nedre vänstra hörnet
curses.ACS_SSBS	alternativt namn för bottentee
curses.ACS_SSSB	alternativt namn för vänster tee
curses.ACS_SSSS	alternativt namn för crossover eller big plus
curses.ACS_STERLING	pund sterling
curses.ACS_TTEE	topp tee
curses.ACS_UARROW	pil upp
curses.ACS_ULCORNER	övre vänstra hörnet
curses.ACS_URCORNER	övre högra hörnet
curses.ACS_VLINE	vertikal linje

Följande tabell listar musknappskonstanter som används av getmouse():

Musknapp konstant	Betydelse
curses.BUTTONn_PRESSED	Musknapp n intryckt
curses.BUTTONn_RELEASED	Musknapp n släppt
curses.BUTTONn_CLICKED	Musknapp n klickad
curses.BUTTONn_DOUBLE_CLICKED	Musknapp n dubbelklickad
curses.BUTTONn_TRIPLE_CLICKED	Musknapp n tre gånger klickad
curses.BUTTON_SHIFT	Skiftet var nere under byte av knappstatus
curses.BUTTON_CTRL	Kontrollen var avstängd under ändring av knappstatus
curses.BUTTON_ALT	Kontrollen var avstängd under ändring av knappstatus

Ändrad i version 3.10: Konstanterna BUTTON5_* exponeras nu om de tillhandahålls av det underliggande curses-biblioteket.

I följande tabell listas de fördefinierade färgerna:

Konstant	Färg
curses.COLOR_BLACK	Svart
curses.COLOR_BLUE	Blå
curses.COLOR_CYAN	Cyan (ljus grönblå)
curses.COLOR_GREEN	Grön
curses.COLOR_MAGENTA	Magenta (purpurfärgad röd)
curses.COLOR_RED	Röd
curses.COLOR_WHITE	Vit
curses.COLOR_YELLOW	Gult

curses.textpad — Widget för inmatning av text i curses-program

Modulen curses.textpad innehåller en Textbox-klass som hanterar elementär textredigering i ett curses-fönster, med stöd för en uppsättning tangentbindningar som liknar dem i Emacs (och därmed också i Netscape Navigator, BBedit 6.x, FrameMaker och många andra program). Modulen innehåller också en funktion för att rita rektanglar som är användbar för att rama in textrutor eller för andra ändamål.

Modulen curses.textpad definierar följande funktion:

curses.textpad.rectangle(win, uly, ulx, lry, lrx)

Rita en rektangel. Det första argumentet måste vara ett fönsterobjekt; de återstående argumenten är koordinater i förhållande till det fönstret. Det andra och tredje argumentet är y- och x-koordinaterna för det övre vänstra hörnet av den rektangel som ska ritas; det fjärde och femte argumentet är y- och x-koordinaterna för det nedre högra hörnet. Rektangeln ritas med VT100/IBM PC-formtecken på terminaler som gör detta möjligt (inklusive xterm och de flesta andra mjukvaruterminalemulatorer). Annars ritas den med ASCII-streck, vertikala staplar och plustecken.

Textbox-objekt

Du kan instansiera ett Textbox-objekt på följande sätt:

class curses.textpad.Textbox(win)

Returnerar ett widgetobjekt för en textruta. Argumentet win bör vara ett curses window-objekt som textrutan ska ingå i. Redigeringsmarkören för textrutan är initialt placerad i det övre vänstra hörnet av det innehållande fönstret, med koordinaterna (0, 0). Instansens flagga stripspaces är initialt aktiverad.

Textbox-objekt har följande metoder:

edit([validator])

Detta är den inmatningspunkt som du normalt kommer att använda. Den accepterar redigeringstangenttryckningar tills en av avslutningstangenttryckningarna anges. Om validator anges måste det vara en funktion. Den kommer att anropas för varje tangenttryckning som görs med tangenttryckningen som parameter; kommandot skickas med resultatet. Denna metod returnerar fönstrets innehåll som en sträng; huruvida blanksteg i fönstret inkluderas påverkas av attributet stripspaces.

do_command(ch)

Behandla en enda kommandotangenttryckning. Här är de speciella tangenttryckningar som stöds:

Tangenttryckning	Åtgärd
Control-A	Gå till vänstra kanten av fönstret.
Control-B	Cursor vänster, ombrytning till föregående rad om så är lämpligt.
Control-D	Radera tecken under markören.
Control-E	Gå till höger kant (stripspaces off) eller slutet av raden (stripspaces on).
Kontroll-F	Cursor höger, brytning till nästa rad när så är lämpligt.
Control-G	Avsluta och returnera fönstrets innehåll.
Control-H	Radera tecken bakåt.
Control-J	Avsluta om fönstret är 1 rad, annars infoga ny rad.
Kontroll-K	Om raden är tom, radera den, annars fortsätt till slutet av raden.
Control-L	Uppdatera skärmen.
Control-N	Nedåtpekare; flytta en rad nedåt.
Control-O	Infoga en tom rad vid markörens position.
Control-P	Cursor upp; flytta upp en rad.

Flyttoperationer gör ingenting om markören befinner sig på en kant där förflyttningen inte är möjlig. Följande synonymer stöds där så är möjligt:

Konstant	Tangenttryckning
KEY_LEFT	Control-B
KEY_RIGHT	Kontroll-F
KEY_UP	Control-P
KEY_DOWN	Control-N
KEY_BACKSPACE	Control-h

Alla andra tangenttryckningar behandlas som ett kommando att infoga det angivna tecknet och flytta till höger (med radbrytning).

gather()

Returnerar fönstrets innehåll som en sträng; huruvida blanksteg i fönstret inkluderas påverkas av stripspaces-medlemmen.

stripspaces

Detta attribut är en flagga som styr tolkningen av blanksteg i fönstret. När den är aktiverad ignoreras blanksteg på varje rad; alla markörrörelser som skulle placera markören på ett blanksteg går till slutet av raden istället, och blanksteg tas bort när fönstrets innehåll samlas in.