Documentation

type QsciLexer a = QObject (CQsciLexer a) #

type TQsciLexer a = TQObject (CQsciLexer a) #

data CQsciLexer a #

qCast_QsciLexer :: Object a -> IO (QsciLexer ()) #

type QsciLexerSc a = QsciLexer (CQsciLexerSc a) #

type TQsciLexerSc a = TQsciLexer (CQsciLexerSc a) #

data CQsciLexerSc a #

qCastList_QsciLexer :: QqCastList_QsciLexer a r => a -> r #

withQsciLexerResult :: IO (Ptr (TQsciLexer a)) -> IO (QsciLexer a) #

qsciLexerFromPtr :: Ptr (TQsciLexer a) -> IO (QsciLexer a) #

qsciLexerAddFinalizer :: QsciLexer a -> IO () #

type QsciLexerCPP a = QsciLexer (CQsciLexerCPP a) #

type TQsciLexerCPP a = TQsciLexer (CQsciLexerCPP a) #

data CQsciLexerCPP a #

qCast_QsciLexerCPP :: Object a -> IO (QsciLexerCPP ()) #

type QsciLexerCPPSc a = QsciLexerCPP (CQsciLexerCPPSc a) #

type TQsciLexerCPPSc a = TQsciLexerCPP (CQsciLexerCPPSc a) #

data CQsciLexerCPPSc a #

qCastList_QsciLexerCPP :: QqCastList_QsciLexerCPP a r => a -> r #

withQsciLexerCPPResult :: IO (Ptr (TQsciLexerCPP a)) -> IO (QsciLexerCPP a) #

qsciLexerCPPFromPtr :: Ptr (TQsciLexerCPP a) -> IO (QsciLexerCPP a) #

qsciLexerCPPAddFinalizer :: QsciLexerCPP a -> IO () #

type QsciAbstractAPIs a = QObject (CQsciAbstractAPIs a) #

type TQsciAbstractAPIs a = TQObject (CQsciAbstractAPIs a) #

data CQsciAbstractAPIs a #

qCast_QsciAbstractAPIs :: Object a -> IO (QsciAbstractAPIs ()) #

type QsciAbstractAPIsSc a = QsciAbstractAPIs (CQsciAbstractAPIsSc a) #

type TQsciAbstractAPIsSc a = TQsciAbstractAPIs (CQsciAbstractAPIsSc a) #

data CQsciAbstractAPIsSc a #

qCastList_QsciAbstractAPIs :: QqCastList_QsciAbstractAPIs a r => a -> r #

withQsciAbstractAPIsResult :: IO (Ptr (TQsciAbstractAPIs a)) -> IO (QsciAbstractAPIs a) #

qsciAbstractAPIsFromPtr :: Ptr (TQsciAbstractAPIs a) -> IO (QsciAbstractAPIs a) #

qsciAbstractAPIsAddFinalizer :: QsciAbstractAPIs a -> IO () #

type QsciScintillaBase a = QAbstractScrollArea (CQsciScintillaBase a) #

type TQsciScintillaBase a = TQAbstractScrollArea (CQsciScintillaBase a) #

data CQsciScintillaBase a #

qCast_QsciScintillaBase :: Object a -> IO (QsciScintillaBase ()) #

type QsciScintillaBaseSc a = QsciScintillaBase (CQsciScintillaBaseSc a) #

type TQsciScintillaBaseSc a = TQsciScintillaBase (CQsciScintillaBaseSc a) #

data CQsciScintillaBaseSc a #

qCastList_QsciScintillaBase :: QqCastList_QsciScintillaBase a r => a -> r #

withQsciScintillaBaseResult :: IO (Ptr (TQsciScintillaBase a)) -> IO (QsciScintillaBase a) #

qsciScintillaBaseFromPtr :: Ptr (TQsciScintillaBase a) -> IO (QsciScintillaBase a) #

qsciScintillaBaseAddFinalizer :: QsciScintillaBase a -> IO () #

type QsciLexerFortran77 a = QsciLexer (CQsciLexerFortran77 a) #

type TQsciLexerFortran77 a = TQsciLexer (CQsciLexerFortran77 a) #

data CQsciLexerFortran77 a #

qCast_QsciLexerFortran77 :: Object a -> IO (QsciLexerFortran77 ()) #

type QsciLexerFortran77Sc a = QsciLexerFortran77 (CQsciLexerFortran77Sc a) #

type TQsciLexerFortran77Sc a = TQsciLexerFortran77 (CQsciLexerFortran77Sc a) #

data CQsciLexerFortran77Sc a #

qCastList_QsciLexerFortran77 :: QqCastList_QsciLexerFortran77 a r => a -> r #

withQsciLexerFortran77Result :: IO (Ptr (TQsciLexerFortran77 a)) -> IO (QsciLexerFortran77 a) #

qsciLexerFortran77FromPtr :: Ptr (TQsciLexerFortran77 a) -> IO (QsciLexerFortran77 a) #

qsciLexerFortran77AddFinalizer :: QsciLexerFortran77 a -> IO () #

type QsciLexerHTML a = QsciLexer (CQsciLexerHTML a) #

type TQsciLexerHTML a = TQsciLexer (CQsciLexerHTML a) #

data CQsciLexerHTML a #

qCast_QsciLexerHTML :: Object a -> IO (QsciLexerHTML ()) #

type QsciLexerHTMLSc a = QsciLexerHTML (CQsciLexerHTMLSc a) #

type TQsciLexerHTMLSc a = TQsciLexerHTML (CQsciLexerHTMLSc a) #

data CQsciLexerHTMLSc a #

qCastList_QsciLexerHTML :: QqCastList_QsciLexerHTML a r => a -> r #

withQsciLexerHTMLResult :: IO (Ptr (TQsciLexerHTML a)) -> IO (QsciLexerHTML a) #

qsciLexerHTMLFromPtr :: Ptr (TQsciLexerHTML a) -> IO (QsciLexerHTML a) #

qsciLexerHTMLAddFinalizer :: QsciLexerHTML a -> IO () #

type QsciLexerMatlab a = QsciLexer (CQsciLexerMatlab a) #

type TQsciLexerMatlab a = TQsciLexer (CQsciLexerMatlab a) #

data CQsciLexerMatlab a #

qCast_QsciLexerMatlab :: Object a -> IO (QsciLexerMatlab ()) #

type QsciLexerMatlabSc a = QsciLexerMatlab (CQsciLexerMatlabSc a) #

type TQsciLexerMatlabSc a = TQsciLexerMatlab (CQsciLexerMatlabSc a) #

data CQsciLexerMatlabSc a #

qCastList_QsciLexerMatlab :: QqCastList_QsciLexerMatlab a r => a -> r #

withQsciLexerMatlabResult :: IO (Ptr (TQsciLexerMatlab a)) -> IO (QsciLexerMatlab a) #

qsciLexerMatlabFromPtr :: Ptr (TQsciLexerMatlab a) -> IO (QsciLexerMatlab a) #

qsciLexerMatlabAddFinalizer :: QsciLexerMatlab a -> IO () #

type QsciCommand a = Object (CQsciCommand a) #

type TQsciCommand a = CQsciCommand a #

data CQsciCommand a #

qCast_QsciCommand :: Object a -> IO (QsciCommand ()) #

type QsciCommandSc a = QsciCommand (CQsciCommandSc a) #

type TQsciCommandSc a = TQsciCommand (CQsciCommandSc a) #

data CQsciCommandSc a #

qCastList_QsciCommand :: QqCastList_QsciCommand a r => a -> r #

withQsciCommandResult :: IO (Ptr (TQsciCommand a)) -> IO (QsciCommand a) #

withQListQsciCommandResult :: IO (Ptr (TQListQsciCommand ())) -> IO [QsciCommand ()] #

qsciCommandListFromPtrList :: [Ptr (TQsciCommand a)] -> IO [QsciCommand a] #

type QListQsciCommand a = Object (CQListQsciCommand a) #

type TQListQsciCommand a = CQListQsciCommand a #

data CQListQsciCommand a #

type QsciCommandSet a = Object (CQsciCommandSet a) #

type TQsciCommandSet a = CQsciCommandSet a #

data CQsciCommandSet a #

qCast_QsciCommandSet :: Object a -> IO (QsciCommandSet ()) #

type QsciCommandSetSc a = QsciCommandSet (CQsciCommandSetSc a) #

type TQsciCommandSetSc a = TQsciCommandSet (CQsciCommandSetSc a) #

data CQsciCommandSetSc a #

qCastList_QsciCommandSet :: QqCastList_QsciCommandSet a r => a -> r #

withQsciCommandSetResult :: IO (Ptr (TQsciCommandSet a)) -> IO (QsciCommandSet a) #

type QsciStyle a = Object (CQsciStyle a) #

type TQsciStyle a = CQsciStyle a #

data CQsciStyle a #

qCast_QsciStyle :: Object a -> IO (QsciStyle ()) #

type QsciStyleSc a = QsciStyle (CQsciStyleSc a) #

type TQsciStyleSc a = TQsciStyle (CQsciStyleSc a) #

data CQsciStyleSc a #

qCastList_QsciStyle :: QqCastList_QsciStyle a r => a -> r #

withQsciStyleResult :: IO (Ptr (TQsciStyle a)) -> IO (QsciStyle a) #

type QsciDocument a = Object (CQsciDocument a) #

type TQsciDocument a = CQsciDocument a #

data CQsciDocument a #

qCast_QsciDocument :: Object a -> IO (QsciDocument ()) #

type QsciDocumentSc a = QsciDocument (CQsciDocumentSc a) #

type TQsciDocumentSc a = TQsciDocument (CQsciDocumentSc a) #

data CQsciDocumentSc a #

qCastList_QsciDocument :: QqCastList_QsciDocument a r => a -> r #

withQsciDocumentResult :: IO (Ptr (TQsciDocument a)) -> IO (QsciDocument a) #

type QsciPrinter a = Object (CQsciPrinter a) #

type TQsciPrinter a = CQsciPrinter a #

data CQsciPrinter a #

qCast_QsciPrinter :: Object a -> IO (QsciPrinter ()) #

type QsciPrinterSc a = QsciPrinter (CQsciPrinterSc a) #

type TQsciPrinterSc a = TQsciPrinter (CQsciPrinterSc a) #

data CQsciPrinterSc a #

qCastList_QsciPrinter :: QqCastList_QsciPrinter a r => a -> r #

withQsciPrinterResult :: IO (Ptr (TQsciPrinter a)) -> IO (QsciPrinter a) #

type QsciStyledText a = Object (CQsciStyledText a) #

type TQsciStyledText a = CQsciStyledText a #

data CQsciStyledText a #

qCast_QsciStyledText :: Object a -> IO (QsciStyledText ()) #

type QsciStyledTextSc a = QsciStyledText (CQsciStyledTextSc a) #

type TQsciStyledTextSc a = TQsciStyledText (CQsciStyledTextSc a) #

data CQsciStyledTextSc a #

qCastList_QsciStyledText :: QqCastList_QsciStyledText a r => a -> r #

withQsciStyledTextResult :: IO (Ptr (TQsciStyledText a)) -> IO (QsciStyledText a) #

type QsciMacro a = QObject (CQsciMacro a) #

type TQsciMacro a = TQObject (CQsciMacro a) #

data CQsciMacro a #

qCast_QsciMacro :: Object a -> IO (QsciMacro ()) #

type QsciMacroSc a = QsciMacro (CQsciMacroSc a) #

type TQsciMacroSc a = TQsciMacro (CQsciMacroSc a) #

data CQsciMacroSc a #

qCastList_QsciMacro :: QqCastList_QsciMacro a r => a -> r #

withQsciMacroResult :: IO (Ptr (TQsciMacro a)) -> IO (QsciMacro a) #

qsciMacroFromPtr :: Ptr (TQsciMacro a) -> IO (QsciMacro a) #

qsciMacroAddFinalizer :: QsciMacro a -> IO () #

type QsciAPIs a = QsciAbstractAPIs (CQsciAPIs a) #

type TQsciAPIs a = TQsciAbstractAPIs (CQsciAPIs a) #

data CQsciAPIs a #

qCast_QsciAPIs :: Object a -> IO (QsciAPIs ()) #

type QsciAPIsSc a = QsciAPIs (CQsciAPIsSc a) #

type TQsciAPIsSc a = TQsciAPIs (CQsciAPIsSc a) #

data CQsciAPIsSc a #

qCastList_QsciAPIs :: QqCastList_QsciAPIs a r => a -> r #

withQsciAPIsResult :: IO (Ptr (TQsciAPIs a)) -> IO (QsciAPIs a) #

qsciAPIsFromPtr :: Ptr (TQsciAPIs a) -> IO (QsciAPIs a) #

qsciAPIsAddFinalizer :: QsciAPIs a -> IO () #

type QsciLexerMakefile a = QsciLexer (CQsciLexerMakefile a) #

type TQsciLexerMakefile a = TQsciLexer (CQsciLexerMakefile a) #

data CQsciLexerMakefile a #

qCast_QsciLexerMakefile :: Object a -> IO (QsciLexerMakefile ()) #

type QsciLexerMakefileSc a = QsciLexerMakefile (CQsciLexerMakefileSc a) #

type TQsciLexerMakefileSc a = TQsciLexerMakefile (CQsciLexerMakefileSc a) #

data CQsciLexerMakefileSc a #

qCastList_QsciLexerMakefile :: QqCastList_QsciLexerMakefile a r => a -> r #

withQsciLexerMakefileResult :: IO (Ptr (TQsciLexerMakefile a)) -> IO (QsciLexerMakefile a) #

qsciLexerMakefileFromPtr :: Ptr (TQsciLexerMakefile a) -> IO (QsciLexerMakefile a) #

qsciLexerMakefileAddFinalizer :: QsciLexerMakefile a -> IO () #

type QsciLexerRuby a = QsciLexer (CQsciLexerRuby a) #

type TQsciLexerRuby a = TQsciLexer (CQsciLexerRuby a) #

data CQsciLexerRuby a #

qCast_QsciLexerRuby :: Object a -> IO (QsciLexerRuby ()) #

type QsciLexerRubySc a = QsciLexerRuby (CQsciLexerRubySc a) #

type TQsciLexerRubySc a = TQsciLexerRuby (CQsciLexerRubySc a) #

data CQsciLexerRubySc a #

qCastList_QsciLexerRuby :: QqCastList_QsciLexerRuby a r => a -> r #

withQsciLexerRubyResult :: IO (Ptr (TQsciLexerRuby a)) -> IO (QsciLexerRuby a) #

qsciLexerRubyFromPtr :: Ptr (TQsciLexerRuby a) -> IO (QsciLexerRuby a) #

qsciLexerRubyAddFinalizer :: QsciLexerRuby a -> IO () #

type QsciLexerPascal a = QsciLexer (CQsciLexerPascal a) #

type TQsciLexerPascal a = TQsciLexer (CQsciLexerPascal a) #

data CQsciLexerPascal a #

qCast_QsciLexerPascal :: Object a -> IO (QsciLexerPascal ()) #

type QsciLexerPascalSc a = QsciLexerPascal (CQsciLexerPascalSc a) #

type TQsciLexerPascalSc a = TQsciLexerPascal (CQsciLexerPascalSc a) #

data CQsciLexerPascalSc a #

qCastList_QsciLexerPascal :: QqCastList_QsciLexerPascal a r => a -> r #

withQsciLexerPascalResult :: IO (Ptr (TQsciLexerPascal a)) -> IO (QsciLexerPascal a) #

qsciLexerPascalFromPtr :: Ptr (TQsciLexerPascal a) -> IO (QsciLexerPascal a) #

qsciLexerPascalAddFinalizer :: QsciLexerPascal a -> IO () #

type QsciLexerJSON a = QsciLexer (CQsciLexerJSON a) #

type TQsciLexerJSON a = TQsciLexer (CQsciLexerJSON a) #

data CQsciLexerJSON a #

qCast_QsciLexerJSON :: Object a -> IO (QsciLexerJSON ()) #

type QsciLexerJSONSc a = QsciLexerJSON (CQsciLexerJSONSc a) #

type TQsciLexerJSONSc a = TQsciLexerJSON (CQsciLexerJSONSc a) #

data CQsciLexerJSONSc a #

qCastList_QsciLexerJSON :: QqCastList_QsciLexerJSON a r => a -> r #

withQsciLexerJSONResult :: IO (Ptr (TQsciLexerJSON a)) -> IO (QsciLexerJSON a) #

qsciLexerJSONFromPtr :: Ptr (TQsciLexerJSON a) -> IO (QsciLexerJSON a) #

qsciLexerJSONAddFinalizer :: QsciLexerJSON a -> IO () #

type QsciLexerMarkdown a = QsciLexer (CQsciLexerMarkdown a) #

type TQsciLexerMarkdown a = TQsciLexer (CQsciLexerMarkdown a) #

data CQsciLexerMarkdown a #

qCast_QsciLexerMarkdown :: Object a -> IO (QsciLexerMarkdown ()) #

type QsciLexerMarkdownSc a = QsciLexerMarkdown (CQsciLexerMarkdownSc a) #

type TQsciLexerMarkdownSc a = TQsciLexerMarkdown (CQsciLexerMarkdownSc a) #

data CQsciLexerMarkdownSc a #

qCastList_QsciLexerMarkdown :: QqCastList_QsciLexerMarkdown a r => a -> r #

withQsciLexerMarkdownResult :: IO (Ptr (TQsciLexerMarkdown a)) -> IO (QsciLexerMarkdown a) #

qsciLexerMarkdownFromPtr :: Ptr (TQsciLexerMarkdown a) -> IO (QsciLexerMarkdown a) #

qsciLexerMarkdownAddFinalizer :: QsciLexerMarkdown a -> IO () #

type QsciLexerCustom a = QsciLexer (CQsciLexerCustom a) #

type TQsciLexerCustom a = TQsciLexer (CQsciLexerCustom a) #

data CQsciLexerCustom a #

qCast_QsciLexerCustom :: Object a -> IO (QsciLexerCustom ()) #

type QsciLexerCustomSc a = QsciLexerCustom (CQsciLexerCustomSc a) #

type TQsciLexerCustomSc a = TQsciLexerCustom (CQsciLexerCustomSc a) #

data CQsciLexerCustomSc a #

qCastList_QsciLexerCustom :: QqCastList_QsciLexerCustom a r => a -> r #

withQsciLexerCustomResult :: IO (Ptr (TQsciLexerCustom a)) -> IO (QsciLexerCustom a) #

qsciLexerCustomFromPtr :: Ptr (TQsciLexerCustom a) -> IO (QsciLexerCustom a) #

qsciLexerCustomAddFinalizer :: QsciLexerCustom a -> IO () #

type QsciLexerBatch a = QsciLexer (CQsciLexerBatch a) #

type TQsciLexerBatch a = TQsciLexer (CQsciLexerBatch a) #

data CQsciLexerBatch a #

qCast_QsciLexerBatch :: Object a -> IO (QsciLexerBatch ()) #

type QsciLexerBatchSc a = QsciLexerBatch (CQsciLexerBatchSc a) #

type TQsciLexerBatchSc a = TQsciLexerBatch (CQsciLexerBatchSc a) #

data CQsciLexerBatchSc a #

qCastList_QsciLexerBatch :: QqCastList_QsciLexerBatch a r => a -> r #

withQsciLexerBatchResult :: IO (Ptr (TQsciLexerBatch a)) -> IO (QsciLexerBatch a) #

qsciLexerBatchFromPtr :: Ptr (TQsciLexerBatch a) -> IO (QsciLexerBatch a) #

qsciLexerBatchAddFinalizer :: QsciLexerBatch a -> IO () #

type QsciLexerTCL a = QsciLexer (CQsciLexerTCL a) #

type TQsciLexerTCL a = TQsciLexer (CQsciLexerTCL a) #

data CQsciLexerTCL a #

qCast_QsciLexerTCL :: Object a -> IO (QsciLexerTCL ()) #

type QsciLexerTCLSc a = QsciLexerTCL (CQsciLexerTCLSc a) #

type TQsciLexerTCLSc a = TQsciLexerTCL (CQsciLexerTCLSc a) #

data CQsciLexerTCLSc a #

qCastList_QsciLexerTCL :: QqCastList_QsciLexerTCL a r => a -> r #

withQsciLexerTCLResult :: IO (Ptr (TQsciLexerTCL a)) -> IO (QsciLexerTCL a) #

qsciLexerTCLFromPtr :: Ptr (TQsciLexerTCL a) -> IO (QsciLexerTCL a) #

qsciLexerTCLAddFinalizer :: QsciLexerTCL a -> IO () #

type QsciLexerPostScript a = QsciLexer (CQsciLexerPostScript a) #

type TQsciLexerPostScript a = TQsciLexer (CQsciLexerPostScript a) #

data CQsciLexerPostScript a #

qCast_QsciLexerPostScript :: Object a -> IO (QsciLexerPostScript ()) #

type QsciLexerPostScriptSc a = QsciLexerPostScript (CQsciLexerPostScriptSc a) #

type TQsciLexerPostScriptSc a = TQsciLexerPostScript (CQsciLexerPostScriptSc a) #

data CQsciLexerPostScriptSc a #

qCastList_QsciLexerPostScript :: QqCastList_QsciLexerPostScript a r => a -> r #

withQsciLexerPostScriptResult :: IO (Ptr (TQsciLexerPostScript a)) -> IO (QsciLexerPostScript a) #

qsciLexerPostScriptFromPtr :: Ptr (TQsciLexerPostScript a) -> IO (QsciLexerPostScript a) #

qsciLexerPostScriptAddFinalizer :: QsciLexerPostScript a -> IO () #

type QsciLexerPO a = QsciLexer (CQsciLexerPO a) #

type TQsciLexerPO a = TQsciLexer (CQsciLexerPO a) #

data CQsciLexerPO a #

qCast_QsciLexerPO :: Object a -> IO (QsciLexerPO ()) #

type QsciLexerPOSc a = QsciLexerPO (CQsciLexerPOSc a) #

type TQsciLexerPOSc a = TQsciLexerPO (CQsciLexerPOSc a) #

data CQsciLexerPOSc a #

qCastList_QsciLexerPO :: QqCastList_QsciLexerPO a r => a -> r #

withQsciLexerPOResult :: IO (Ptr (TQsciLexerPO a)) -> IO (QsciLexerPO a) #

qsciLexerPOFromPtr :: Ptr (TQsciLexerPO a) -> IO (QsciLexerPO a) #

qsciLexerPOAddFinalizer :: QsciLexerPO a -> IO () #

type QsciLexerVHDL a = QsciLexer (CQsciLexerVHDL a) #

type TQsciLexerVHDL a = TQsciLexer (CQsciLexerVHDL a) #

data CQsciLexerVHDL a #

qCast_QsciLexerVHDL :: Object a -> IO (QsciLexerVHDL ()) #

type QsciLexerVHDLSc a = QsciLexerVHDL (CQsciLexerVHDLSc a) #

type TQsciLexerVHDLSc a = TQsciLexerVHDL (CQsciLexerVHDLSc a) #

data CQsciLexerVHDLSc a #

qCastList_QsciLexerVHDL :: QqCastList_QsciLexerVHDL a r => a -> r #

withQsciLexerVHDLResult :: IO (Ptr (TQsciLexerVHDL a)) -> IO (QsciLexerVHDL a) #

qsciLexerVHDLFromPtr :: Ptr (TQsciLexerVHDL a) -> IO (QsciLexerVHDL a) #

qsciLexerVHDLAddFinalizer :: QsciLexerVHDL a -> IO () #

type QsciLexerPerl a = QsciLexer (CQsciLexerPerl a) #

type TQsciLexerPerl a = TQsciLexer (CQsciLexerPerl a) #

data CQsciLexerPerl a #

qCast_QsciLexerPerl :: Object a -> IO (QsciLexerPerl ()) #

type QsciLexerPerlSc a = QsciLexerPerl (CQsciLexerPerlSc a) #

type TQsciLexerPerlSc a = TQsciLexerPerl (CQsciLexerPerlSc a) #

data CQsciLexerPerlSc a #

qCastList_QsciLexerPerl :: QqCastList_QsciLexerPerl a r => a -> r #

withQsciLexerPerlResult :: IO (Ptr (TQsciLexerPerl a)) -> IO (QsciLexerPerl a) #

qsciLexerPerlFromPtr :: Ptr (TQsciLexerPerl a) -> IO (QsciLexerPerl a) #

qsciLexerPerlAddFinalizer :: QsciLexerPerl a -> IO () #

type QsciLexerCoffeeScript a = QsciLexer (CQsciLexerCoffeeScript a) #

type TQsciLexerCoffeeScript a = TQsciLexer (CQsciLexerCoffeeScript a) #

data CQsciLexerCoffeeScript a #

qCast_QsciLexerCoffeeScript :: Object a -> IO (QsciLexerCoffeeScript ()) #

type QsciLexerCoffeeScriptSc a = QsciLexerCoffeeScript (CQsciLexerCoffeeScriptSc a) #

type TQsciLexerCoffeeScriptSc a = TQsciLexerCoffeeScript (CQsciLexerCoffeeScriptSc a) #

data CQsciLexerCoffeeScriptSc a #

qCastList_QsciLexerCoffeeScript :: QqCastList_QsciLexerCoffeeScript a r => a -> r #

withQsciLexerCoffeeScriptResult :: IO (Ptr (TQsciLexerCoffeeScript a)) -> IO (QsciLexerCoffeeScript a) #

qsciLexerCoffeeScriptFromPtr :: Ptr (TQsciLexerCoffeeScript a) -> IO (QsciLexerCoffeeScript a) #

qsciLexerCoffeeScriptAddFinalizer :: QsciLexerCoffeeScript a -> IO () #

type QsciLexerTeX a = QsciLexer (CQsciLexerTeX a) #

type TQsciLexerTeX a = TQsciLexer (CQsciLexerTeX a) #

data CQsciLexerTeX a #

qCast_QsciLexerTeX :: Object a -> IO (QsciLexerTeX ()) #

type QsciLexerTeXSc a = QsciLexerTeX (CQsciLexerTeXSc a) #

type TQsciLexerTeXSc a = TQsciLexerTeX (CQsciLexerTeXSc a) #

data CQsciLexerTeXSc a #

qCastList_QsciLexerTeX :: QqCastList_QsciLexerTeX a r => a -> r #

withQsciLexerTeXResult :: IO (Ptr (TQsciLexerTeX a)) -> IO (QsciLexerTeX a) #

qsciLexerTeXFromPtr :: Ptr (TQsciLexerTeX a) -> IO (QsciLexerTeX a) #

qsciLexerTeXAddFinalizer :: QsciLexerTeX a -> IO () #

type QsciLexerSQL a = QsciLexer (CQsciLexerSQL a) #

type TQsciLexerSQL a = TQsciLexer (CQsciLexerSQL a) #

data CQsciLexerSQL a #

qCast_QsciLexerSQL :: Object a -> IO (QsciLexerSQL ()) #

type QsciLexerSQLSc a = QsciLexerSQL (CQsciLexerSQLSc a) #

type TQsciLexerSQLSc a = TQsciLexerSQL (CQsciLexerSQLSc a) #

data CQsciLexerSQLSc a #

qCastList_QsciLexerSQL :: QqCastList_QsciLexerSQL a r => a -> r #

withQsciLexerSQLResult :: IO (Ptr (TQsciLexerSQL a)) -> IO (QsciLexerSQL a) #

qsciLexerSQLFromPtr :: Ptr (TQsciLexerSQL a) -> IO (QsciLexerSQL a) #

qsciLexerSQLAddFinalizer :: QsciLexerSQL a -> IO () #

type QsciLexerDiff a = QsciLexer (CQsciLexerDiff a) #

type TQsciLexerDiff a = TQsciLexer (CQsciLexerDiff a) #

data CQsciLexerDiff a #

qCast_QsciLexerDiff :: Object a -> IO (QsciLexerDiff ()) #

type QsciLexerDiffSc a = QsciLexerDiff (CQsciLexerDiffSc a) #

type TQsciLexerDiffSc a = TQsciLexerDiff (CQsciLexerDiffSc a) #

data CQsciLexerDiffSc a #

qCastList_QsciLexerDiff :: QqCastList_QsciLexerDiff a r => a -> r #

withQsciLexerDiffResult :: IO (Ptr (TQsciLexerDiff a)) -> IO (QsciLexerDiff a) #

qsciLexerDiffFromPtr :: Ptr (TQsciLexerDiff a) -> IO (QsciLexerDiff a) #

qsciLexerDiffAddFinalizer :: QsciLexerDiff a -> IO () #

type QsciLexerPython a = QsciLexer (CQsciLexerPython a) #

type TQsciLexerPython a = TQsciLexer (CQsciLexerPython a) #

data CQsciLexerPython a #

qCast_QsciLexerPython :: Object a -> IO (QsciLexerPython ()) #

type QsciLexerPythonSc a = QsciLexerPython (CQsciLexerPythonSc a) #

type TQsciLexerPythonSc a = TQsciLexerPython (CQsciLexerPythonSc a) #

data CQsciLexerPythonSc a #

qCastList_QsciLexerPython :: QqCastList_QsciLexerPython a r => a -> r #

withQsciLexerPythonResult :: IO (Ptr (TQsciLexerPython a)) -> IO (QsciLexerPython a) #

qsciLexerPythonFromPtr :: Ptr (TQsciLexerPython a) -> IO (QsciLexerPython a) #

qsciLexerPythonAddFinalizer :: QsciLexerPython a -> IO () #

type QsciLexerD a = QsciLexer (CQsciLexerD a) #

type TQsciLexerD a = TQsciLexer (CQsciLexerD a) #

data CQsciLexerD a #

qCast_QsciLexerD :: Object a -> IO (QsciLexerD ()) #

type QsciLexerDSc a = QsciLexerD (CQsciLexerDSc a) #

type TQsciLexerDSc a = TQsciLexerD (CQsciLexerDSc a) #

data CQsciLexerDSc a #

qCastList_QsciLexerD :: QqCastList_QsciLexerD a r => a -> r #

withQsciLexerDResult :: IO (Ptr (TQsciLexerD a)) -> IO (QsciLexerD a) #

qsciLexerDFromPtr :: Ptr (TQsciLexerD a) -> IO (QsciLexerD a) #

qsciLexerDAddFinalizer :: QsciLexerD a -> IO () #

type QsciLexerCSS a = QsciLexer (CQsciLexerCSS a) #

type TQsciLexerCSS a = TQsciLexer (CQsciLexerCSS a) #

data CQsciLexerCSS a #

qCast_QsciLexerCSS :: Object a -> IO (QsciLexerCSS ()) #

type QsciLexerCSSSc a = QsciLexerCSS (CQsciLexerCSSSc a) #

type TQsciLexerCSSSc a = TQsciLexerCSS (CQsciLexerCSSSc a) #

data CQsciLexerCSSSc a #

qCastList_QsciLexerCSS :: QqCastList_QsciLexerCSS a r => a -> r #

withQsciLexerCSSResult :: IO (Ptr (TQsciLexerCSS a)) -> IO (QsciLexerCSS a) #

qsciLexerCSSFromPtr :: Ptr (TQsciLexerCSS a) -> IO (QsciLexerCSS a) #

qsciLexerCSSAddFinalizer :: QsciLexerCSS a -> IO () #

type QsciLexerProperties a = QsciLexer (CQsciLexerProperties a) #

type TQsciLexerProperties a = TQsciLexer (CQsciLexerProperties a) #

data CQsciLexerProperties a #

qCast_QsciLexerProperties :: Object a -> IO (QsciLexerProperties ()) #

type QsciLexerPropertiesSc a = QsciLexerProperties (CQsciLexerPropertiesSc a) #

type TQsciLexerPropertiesSc a = TQsciLexerProperties (CQsciLexerPropertiesSc a) #

data CQsciLexerPropertiesSc a #

qCastList_QsciLexerProperties :: QqCastList_QsciLexerProperties a r => a -> r #

withQsciLexerPropertiesResult :: IO (Ptr (TQsciLexerProperties a)) -> IO (QsciLexerProperties a) #

qsciLexerPropertiesFromPtr :: Ptr (TQsciLexerProperties a) -> IO (QsciLexerProperties a) #

qsciLexerPropertiesAddFinalizer :: QsciLexerProperties a -> IO () #

type QsciLexerPOV a = QsciLexer (CQsciLexerPOV a) #

type TQsciLexerPOV a = TQsciLexer (CQsciLexerPOV a) #

data CQsciLexerPOV a #

qCast_QsciLexerPOV :: Object a -> IO (QsciLexerPOV ()) #

type QsciLexerPOVSc a = QsciLexerPOV (CQsciLexerPOVSc a) #

type TQsciLexerPOVSc a = TQsciLexerPOV (CQsciLexerPOVSc a) #

data CQsciLexerPOVSc a #

qCastList_QsciLexerPOV :: QqCastList_QsciLexerPOV a r => a -> r #

withQsciLexerPOVResult :: IO (Ptr (TQsciLexerPOV a)) -> IO (QsciLexerPOV a) #

qsciLexerPOVFromPtr :: Ptr (TQsciLexerPOV a) -> IO (QsciLexerPOV a) #

qsciLexerPOVAddFinalizer :: QsciLexerPOV a -> IO () #

type QsciLexerYAML a = QsciLexer (CQsciLexerYAML a) #

type TQsciLexerYAML a = TQsciLexer (CQsciLexerYAML a) #

data CQsciLexerYAML a #

qCast_QsciLexerYAML :: Object a -> IO (QsciLexerYAML ()) #

type QsciLexerYAMLSc a = QsciLexerYAML (CQsciLexerYAMLSc a) #

type TQsciLexerYAMLSc a = TQsciLexerYAML (CQsciLexerYAMLSc a) #

data CQsciLexerYAMLSc a #

qCastList_QsciLexerYAML :: QqCastList_QsciLexerYAML a r => a -> r #

withQsciLexerYAMLResult :: IO (Ptr (TQsciLexerYAML a)) -> IO (QsciLexerYAML a) #

qsciLexerYAMLFromPtr :: Ptr (TQsciLexerYAML a) -> IO (QsciLexerYAML a) #

qsciLexerYAMLAddFinalizer :: QsciLexerYAML a -> IO () #

type QsciLexerCMake a = QsciLexer (CQsciLexerCMake a) #

type TQsciLexerCMake a = TQsciLexer (CQsciLexerCMake a) #

data CQsciLexerCMake a #

qCast_QsciLexerCMake :: Object a -> IO (QsciLexerCMake ()) #

type QsciLexerCMakeSc a = QsciLexerCMake (CQsciLexerCMakeSc a) #

type TQsciLexerCMakeSc a = TQsciLexerCMake (CQsciLexerCMakeSc a) #

data CQsciLexerCMakeSc a #

qCastList_QsciLexerCMake :: QqCastList_QsciLexerCMake a r => a -> r #

withQsciLexerCMakeResult :: IO (Ptr (TQsciLexerCMake a)) -> IO (QsciLexerCMake a) #

qsciLexerCMakeFromPtr :: Ptr (TQsciLexerCMake a) -> IO (QsciLexerCMake a) #

qsciLexerCMakeAddFinalizer :: QsciLexerCMake a -> IO () #

type QsciLexerSpice a = QsciLexer (CQsciLexerSpice a) #

type TQsciLexerSpice a = TQsciLexer (CQsciLexerSpice a) #

data CQsciLexerSpice a #

qCast_QsciLexerSpice :: Object a -> IO (QsciLexerSpice ()) #

type QsciLexerSpiceSc a = QsciLexerSpice (CQsciLexerSpiceSc a) #

type TQsciLexerSpiceSc a = TQsciLexerSpice (CQsciLexerSpiceSc a) #

data CQsciLexerSpiceSc a #

qCastList_QsciLexerSpice :: QqCastList_QsciLexerSpice a r => a -> r #

withQsciLexerSpiceResult :: IO (Ptr (TQsciLexerSpice a)) -> IO (QsciLexerSpice a) #

qsciLexerSpiceFromPtr :: Ptr (TQsciLexerSpice a) -> IO (QsciLexerSpice a) #

qsciLexerSpiceAddFinalizer :: QsciLexerSpice a -> IO () #

type QsciLexerVerilog a = QsciLexer (CQsciLexerVerilog a) #

type TQsciLexerVerilog a = TQsciLexer (CQsciLexerVerilog a) #

data CQsciLexerVerilog a #

qCast_QsciLexerVerilog :: Object a -> IO (QsciLexerVerilog ()) #

type QsciLexerVerilogSc a = QsciLexerVerilog (CQsciLexerVerilogSc a) #

type TQsciLexerVerilogSc a = TQsciLexerVerilog (CQsciLexerVerilogSc a) #

data CQsciLexerVerilogSc a #

qCastList_QsciLexerVerilog :: QqCastList_QsciLexerVerilog a r => a -> r #

withQsciLexerVerilogResult :: IO (Ptr (TQsciLexerVerilog a)) -> IO (QsciLexerVerilog a) #

qsciLexerVerilogFromPtr :: Ptr (TQsciLexerVerilog a) -> IO (QsciLexerVerilog a) #

qsciLexerVerilogAddFinalizer :: QsciLexerVerilog a -> IO () #

type QsciLexerLua a = QsciLexer (CQsciLexerLua a) #

type TQsciLexerLua a = TQsciLexer (CQsciLexerLua a) #

data CQsciLexerLua a #

qCast_QsciLexerLua :: Object a -> IO (QsciLexerLua ()) #

type QsciLexerLuaSc a = QsciLexerLua (CQsciLexerLuaSc a) #

type TQsciLexerLuaSc a = TQsciLexerLua (CQsciLexerLuaSc a) #

data CQsciLexerLuaSc a #

qCastList_QsciLexerLua :: QqCastList_QsciLexerLua a r => a -> r #

withQsciLexerLuaResult :: IO (Ptr (TQsciLexerLua a)) -> IO (QsciLexerLua a) #

qsciLexerLuaFromPtr :: Ptr (TQsciLexerLua a) -> IO (QsciLexerLua a) #

qsciLexerLuaAddFinalizer :: QsciLexerLua a -> IO () #

type QsciLexerAVS a = QsciLexer (CQsciLexerAVS a) #

type TQsciLexerAVS a = TQsciLexer (CQsciLexerAVS a) #

data CQsciLexerAVS a #

qCast_QsciLexerAVS :: Object a -> IO (QsciLexerAVS ()) #

type QsciLexerAVSSc a = QsciLexerAVS (CQsciLexerAVSSc a) #

type TQsciLexerAVSSc a = TQsciLexerAVS (CQsciLexerAVSSc a) #

data CQsciLexerAVSSc a #

qCastList_QsciLexerAVS :: QqCastList_QsciLexerAVS a r => a -> r #

withQsciLexerAVSResult :: IO (Ptr (TQsciLexerAVS a)) -> IO (QsciLexerAVS a) #

qsciLexerAVSFromPtr :: Ptr (TQsciLexerAVS a) -> IO (QsciLexerAVS a) #

qsciLexerAVSAddFinalizer :: QsciLexerAVS a -> IO () #

type QsciLexerBash a = QsciLexer (CQsciLexerBash a) #

type TQsciLexerBash a = TQsciLexer (CQsciLexerBash a) #

data CQsciLexerBash a #

qCast_QsciLexerBash :: Object a -> IO (QsciLexerBash ()) #

type QsciLexerBashSc a = QsciLexerBash (CQsciLexerBashSc a) #

type TQsciLexerBashSc a = TQsciLexerBash (CQsciLexerBashSc a) #

data CQsciLexerBashSc a #

qCastList_QsciLexerBash :: QqCastList_QsciLexerBash a r => a -> r #

withQsciLexerBashResult :: IO (Ptr (TQsciLexerBash a)) -> IO (QsciLexerBash a) #

qsciLexerBashFromPtr :: Ptr (TQsciLexerBash a) -> IO (QsciLexerBash a) #

qsciLexerBashAddFinalizer :: QsciLexerBash a -> IO () #

type QsciLexerJava a = QsciLexerCPP (CQsciLexerJava a) #

type TQsciLexerJava a = TQsciLexerCPP (CQsciLexerJava a) #

data CQsciLexerJava a #

qCast_QsciLexerJava :: Object a -> IO (QsciLexerJava ()) #

type QsciLexerJavaSc a = QsciLexerJava (CQsciLexerJavaSc a) #

type TQsciLexerJavaSc a = TQsciLexerJava (CQsciLexerJavaSc a) #

data CQsciLexerJavaSc a #

qCastList_QsciLexerJava :: QqCastList_QsciLexerJava a r => a -> r #

withQsciLexerJavaResult :: IO (Ptr (TQsciLexerJava a)) -> IO (QsciLexerJava a) #

qsciLexerJavaFromPtr :: Ptr (TQsciLexerJava a) -> IO (QsciLexerJava a) #

qsciLexerJavaAddFinalizer :: QsciLexerJava a -> IO () #

type QsciLexerCSharp a = QsciLexerCPP (CQsciLexerCSharp a) #

type TQsciLexerCSharp a = TQsciLexerCPP (CQsciLexerCSharp a) #

data CQsciLexerCSharp a #

qCast_QsciLexerCSharp :: Object a -> IO (QsciLexerCSharp ()) #

type QsciLexerCSharpSc a = QsciLexerCSharp (CQsciLexerCSharpSc a) #

type TQsciLexerCSharpSc a = TQsciLexerCSharp (CQsciLexerCSharpSc a) #

data CQsciLexerCSharpSc a #

qCastList_QsciLexerCSharp :: QqCastList_QsciLexerCSharp a r => a -> r #

withQsciLexerCSharpResult :: IO (Ptr (TQsciLexerCSharp a)) -> IO (QsciLexerCSharp a) #

qsciLexerCSharpFromPtr :: Ptr (TQsciLexerCSharp a) -> IO (QsciLexerCSharp a) #

qsciLexerCSharpAddFinalizer :: QsciLexerCSharp a -> IO () #

type QsciLexerIDL a = QsciLexerCPP (CQsciLexerIDL a) #

type TQsciLexerIDL a = TQsciLexerCPP (CQsciLexerIDL a) #

data CQsciLexerIDL a #

qCast_QsciLexerIDL :: Object a -> IO (QsciLexerIDL ()) #

type QsciLexerIDLSc a = QsciLexerIDL (CQsciLexerIDLSc a) #

type TQsciLexerIDLSc a = TQsciLexerIDL (CQsciLexerIDLSc a) #

data CQsciLexerIDLSc a #

qCastList_QsciLexerIDL :: QqCastList_QsciLexerIDL a r => a -> r #

withQsciLexerIDLResult :: IO (Ptr (TQsciLexerIDL a)) -> IO (QsciLexerIDL a) #

qsciLexerIDLFromPtr :: Ptr (TQsciLexerIDL a) -> IO (QsciLexerIDL a) #

qsciLexerIDLAddFinalizer :: QsciLexerIDL a -> IO () #

type QsciLexerJavaScript a = QsciLexerCPP (CQsciLexerJavaScript a) #

type TQsciLexerJavaScript a = TQsciLexerCPP (CQsciLexerJavaScript a) #

data CQsciLexerJavaScript a #

qCast_QsciLexerJavaScript :: Object a -> IO (QsciLexerJavaScript ()) #

type QsciLexerJavaScriptSc a = QsciLexerJavaScript (CQsciLexerJavaScriptSc a) #

type TQsciLexerJavaScriptSc a = TQsciLexerJavaScript (CQsciLexerJavaScriptSc a) #

data CQsciLexerJavaScriptSc a #

qCastList_QsciLexerJavaScript :: QqCastList_QsciLexerJavaScript a r => a -> r #

withQsciLexerJavaScriptResult :: IO (Ptr (TQsciLexerJavaScript a)) -> IO (QsciLexerJavaScript a) #

qsciLexerJavaScriptFromPtr :: Ptr (TQsciLexerJavaScript a) -> IO (QsciLexerJavaScript a) #

qsciLexerJavaScriptAddFinalizer :: QsciLexerJavaScript a -> IO () #

type QsciLexerFortran a = QsciLexerFortran77 (CQsciLexerFortran a) #

type TQsciLexerFortran a = TQsciLexerFortran77 (CQsciLexerFortran a) #

data CQsciLexerFortran a #

qCast_QsciLexerFortran :: Object a -> IO (QsciLexerFortran ()) #

type QsciLexerFortranSc a = QsciLexerFortran (CQsciLexerFortranSc a) #

type TQsciLexerFortranSc a = TQsciLexerFortran (CQsciLexerFortranSc a) #

data CQsciLexerFortranSc a #

qCastList_QsciLexerFortran :: QqCastList_QsciLexerFortran a r => a -> r #

withQsciLexerFortranResult :: IO (Ptr (TQsciLexerFortran a)) -> IO (QsciLexerFortran a) #

qsciLexerFortranFromPtr :: Ptr (TQsciLexerFortran a) -> IO (QsciLexerFortran a) #

qsciLexerFortranAddFinalizer :: QsciLexerFortran a -> IO () #

type QsciLexerXML a = QsciLexerHTML (CQsciLexerXML a) #

type TQsciLexerXML a = TQsciLexerHTML (CQsciLexerXML a) #

data CQsciLexerXML a #

qCast_QsciLexerXML :: Object a -> IO (QsciLexerXML ()) #

type QsciLexerXMLSc a = QsciLexerXML (CQsciLexerXMLSc a) #

type TQsciLexerXMLSc a = TQsciLexerXML (CQsciLexerXMLSc a) #

data CQsciLexerXMLSc a #

qCastList_QsciLexerXML :: QqCastList_QsciLexerXML a r => a -> r #

withQsciLexerXMLResult :: IO (Ptr (TQsciLexerXML a)) -> IO (QsciLexerXML a) #

qsciLexerXMLFromPtr :: Ptr (TQsciLexerXML a) -> IO (QsciLexerXML a) #

qsciLexerXMLAddFinalizer :: QsciLexerXML a -> IO () #

type QsciLexerOctave a = QsciLexerMatlab (CQsciLexerOctave a) #

type TQsciLexerOctave a = TQsciLexerMatlab (CQsciLexerOctave a) #

data CQsciLexerOctave a #

qCast_QsciLexerOctave :: Object a -> IO (QsciLexerOctave ()) #

type QsciLexerOctaveSc a = QsciLexerOctave (CQsciLexerOctaveSc a) #

type TQsciLexerOctaveSc a = TQsciLexerOctave (CQsciLexerOctaveSc a) #

data CQsciLexerOctaveSc a #

qCastList_QsciLexerOctave :: QqCastList_QsciLexerOctave a r => a -> r #

withQsciLexerOctaveResult :: IO (Ptr (TQsciLexerOctave a)) -> IO (QsciLexerOctave a) #

qsciLexerOctaveFromPtr :: Ptr (TQsciLexerOctave a) -> IO (QsciLexerOctave a) #

qsciLexerOctaveAddFinalizer :: QsciLexerOctave a -> IO () #

type QsciScintilla a = QsciScintillaBase (CQsciScintilla a) #

type TQsciScintilla a = TQsciScintillaBase (CQsciScintilla a) #

data CQsciScintilla a #

qCast_QsciScintilla :: Object a -> IO (QsciScintilla ()) #

type QsciScintillaSc a = QsciScintilla (CQsciScintillaSc a) #

type TQsciScintillaSc a = TQsciScintilla (CQsciScintillaSc a) #

data CQsciScintillaSc a #

qCastList_QsciScintilla :: QqCastList_QsciScintilla a r => a -> r #

withQsciScintillaResult :: IO (Ptr (TQsciScintilla a)) -> IO (QsciScintilla a) #

qsciScintillaFromPtr :: Ptr (TQsciScintilla a) -> IO (QsciScintilla a) #

qsciScintillaAddFinalizer :: QsciScintilla a -> IO () #