{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- Subclass of t'GI.Gtk.Objects.TextView.TextView'.
-- 
-- @GtkSourceView@ is the main class of the GtkSourceView library.
-- Use a [class/@buffer@/] to display text with a @GtkSourceView@.
-- 
-- This class provides:
-- 
--  - Show the line numbers;
--  - Show a right margin;
--  - Highlight the current line;
--  - Indentation settings;
--  - Configuration for the Home and End keyboard keys;
--  - Configure and show line marks;
--  - And a few other things.
-- 
-- An easy way to test all these features is to use the test-widget mini-program
-- provided in the GtkSourceView repository, in the tests\/ directory.
-- 
-- = GtkSourceView as GtkBuildable
-- 
-- The GtkSourceView implementation of the t'GI.Gtk.Interfaces.Buildable.Buildable' interface exposes the
-- [property/@view@/:completion] object with the internal-child \"completion\".
-- 
-- An example of a UI definition fragment with GtkSourceView:
-- 
-- === /xml code/
-- ><object class="GtkSourceView" id="source_view">
-- >  <property name="tab-width">4</property>
-- >  <property name="auto-indent">True</property>
-- >  <child internal-child="completion">
-- >    <object class="GtkSourceCompletion">
-- >      <property name="select-on-show">False</property>
-- >    </object>
-- >  </child>
-- ></object>
-- 
-- 
-- = Changing the Font
-- 
-- Gtk CSS provides the best way to change the font for a @GtkSourceView@ in a
-- manner that allows for components like [class/@map@/] to scale the desired
-- font.
-- 
-- 
-- === /c code/
-- >GtkCssProvider *provider = gtk_css_provider_new ();
-- >gtk_css_provider_load_from_data (provider,
-- >                                 "textview { font-family: Monospace; font-size: 8pt; }",
-- >                                 -1,
-- >                                 NULL);
-- >gtk_style_context_add_provider (gtk_widget_get_style_context (view),
-- >                                GTK_STYLE_PROVIDER (provider),
-- >                                GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
-- >g_object_unref (provider);
-- 
-- 
-- If you need to adjust the font or size of font within a portion of the
-- document only, you should use a t'GI.Gtk.Objects.TextTag.TextTag' with the [TextTag:family]("GI.Gtk.Objects.TextTag#g:attr:family") or
-- [TextTag:scale]("GI.Gtk.Objects.TextTag#g:attr:scale") set so that the font size may be scaled relative to
-- the default font set in CSS.

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.GtkSource.Objects.View
    ( 

-- * Exported types
    View(..)                                ,
    IsView                                  ,
    toView                                  ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [actionSetEnabled]("GI.Gtk.Objects.Widget#g:method:actionSetEnabled"), [activate]("GI.Gtk.Objects.Widget#g:method:activate"), [activateAction]("GI.Gtk.Objects.Widget#g:method:activateAction"), [activateDefault]("GI.Gtk.Objects.Widget#g:method:activateDefault"), [addChildAtAnchor]("GI.Gtk.Objects.TextView#g:method:addChildAtAnchor"), [addController]("GI.Gtk.Objects.Widget#g:method:addController"), [addCssClass]("GI.Gtk.Objects.Widget#g:method:addCssClass"), [addMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:addMnemonicLabel"), [addOverlay]("GI.Gtk.Objects.TextView#g:method:addOverlay"), [addTickCallback]("GI.Gtk.Objects.Widget#g:method:addTickCallback"), [allocate]("GI.Gtk.Objects.Widget#g:method:allocate"), [backwardDisplayLine]("GI.Gtk.Objects.TextView#g:method:backwardDisplayLine"), [backwardDisplayLineStart]("GI.Gtk.Objects.TextView#g:method:backwardDisplayLineStart"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [bufferToWindowCoords]("GI.Gtk.Objects.TextView#g:method:bufferToWindowCoords"), [childFocus]("GI.Gtk.Objects.Widget#g:method:childFocus"), [computeBounds]("GI.Gtk.Objects.Widget#g:method:computeBounds"), [computeExpand]("GI.Gtk.Objects.Widget#g:method:computeExpand"), [computePoint]("GI.Gtk.Objects.Widget#g:method:computePoint"), [computeTransform]("GI.Gtk.Objects.Widget#g:method:computeTransform"), [contains]("GI.Gtk.Objects.Widget#g:method:contains"), [createPangoContext]("GI.Gtk.Objects.Widget#g:method:createPangoContext"), [createPangoLayout]("GI.Gtk.Objects.Widget#g:method:createPangoLayout"), [disposeTemplate]("GI.Gtk.Objects.Widget#g:method:disposeTemplate"), [dragCheckThreshold]("GI.Gtk.Objects.Widget#g:method:dragCheckThreshold"), [errorBell]("GI.Gtk.Objects.Widget#g:method:errorBell"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [forwardDisplayLine]("GI.Gtk.Objects.TextView#g:method:forwardDisplayLine"), [forwardDisplayLineEnd]("GI.Gtk.Objects.TextView#g:method:forwardDisplayLineEnd"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [grabFocus]("GI.Gtk.Objects.Widget#g:method:grabFocus"), [hasCssClass]("GI.Gtk.Objects.Widget#g:method:hasCssClass"), [hasDefault]("GI.Gtk.Objects.Widget#g:method:hasDefault"), [hasFocus]("GI.Gtk.Objects.Widget#g:method:hasFocus"), [hasVisibleFocus]("GI.Gtk.Objects.Widget#g:method:hasVisibleFocus"), [hide]("GI.Gtk.Objects.Widget#g:method:hide"), [imContextFilterKeypress]("GI.Gtk.Objects.TextView#g:method:imContextFilterKeypress"), [inDestruction]("GI.Gtk.Objects.Widget#g:method:inDestruction"), [indentLines]("GI.GtkSource.Objects.View#g:method:indentLines"), [initTemplate]("GI.Gtk.Objects.Widget#g:method:initTemplate"), [insertActionGroup]("GI.Gtk.Objects.Widget#g:method:insertActionGroup"), [insertAfter]("GI.Gtk.Objects.Widget#g:method:insertAfter"), [insertBefore]("GI.Gtk.Objects.Widget#g:method:insertBefore"), [isAncestor]("GI.Gtk.Objects.Widget#g:method:isAncestor"), [isDrawable]("GI.Gtk.Objects.Widget#g:method:isDrawable"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isFocus]("GI.Gtk.Objects.Widget#g:method:isFocus"), [isSensitive]("GI.Gtk.Objects.Widget#g:method:isSensitive"), [isVisible]("GI.Gtk.Objects.Widget#g:method:isVisible"), [keynavFailed]("GI.Gtk.Objects.Widget#g:method:keynavFailed"), [listMnemonicLabels]("GI.Gtk.Objects.Widget#g:method:listMnemonicLabels"), [map]("GI.Gtk.Objects.Widget#g:method:map"), [measure]("GI.Gtk.Objects.Widget#g:method:measure"), [mnemonicActivate]("GI.Gtk.Objects.Widget#g:method:mnemonicActivate"), [moveMarkOnscreen]("GI.Gtk.Objects.TextView#g:method:moveMarkOnscreen"), [moveOverlay]("GI.Gtk.Objects.TextView#g:method:moveOverlay"), [moveVisually]("GI.Gtk.Objects.TextView#g:method:moveVisually"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [observeChildren]("GI.Gtk.Objects.Widget#g:method:observeChildren"), [observeControllers]("GI.Gtk.Objects.Widget#g:method:observeControllers"), [pick]("GI.Gtk.Objects.Widget#g:method:pick"), [placeCursorOnscreen]("GI.Gtk.Objects.TextView#g:method:placeCursorOnscreen"), [pushSnippet]("GI.GtkSource.Objects.View#g:method:pushSnippet"), [queueAllocate]("GI.Gtk.Objects.Widget#g:method:queueAllocate"), [queueDraw]("GI.Gtk.Objects.Widget#g:method:queueDraw"), [queueResize]("GI.Gtk.Objects.Widget#g:method:queueResize"), [realize]("GI.Gtk.Objects.Widget#g:method:realize"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [remove]("GI.Gtk.Objects.TextView#g:method:remove"), [removeController]("GI.Gtk.Objects.Widget#g:method:removeController"), [removeCssClass]("GI.Gtk.Objects.Widget#g:method:removeCssClass"), [removeMnemonicLabel]("GI.Gtk.Objects.Widget#g:method:removeMnemonicLabel"), [removeTickCallback]("GI.Gtk.Objects.Widget#g:method:removeTickCallback"), [resetCursorBlink]("GI.Gtk.Objects.TextView#g:method:resetCursorBlink"), [resetImContext]("GI.Gtk.Objects.TextView#g:method:resetImContext"), [resetProperty]("GI.Gtk.Interfaces.Accessible#g:method:resetProperty"), [resetRelation]("GI.Gtk.Interfaces.Accessible#g:method:resetRelation"), [resetState]("GI.Gtk.Interfaces.Accessible#g:method:resetState"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [scrollMarkOnscreen]("GI.Gtk.Objects.TextView#g:method:scrollMarkOnscreen"), [scrollToIter]("GI.Gtk.Objects.TextView#g:method:scrollToIter"), [scrollToMark]("GI.Gtk.Objects.TextView#g:method:scrollToMark"), [shouldLayout]("GI.Gtk.Objects.Widget#g:method:shouldLayout"), [show]("GI.Gtk.Objects.Widget#g:method:show"), [sizeAllocate]("GI.Gtk.Objects.Widget#g:method:sizeAllocate"), [snapshotChild]("GI.Gtk.Objects.Widget#g:method:snapshotChild"), [startsDisplayLine]("GI.Gtk.Objects.TextView#g:method:startsDisplayLine"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [translateCoordinates]("GI.Gtk.Objects.Widget#g:method:translateCoordinates"), [triggerTooltipQuery]("GI.Gtk.Objects.Widget#g:method:triggerTooltipQuery"), [unindentLines]("GI.GtkSource.Objects.View#g:method:unindentLines"), [unmap]("GI.Gtk.Objects.Widget#g:method:unmap"), [unparent]("GI.Gtk.Objects.Widget#g:method:unparent"), [unrealize]("GI.Gtk.Objects.Widget#g:method:unrealize"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [unsetStateFlags]("GI.Gtk.Objects.Widget#g:method:unsetStateFlags"), [updateNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:updateNextAccessibleSibling"), [updateProperty]("GI.Gtk.Interfaces.Accessible#g:method:updateProperty"), [updateRelation]("GI.Gtk.Interfaces.Accessible#g:method:updateRelation"), [updateState]("GI.Gtk.Interfaces.Accessible#g:method:updateState"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure"), [windowToBufferCoords]("GI.Gtk.Objects.TextView#g:method:windowToBufferCoords").
-- 
-- ==== Getters
-- [getAcceptsTab]("GI.Gtk.Objects.TextView#g:method:getAcceptsTab"), [getAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleParent"), [getAccessibleRole]("GI.Gtk.Interfaces.Accessible#g:method:getAccessibleRole"), [getAllocatedBaseline]("GI.Gtk.Objects.Widget#g:method:getAllocatedBaseline"), [getAllocatedHeight]("GI.Gtk.Objects.Widget#g:method:getAllocatedHeight"), [getAllocatedWidth]("GI.Gtk.Objects.Widget#g:method:getAllocatedWidth"), [getAllocation]("GI.Gtk.Objects.Widget#g:method:getAllocation"), [getAncestor]("GI.Gtk.Objects.Widget#g:method:getAncestor"), [getAtContext]("GI.Gtk.Interfaces.Accessible#g:method:getAtContext"), [getAutoIndent]("GI.GtkSource.Objects.View#g:method:getAutoIndent"), [getBackgroundPattern]("GI.GtkSource.Objects.View#g:method:getBackgroundPattern"), [getBorder]("GI.Gtk.Interfaces.Scrollable#g:method:getBorder"), [getBottomMargin]("GI.Gtk.Objects.TextView#g:method:getBottomMargin"), [getBounds]("GI.Gtk.Interfaces.Accessible#g:method:getBounds"), [getBuffer]("GI.Gtk.Objects.TextView#g:method:getBuffer"), [getBuildableId]("GI.Gtk.Interfaces.Buildable#g:method:getBuildableId"), [getCanFocus]("GI.Gtk.Objects.Widget#g:method:getCanFocus"), [getCanTarget]("GI.Gtk.Objects.Widget#g:method:getCanTarget"), [getChildVisible]("GI.Gtk.Objects.Widget#g:method:getChildVisible"), [getClipboard]("GI.Gtk.Objects.Widget#g:method:getClipboard"), [getColor]("GI.Gtk.Objects.Widget#g:method:getColor"), [getCompletion]("GI.GtkSource.Objects.View#g:method:getCompletion"), [getCssClasses]("GI.Gtk.Objects.Widget#g:method:getCssClasses"), [getCssName]("GI.Gtk.Objects.Widget#g:method:getCssName"), [getCursor]("GI.Gtk.Objects.Widget#g:method:getCursor"), [getCursorLocations]("GI.Gtk.Objects.TextView#g:method:getCursorLocations"), [getCursorVisible]("GI.Gtk.Objects.TextView#g:method:getCursorVisible"), [getData]("GI.GObject.Objects.Object#g:method:getData"), [getDirection]("GI.Gtk.Objects.Widget#g:method:getDirection"), [getDisplay]("GI.Gtk.Objects.Widget#g:method:getDisplay"), [getEditable]("GI.Gtk.Objects.TextView#g:method:getEditable"), [getEnableSnippets]("GI.GtkSource.Objects.View#g:method:getEnableSnippets"), [getExtraMenu]("GI.Gtk.Objects.TextView#g:method:getExtraMenu"), [getFirstAccessibleChild]("GI.Gtk.Interfaces.Accessible#g:method:getFirstAccessibleChild"), [getFirstChild]("GI.Gtk.Objects.Widget#g:method:getFirstChild"), [getFocusChild]("GI.Gtk.Objects.Widget#g:method:getFocusChild"), [getFocusOnClick]("GI.Gtk.Objects.Widget#g:method:getFocusOnClick"), [getFocusable]("GI.Gtk.Objects.Widget#g:method:getFocusable"), [getFontMap]("GI.Gtk.Objects.Widget#g:method:getFontMap"), [getFontOptions]("GI.Gtk.Objects.Widget#g:method:getFontOptions"), [getFrameClock]("GI.Gtk.Objects.Widget#g:method:getFrameClock"), [getGutter]("GI.GtkSource.Objects.View#g:method:getGutter"), [getHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getHadjustment"), [getHalign]("GI.Gtk.Objects.Widget#g:method:getHalign"), [getHasTooltip]("GI.Gtk.Objects.Widget#g:method:getHasTooltip"), [getHeight]("GI.Gtk.Objects.Widget#g:method:getHeight"), [getHexpand]("GI.Gtk.Objects.Widget#g:method:getHexpand"), [getHexpandSet]("GI.Gtk.Objects.Widget#g:method:getHexpandSet"), [getHighlightCurrentLine]("GI.GtkSource.Objects.View#g:method:getHighlightCurrentLine"), [getHover]("GI.GtkSource.Objects.View#g:method:getHover"), [getHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getHscrollPolicy"), [getIndent]("GI.Gtk.Objects.TextView#g:method:getIndent"), [getIndentOnTab]("GI.GtkSource.Objects.View#g:method:getIndentOnTab"), [getIndentWidth]("GI.GtkSource.Objects.View#g:method:getIndentWidth"), [getIndenter]("GI.GtkSource.Objects.View#g:method:getIndenter"), [getInputHints]("GI.Gtk.Objects.TextView#g:method:getInputHints"), [getInputPurpose]("GI.Gtk.Objects.TextView#g:method:getInputPurpose"), [getInsertSpacesInsteadOfTabs]("GI.GtkSource.Objects.View#g:method:getInsertSpacesInsteadOfTabs"), [getIterAtLocation]("GI.Gtk.Objects.TextView#g:method:getIterAtLocation"), [getIterAtPosition]("GI.Gtk.Objects.TextView#g:method:getIterAtPosition"), [getIterLocation]("GI.Gtk.Objects.TextView#g:method:getIterLocation"), [getJustification]("GI.Gtk.Objects.TextView#g:method:getJustification"), [getLastChild]("GI.Gtk.Objects.Widget#g:method:getLastChild"), [getLayoutManager]("GI.Gtk.Objects.Widget#g:method:getLayoutManager"), [getLeftMargin]("GI.Gtk.Objects.TextView#g:method:getLeftMargin"), [getLineAtY]("GI.Gtk.Objects.TextView#g:method:getLineAtY"), [getLineYrange]("GI.Gtk.Objects.TextView#g:method:getLineYrange"), [getLtrContext]("GI.Gtk.Objects.TextView#g:method:getLtrContext"), [getMapped]("GI.Gtk.Objects.Widget#g:method:getMapped"), [getMarginBottom]("GI.Gtk.Objects.Widget#g:method:getMarginBottom"), [getMarginEnd]("GI.Gtk.Objects.Widget#g:method:getMarginEnd"), [getMarginStart]("GI.Gtk.Objects.Widget#g:method:getMarginStart"), [getMarginTop]("GI.Gtk.Objects.Widget#g:method:getMarginTop"), [getMarkAttributes]("GI.GtkSource.Objects.View#g:method:getMarkAttributes"), [getMonospace]("GI.Gtk.Objects.TextView#g:method:getMonospace"), [getName]("GI.Gtk.Objects.Widget#g:method:getName"), [getNative]("GI.Gtk.Objects.Widget#g:method:getNative"), [getNextAccessibleSibling]("GI.Gtk.Interfaces.Accessible#g:method:getNextAccessibleSibling"), [getNextSibling]("GI.Gtk.Objects.Widget#g:method:getNextSibling"), [getOpacity]("GI.Gtk.Objects.Widget#g:method:getOpacity"), [getOverflow]("GI.Gtk.Objects.Widget#g:method:getOverflow"), [getOverwrite]("GI.Gtk.Objects.TextView#g:method:getOverwrite"), [getPangoContext]("GI.Gtk.Objects.Widget#g:method:getPangoContext"), [getParent]("GI.Gtk.Objects.Widget#g:method:getParent"), [getPixelsAboveLines]("GI.Gtk.Objects.TextView#g:method:getPixelsAboveLines"), [getPixelsBelowLines]("GI.Gtk.Objects.TextView#g:method:getPixelsBelowLines"), [getPixelsInsideWrap]("GI.Gtk.Objects.TextView#g:method:getPixelsInsideWrap"), [getPlatformState]("GI.Gtk.Interfaces.Accessible#g:method:getPlatformState"), [getPreferredSize]("GI.Gtk.Objects.Widget#g:method:getPreferredSize"), [getPrevSibling]("GI.Gtk.Objects.Widget#g:method:getPrevSibling"), [getPrimaryClipboard]("GI.Gtk.Objects.Widget#g:method:getPrimaryClipboard"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRealized]("GI.Gtk.Objects.Widget#g:method:getRealized"), [getReceivesDefault]("GI.Gtk.Objects.Widget#g:method:getReceivesDefault"), [getRequestMode]("GI.Gtk.Objects.Widget#g:method:getRequestMode"), [getRightMargin]("GI.Gtk.Objects.TextView#g:method:getRightMargin"), [getRightMarginPosition]("GI.GtkSource.Objects.View#g:method:getRightMarginPosition"), [getRoot]("GI.Gtk.Objects.Widget#g:method:getRoot"), [getRtlContext]("GI.Gtk.Objects.TextView#g:method:getRtlContext"), [getScaleFactor]("GI.Gtk.Objects.Widget#g:method:getScaleFactor"), [getSensitive]("GI.Gtk.Objects.Widget#g:method:getSensitive"), [getSettings]("GI.Gtk.Objects.Widget#g:method:getSettings"), [getShowLineMarks]("GI.GtkSource.Objects.View#g:method:getShowLineMarks"), [getShowLineNumbers]("GI.GtkSource.Objects.View#g:method:getShowLineNumbers"), [getShowRightMargin]("GI.GtkSource.Objects.View#g:method:getShowRightMargin"), [getSize]("GI.Gtk.Objects.Widget#g:method:getSize"), [getSizeRequest]("GI.Gtk.Objects.Widget#g:method:getSizeRequest"), [getSmartBackspace]("GI.GtkSource.Objects.View#g:method:getSmartBackspace"), [getSmartHomeEnd]("GI.GtkSource.Objects.View#g:method:getSmartHomeEnd"), [getSpaceDrawer]("GI.GtkSource.Objects.View#g:method:getSpaceDrawer"), [getStateFlags]("GI.Gtk.Objects.Widget#g:method:getStateFlags"), [getStyleContext]("GI.Gtk.Objects.Widget#g:method:getStyleContext"), [getTabWidth]("GI.GtkSource.Objects.View#g:method:getTabWidth"), [getTabs]("GI.Gtk.Objects.TextView#g:method:getTabs"), [getTemplateChild]("GI.Gtk.Objects.Widget#g:method:getTemplateChild"), [getTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:getTooltipMarkup"), [getTooltipText]("GI.Gtk.Objects.Widget#g:method:getTooltipText"), [getTopMargin]("GI.Gtk.Objects.TextView#g:method:getTopMargin"), [getVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:getVadjustment"), [getValign]("GI.Gtk.Objects.Widget#g:method:getValign"), [getVexpand]("GI.Gtk.Objects.Widget#g:method:getVexpand"), [getVexpandSet]("GI.Gtk.Objects.Widget#g:method:getVexpandSet"), [getVisible]("GI.Gtk.Objects.Widget#g:method:getVisible"), [getVisibleRect]("GI.Gtk.Objects.TextView#g:method:getVisibleRect"), [getVisualColumn]("GI.GtkSource.Objects.View#g:method:getVisualColumn"), [getVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:getVscrollPolicy"), [getWidth]("GI.Gtk.Objects.Widget#g:method:getWidth"), [getWrapMode]("GI.Gtk.Objects.TextView#g:method:getWrapMode").
-- 
-- ==== Setters
-- [setAcceptsTab]("GI.Gtk.Objects.TextView#g:method:setAcceptsTab"), [setAccessibleParent]("GI.Gtk.Interfaces.Accessible#g:method:setAccessibleParent"), [setAutoIndent]("GI.GtkSource.Objects.View#g:method:setAutoIndent"), [setBackgroundPattern]("GI.GtkSource.Objects.View#g:method:setBackgroundPattern"), [setBottomMargin]("GI.Gtk.Objects.TextView#g:method:setBottomMargin"), [setBuffer]("GI.Gtk.Objects.TextView#g:method:setBuffer"), [setCanFocus]("GI.Gtk.Objects.Widget#g:method:setCanFocus"), [setCanTarget]("GI.Gtk.Objects.Widget#g:method:setCanTarget"), [setChildVisible]("GI.Gtk.Objects.Widget#g:method:setChildVisible"), [setCssClasses]("GI.Gtk.Objects.Widget#g:method:setCssClasses"), [setCursor]("GI.Gtk.Objects.Widget#g:method:setCursor"), [setCursorFromName]("GI.Gtk.Objects.Widget#g:method:setCursorFromName"), [setCursorVisible]("GI.Gtk.Objects.TextView#g:method:setCursorVisible"), [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setDirection]("GI.Gtk.Objects.Widget#g:method:setDirection"), [setEditable]("GI.Gtk.Objects.TextView#g:method:setEditable"), [setEnableSnippets]("GI.GtkSource.Objects.View#g:method:setEnableSnippets"), [setExtraMenu]("GI.Gtk.Objects.TextView#g:method:setExtraMenu"), [setFocusChild]("GI.Gtk.Objects.Widget#g:method:setFocusChild"), [setFocusOnClick]("GI.Gtk.Objects.Widget#g:method:setFocusOnClick"), [setFocusable]("GI.Gtk.Objects.Widget#g:method:setFocusable"), [setFontMap]("GI.Gtk.Objects.Widget#g:method:setFontMap"), [setFontOptions]("GI.Gtk.Objects.Widget#g:method:setFontOptions"), [setGutter]("GI.Gtk.Objects.TextView#g:method:setGutter"), [setHadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setHadjustment"), [setHalign]("GI.Gtk.Objects.Widget#g:method:setHalign"), [setHasTooltip]("GI.Gtk.Objects.Widget#g:method:setHasTooltip"), [setHexpand]("GI.Gtk.Objects.Widget#g:method:setHexpand"), [setHexpandSet]("GI.Gtk.Objects.Widget#g:method:setHexpandSet"), [setHighlightCurrentLine]("GI.GtkSource.Objects.View#g:method:setHighlightCurrentLine"), [setHscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setHscrollPolicy"), [setIndent]("GI.Gtk.Objects.TextView#g:method:setIndent"), [setIndentOnTab]("GI.GtkSource.Objects.View#g:method:setIndentOnTab"), [setIndentWidth]("GI.GtkSource.Objects.View#g:method:setIndentWidth"), [setIndenter]("GI.GtkSource.Objects.View#g:method:setIndenter"), [setInputHints]("GI.Gtk.Objects.TextView#g:method:setInputHints"), [setInputPurpose]("GI.Gtk.Objects.TextView#g:method:setInputPurpose"), [setInsertSpacesInsteadOfTabs]("GI.GtkSource.Objects.View#g:method:setInsertSpacesInsteadOfTabs"), [setJustification]("GI.Gtk.Objects.TextView#g:method:setJustification"), [setLayoutManager]("GI.Gtk.Objects.Widget#g:method:setLayoutManager"), [setLeftMargin]("GI.Gtk.Objects.TextView#g:method:setLeftMargin"), [setMarginBottom]("GI.Gtk.Objects.Widget#g:method:setMarginBottom"), [setMarginEnd]("GI.Gtk.Objects.Widget#g:method:setMarginEnd"), [setMarginStart]("GI.Gtk.Objects.Widget#g:method:setMarginStart"), [setMarginTop]("GI.Gtk.Objects.Widget#g:method:setMarginTop"), [setMarkAttributes]("GI.GtkSource.Objects.View#g:method:setMarkAttributes"), [setMonospace]("GI.Gtk.Objects.TextView#g:method:setMonospace"), [setName]("GI.Gtk.Objects.Widget#g:method:setName"), [setOpacity]("GI.Gtk.Objects.Widget#g:method:setOpacity"), [setOverflow]("GI.Gtk.Objects.Widget#g:method:setOverflow"), [setOverwrite]("GI.Gtk.Objects.TextView#g:method:setOverwrite"), [setParent]("GI.Gtk.Objects.Widget#g:method:setParent"), [setPixelsAboveLines]("GI.Gtk.Objects.TextView#g:method:setPixelsAboveLines"), [setPixelsBelowLines]("GI.Gtk.Objects.TextView#g:method:setPixelsBelowLines"), [setPixelsInsideWrap]("GI.Gtk.Objects.TextView#g:method:setPixelsInsideWrap"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setReceivesDefault]("GI.Gtk.Objects.Widget#g:method:setReceivesDefault"), [setRightMargin]("GI.Gtk.Objects.TextView#g:method:setRightMargin"), [setRightMarginPosition]("GI.GtkSource.Objects.View#g:method:setRightMarginPosition"), [setSensitive]("GI.Gtk.Objects.Widget#g:method:setSensitive"), [setShowLineMarks]("GI.GtkSource.Objects.View#g:method:setShowLineMarks"), [setShowLineNumbers]("GI.GtkSource.Objects.View#g:method:setShowLineNumbers"), [setShowRightMargin]("GI.GtkSource.Objects.View#g:method:setShowRightMargin"), [setSizeRequest]("GI.Gtk.Objects.Widget#g:method:setSizeRequest"), [setSmartBackspace]("GI.GtkSource.Objects.View#g:method:setSmartBackspace"), [setSmartHomeEnd]("GI.GtkSource.Objects.View#g:method:setSmartHomeEnd"), [setStateFlags]("GI.Gtk.Objects.Widget#g:method:setStateFlags"), [setTabWidth]("GI.GtkSource.Objects.View#g:method:setTabWidth"), [setTabs]("GI.Gtk.Objects.TextView#g:method:setTabs"), [setTooltipMarkup]("GI.Gtk.Objects.Widget#g:method:setTooltipMarkup"), [setTooltipText]("GI.Gtk.Objects.Widget#g:method:setTooltipText"), [setTopMargin]("GI.Gtk.Objects.TextView#g:method:setTopMargin"), [setVadjustment]("GI.Gtk.Interfaces.Scrollable#g:method:setVadjustment"), [setValign]("GI.Gtk.Objects.Widget#g:method:setValign"), [setVexpand]("GI.Gtk.Objects.Widget#g:method:setVexpand"), [setVexpandSet]("GI.Gtk.Objects.Widget#g:method:setVexpandSet"), [setVisible]("GI.Gtk.Objects.Widget#g:method:setVisible"), [setVscrollPolicy]("GI.Gtk.Interfaces.Scrollable#g:method:setVscrollPolicy"), [setWrapMode]("GI.Gtk.Objects.TextView#g:method:setWrapMode").

#if defined(ENABLE_OVERLOADING)
    ResolveViewMethod                       ,
#endif

-- ** getAutoIndent #method:getAutoIndent#

#if defined(ENABLE_OVERLOADING)
    ViewGetAutoIndentMethodInfo             ,
#endif
    viewGetAutoIndent                       ,


-- ** getBackgroundPattern #method:getBackgroundPattern#

#if defined(ENABLE_OVERLOADING)
    ViewGetBackgroundPatternMethodInfo      ,
#endif
    viewGetBackgroundPattern                ,


-- ** getCompletion #method:getCompletion#

#if defined(ENABLE_OVERLOADING)
    ViewGetCompletionMethodInfo             ,
#endif
    viewGetCompletion                       ,


-- ** getEnableSnippets #method:getEnableSnippets#

#if defined(ENABLE_OVERLOADING)
    ViewGetEnableSnippetsMethodInfo         ,
#endif
    viewGetEnableSnippets                   ,


-- ** getGutter #method:getGutter#

#if defined(ENABLE_OVERLOADING)
    ViewGetGutterMethodInfo                 ,
#endif
    viewGetGutter                           ,


-- ** getHighlightCurrentLine #method:getHighlightCurrentLine#

#if defined(ENABLE_OVERLOADING)
    ViewGetHighlightCurrentLineMethodInfo   ,
#endif
    viewGetHighlightCurrentLine             ,


-- ** getHover #method:getHover#

#if defined(ENABLE_OVERLOADING)
    ViewGetHoverMethodInfo                  ,
#endif
    viewGetHover                            ,


-- ** getIndentOnTab #method:getIndentOnTab#

#if defined(ENABLE_OVERLOADING)
    ViewGetIndentOnTabMethodInfo            ,
#endif
    viewGetIndentOnTab                      ,


-- ** getIndentWidth #method:getIndentWidth#

#if defined(ENABLE_OVERLOADING)
    ViewGetIndentWidthMethodInfo            ,
#endif
    viewGetIndentWidth                      ,


-- ** getIndenter #method:getIndenter#

#if defined(ENABLE_OVERLOADING)
    ViewGetIndenterMethodInfo               ,
#endif
    viewGetIndenter                         ,


-- ** getInsertSpacesInsteadOfTabs #method:getInsertSpacesInsteadOfTabs#

#if defined(ENABLE_OVERLOADING)
    ViewGetInsertSpacesInsteadOfTabsMethodInfo,
#endif
    viewGetInsertSpacesInsteadOfTabs        ,


-- ** getMarkAttributes #method:getMarkAttributes#

#if defined(ENABLE_OVERLOADING)
    ViewGetMarkAttributesMethodInfo         ,
#endif
    viewGetMarkAttributes                   ,


-- ** getRightMarginPosition #method:getRightMarginPosition#

#if defined(ENABLE_OVERLOADING)
    ViewGetRightMarginPositionMethodInfo    ,
#endif
    viewGetRightMarginPosition              ,


-- ** getShowLineMarks #method:getShowLineMarks#

#if defined(ENABLE_OVERLOADING)
    ViewGetShowLineMarksMethodInfo          ,
#endif
    viewGetShowLineMarks                    ,


-- ** getShowLineNumbers #method:getShowLineNumbers#

#if defined(ENABLE_OVERLOADING)
    ViewGetShowLineNumbersMethodInfo        ,
#endif
    viewGetShowLineNumbers                  ,


-- ** getShowRightMargin #method:getShowRightMargin#

#if defined(ENABLE_OVERLOADING)
    ViewGetShowRightMarginMethodInfo        ,
#endif
    viewGetShowRightMargin                  ,


-- ** getSmartBackspace #method:getSmartBackspace#

#if defined(ENABLE_OVERLOADING)
    ViewGetSmartBackspaceMethodInfo         ,
#endif
    viewGetSmartBackspace                   ,


-- ** getSmartHomeEnd #method:getSmartHomeEnd#

#if defined(ENABLE_OVERLOADING)
    ViewGetSmartHomeEndMethodInfo           ,
#endif
    viewGetSmartHomeEnd                     ,


-- ** getSpaceDrawer #method:getSpaceDrawer#

#if defined(ENABLE_OVERLOADING)
    ViewGetSpaceDrawerMethodInfo            ,
#endif
    viewGetSpaceDrawer                      ,


-- ** getTabWidth #method:getTabWidth#

#if defined(ENABLE_OVERLOADING)
    ViewGetTabWidthMethodInfo               ,
#endif
    viewGetTabWidth                         ,


-- ** getVisualColumn #method:getVisualColumn#

#if defined(ENABLE_OVERLOADING)
    ViewGetVisualColumnMethodInfo           ,
#endif
    viewGetVisualColumn                     ,


-- ** indentLines #method:indentLines#

#if defined(ENABLE_OVERLOADING)
    ViewIndentLinesMethodInfo               ,
#endif
    viewIndentLines                         ,


-- ** new #method:new#

    viewNew                                 ,


-- ** newWithBuffer #method:newWithBuffer#

    viewNewWithBuffer                       ,


-- ** pushSnippet #method:pushSnippet#

#if defined(ENABLE_OVERLOADING)
    ViewPushSnippetMethodInfo               ,
#endif
    viewPushSnippet                         ,


-- ** setAutoIndent #method:setAutoIndent#

#if defined(ENABLE_OVERLOADING)
    ViewSetAutoIndentMethodInfo             ,
#endif
    viewSetAutoIndent                       ,


-- ** setBackgroundPattern #method:setBackgroundPattern#

#if defined(ENABLE_OVERLOADING)
    ViewSetBackgroundPatternMethodInfo      ,
#endif
    viewSetBackgroundPattern                ,


-- ** setEnableSnippets #method:setEnableSnippets#

#if defined(ENABLE_OVERLOADING)
    ViewSetEnableSnippetsMethodInfo         ,
#endif
    viewSetEnableSnippets                   ,


-- ** setHighlightCurrentLine #method:setHighlightCurrentLine#

#if defined(ENABLE_OVERLOADING)
    ViewSetHighlightCurrentLineMethodInfo   ,
#endif
    viewSetHighlightCurrentLine             ,


-- ** setIndentOnTab #method:setIndentOnTab#

#if defined(ENABLE_OVERLOADING)
    ViewSetIndentOnTabMethodInfo            ,
#endif
    viewSetIndentOnTab                      ,


-- ** setIndentWidth #method:setIndentWidth#

#if defined(ENABLE_OVERLOADING)
    ViewSetIndentWidthMethodInfo            ,
#endif
    viewSetIndentWidth                      ,


-- ** setIndenter #method:setIndenter#

#if defined(ENABLE_OVERLOADING)
    ViewSetIndenterMethodInfo               ,
#endif
    viewSetIndenter                         ,


-- ** setInsertSpacesInsteadOfTabs #method:setInsertSpacesInsteadOfTabs#

#if defined(ENABLE_OVERLOADING)
    ViewSetInsertSpacesInsteadOfTabsMethodInfo,
#endif
    viewSetInsertSpacesInsteadOfTabs        ,


-- ** setMarkAttributes #method:setMarkAttributes#

#if defined(ENABLE_OVERLOADING)
    ViewSetMarkAttributesMethodInfo         ,
#endif
    viewSetMarkAttributes                   ,


-- ** setRightMarginPosition #method:setRightMarginPosition#

#if defined(ENABLE_OVERLOADING)
    ViewSetRightMarginPositionMethodInfo    ,
#endif
    viewSetRightMarginPosition              ,


-- ** setShowLineMarks #method:setShowLineMarks#

#if defined(ENABLE_OVERLOADING)
    ViewSetShowLineMarksMethodInfo          ,
#endif
    viewSetShowLineMarks                    ,


-- ** setShowLineNumbers #method:setShowLineNumbers#

#if defined(ENABLE_OVERLOADING)
    ViewSetShowLineNumbersMethodInfo        ,
#endif
    viewSetShowLineNumbers                  ,


-- ** setShowRightMargin #method:setShowRightMargin#

#if defined(ENABLE_OVERLOADING)
    ViewSetShowRightMarginMethodInfo        ,
#endif
    viewSetShowRightMargin                  ,


-- ** setSmartBackspace #method:setSmartBackspace#

#if defined(ENABLE_OVERLOADING)
    ViewSetSmartBackspaceMethodInfo         ,
#endif
    viewSetSmartBackspace                   ,


-- ** setSmartHomeEnd #method:setSmartHomeEnd#

#if defined(ENABLE_OVERLOADING)
    ViewSetSmartHomeEndMethodInfo           ,
#endif
    viewSetSmartHomeEnd                     ,


-- ** setTabWidth #method:setTabWidth#

#if defined(ENABLE_OVERLOADING)
    ViewSetTabWidthMethodInfo               ,
#endif
    viewSetTabWidth                         ,


-- ** unindentLines #method:unindentLines#

#if defined(ENABLE_OVERLOADING)
    ViewUnindentLinesMethodInfo             ,
#endif
    viewUnindentLines                       ,




 -- * Properties


-- ** autoIndent #attr:autoIndent#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ViewAutoIndentPropertyInfo              ,
#endif
    constructViewAutoIndent                 ,
    getViewAutoIndent                       ,
    setViewAutoIndent                       ,
#if defined(ENABLE_OVERLOADING)
    viewAutoIndent                          ,
#endif


-- ** backgroundPattern #attr:backgroundPattern#
-- | Draw a specific background pattern on the view.

#if defined(ENABLE_OVERLOADING)
    ViewBackgroundPatternPropertyInfo       ,
#endif
    constructViewBackgroundPattern          ,
    getViewBackgroundPattern                ,
    setViewBackgroundPattern                ,
#if defined(ENABLE_OVERLOADING)
    viewBackgroundPattern                   ,
#endif


-- ** completion #attr:completion#
-- | The completion object associated with the view

#if defined(ENABLE_OVERLOADING)
    ViewCompletionPropertyInfo              ,
#endif
    getViewCompletion                       ,
#if defined(ENABLE_OVERLOADING)
    viewCompletion                          ,
#endif


-- ** enableSnippets #attr:enableSnippets#
-- | The property denotes if snippets should be
-- expanded when the user presses Tab after having typed a word
-- matching the snippets found in [class/@snippetManager@/].
-- 
-- The user may tab through focus-positions of the snippet if any
-- are available by pressing Tab repeatedly until the desired focus
-- position is selected.

#if defined(ENABLE_OVERLOADING)
    ViewEnableSnippetsPropertyInfo          ,
#endif
    constructViewEnableSnippets             ,
    getViewEnableSnippets                   ,
    setViewEnableSnippets                   ,
#if defined(ENABLE_OVERLOADING)
    viewEnableSnippets                      ,
#endif


-- ** highlightCurrentLine #attr:highlightCurrentLine#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ViewHighlightCurrentLinePropertyInfo    ,
#endif
    constructViewHighlightCurrentLine       ,
    getViewHighlightCurrentLine             ,
    setViewHighlightCurrentLine             ,
#if defined(ENABLE_OVERLOADING)
    viewHighlightCurrentLine                ,
#endif


-- ** indentOnTab #attr:indentOnTab#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ViewIndentOnTabPropertyInfo             ,
#endif
    constructViewIndentOnTab                ,
    getViewIndentOnTab                      ,
    setViewIndentOnTab                      ,
#if defined(ENABLE_OVERLOADING)
    viewIndentOnTab                         ,
#endif


-- ** indentWidth #attr:indentWidth#
-- | Width of an indentation step expressed in number of spaces.

#if defined(ENABLE_OVERLOADING)
    ViewIndentWidthPropertyInfo             ,
#endif
    constructViewIndentWidth                ,
    getViewIndentWidth                      ,
    setViewIndentWidth                      ,
#if defined(ENABLE_OVERLOADING)
    viewIndentWidth                         ,
#endif


-- ** indenter #attr:indenter#
-- | The property is a [iface/@indenter@/] to use to indent
-- as the user types into the [class/@view@/].

#if defined(ENABLE_OVERLOADING)
    ViewIndenterPropertyInfo                ,
#endif
    clearViewIndenter                       ,
    constructViewIndenter                   ,
    getViewIndenter                         ,
    setViewIndenter                         ,
#if defined(ENABLE_OVERLOADING)
    viewIndenter                            ,
#endif


-- ** insertSpacesInsteadOfTabs #attr:insertSpacesInsteadOfTabs#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    ViewInsertSpacesInsteadOfTabsPropertyInfo,
#endif
    constructViewInsertSpacesInsteadOfTabs  ,
    getViewInsertSpacesInsteadOfTabs        ,
    setViewInsertSpacesInsteadOfTabs        ,
#if defined(ENABLE_OVERLOADING)
    viewInsertSpacesInsteadOfTabs           ,
#endif


-- ** rightMarginPosition #attr:rightMarginPosition#
-- | Position of the right margin.

#if defined(ENABLE_OVERLOADING)
    ViewRightMarginPositionPropertyInfo     ,
#endif
    constructViewRightMarginPosition        ,
    getViewRightMarginPosition              ,
    setViewRightMarginPosition              ,
#if defined(ENABLE_OVERLOADING)
    viewRightMarginPosition                 ,
#endif


-- ** showLineMarks #attr:showLineMarks#
-- | Whether to display line mark pixbufs

#if defined(ENABLE_OVERLOADING)
    ViewShowLineMarksPropertyInfo           ,
#endif
    constructViewShowLineMarks              ,
    getViewShowLineMarks                    ,
    setViewShowLineMarks                    ,
#if defined(ENABLE_OVERLOADING)
    viewShowLineMarks                       ,
#endif


-- ** showLineNumbers #attr:showLineNumbers#
-- | Whether to display line numbers

#if defined(ENABLE_OVERLOADING)
    ViewShowLineNumbersPropertyInfo         ,
#endif
    constructViewShowLineNumbers            ,
    getViewShowLineNumbers                  ,
    setViewShowLineNumbers                  ,
#if defined(ENABLE_OVERLOADING)
    viewShowLineNumbers                     ,
#endif


-- ** showRightMargin #attr:showRightMargin#
-- | Whether to display the right margin.

#if defined(ENABLE_OVERLOADING)
    ViewShowRightMarginPropertyInfo         ,
#endif
    constructViewShowRightMargin            ,
    getViewShowRightMargin                  ,
    setViewShowRightMargin                  ,
#if defined(ENABLE_OVERLOADING)
    viewShowRightMargin                     ,
#endif


-- ** smartBackspace #attr:smartBackspace#
-- | Whether smart Backspace should be used.

#if defined(ENABLE_OVERLOADING)
    ViewSmartBackspacePropertyInfo          ,
#endif
    constructViewSmartBackspace             ,
    getViewSmartBackspace                   ,
    setViewSmartBackspace                   ,
#if defined(ENABLE_OVERLOADING)
    viewSmartBackspace                      ,
#endif


-- ** smartHomeEnd #attr:smartHomeEnd#
-- | Set the behavior of the HOME and END keys.

#if defined(ENABLE_OVERLOADING)
    ViewSmartHomeEndPropertyInfo            ,
#endif
    constructViewSmartHomeEnd               ,
    getViewSmartHomeEnd                     ,
    setViewSmartHomeEnd                     ,
#if defined(ENABLE_OVERLOADING)
    viewSmartHomeEnd                        ,
#endif


-- ** spaceDrawer #attr:spaceDrawer#
-- | The [class/@spaceDrawer@/] object associated with the view.4

#if defined(ENABLE_OVERLOADING)
    ViewSpaceDrawerPropertyInfo             ,
#endif
    getViewSpaceDrawer                      ,
#if defined(ENABLE_OVERLOADING)
    viewSpaceDrawer                         ,
#endif


-- ** tabWidth #attr:tabWidth#
-- | Width of a tab character expressed in number of spaces.

#if defined(ENABLE_OVERLOADING)
    ViewTabWidthPropertyInfo                ,
#endif
    constructViewTabWidth                   ,
    getViewTabWidth                         ,
    setViewTabWidth                         ,
#if defined(ENABLE_OVERLOADING)
    viewTabWidth                            ,
#endif




 -- * Signals


-- ** changeCase #signal:changeCase#

    ViewChangeCaseCallback                  ,
#if defined(ENABLE_OVERLOADING)
    ViewChangeCaseSignalInfo                ,
#endif
    afterViewChangeCase                     ,
    onViewChangeCase                        ,


-- ** changeNumber #signal:changeNumber#

    ViewChangeNumberCallback                ,
#if defined(ENABLE_OVERLOADING)
    ViewChangeNumberSignalInfo              ,
#endif
    afterViewChangeNumber                   ,
    onViewChangeNumber                      ,


-- ** joinLines #signal:joinLines#

    ViewJoinLinesCallback                   ,
#if defined(ENABLE_OVERLOADING)
    ViewJoinLinesSignalInfo                 ,
#endif
    afterViewJoinLines                      ,
    onViewJoinLines                         ,


-- ** lineMarkActivated #signal:lineMarkActivated#

    ViewLineMarkActivatedCallback           ,
#if defined(ENABLE_OVERLOADING)
    ViewLineMarkActivatedSignalInfo         ,
#endif
    afterViewLineMarkActivated              ,
    onViewLineMarkActivated                 ,


-- ** moveLines #signal:moveLines#

    ViewMoveLinesCallback                   ,
#if defined(ENABLE_OVERLOADING)
    ViewMoveLinesSignalInfo                 ,
#endif
    afterViewMoveLines                      ,
    onViewMoveLines                         ,


-- ** moveToMatchingBracket #signal:moveToMatchingBracket#

    ViewMoveToMatchingBracketCallback       ,
#if defined(ENABLE_OVERLOADING)
    ViewMoveToMatchingBracketSignalInfo     ,
#endif
    afterViewMoveToMatchingBracket          ,
    onViewMoveToMatchingBracket             ,


-- ** moveWords #signal:moveWords#

    ViewMoveWordsCallback                   ,
#if defined(ENABLE_OVERLOADING)
    ViewMoveWordsSignalInfo                 ,
#endif
    afterViewMoveWords                      ,
    onViewMoveWords                         ,


-- ** pushSnippet #signal:pushSnippet#

    ViewPushSnippetCallback                 ,
#if defined(ENABLE_OVERLOADING)
    ViewPushSnippetSignalInfo               ,
#endif
    afterViewPushSnippet                    ,
    onViewPushSnippet                       ,


-- ** showCompletion #signal:showCompletion#

    ViewShowCompletionCallback              ,
#if defined(ENABLE_OVERLOADING)
    ViewShowCompletionSignalInfo            ,
#endif
    afterViewShowCompletion                 ,
    onViewShowCompletion                    ,


-- ** smartHomeEnd #signal:smartHomeEnd#

    ViewSmartHomeEndCallback                ,
#if defined(ENABLE_OVERLOADING)
    ViewSmartHomeEndSignalInfo              ,
#endif
    afterViewSmartHomeEnd                   ,
    onViewSmartHomeEnd                      ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gdk.Flags as Gdk.Flags
import qualified GI.Gtk.Enums as Gtk.Enums
import qualified GI.Gtk.Interfaces.Accessible as Gtk.Accessible
import qualified GI.Gtk.Interfaces.Buildable as Gtk.Buildable
import qualified GI.Gtk.Interfaces.ConstraintTarget as Gtk.ConstraintTarget
import qualified GI.Gtk.Interfaces.Scrollable as Gtk.Scrollable
import qualified GI.Gtk.Objects.TextView as Gtk.TextView
import qualified GI.Gtk.Objects.Widget as Gtk.Widget
import qualified GI.Gtk.Structs.TextIter as Gtk.TextIter
import {-# SOURCE #-} qualified GI.GtkSource.Enums as GtkSource.Enums
import {-# SOURCE #-} qualified GI.GtkSource.Interfaces.Indenter as GtkSource.Indenter
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Buffer as GtkSource.Buffer
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Completion as GtkSource.Completion
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Gutter as GtkSource.Gutter
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Hover as GtkSource.Hover
import {-# SOURCE #-} qualified GI.GtkSource.Objects.MarkAttributes as GtkSource.MarkAttributes
import {-# SOURCE #-} qualified GI.GtkSource.Objects.Snippet as GtkSource.Snippet
import {-# SOURCE #-} qualified GI.GtkSource.Objects.SpaceDrawer as GtkSource.SpaceDrawer

-- | Memory-managed wrapper type.
newtype View = View (SP.ManagedPtr View)
    deriving (View -> View -> Bool
(View -> View -> Bool) -> (View -> View -> Bool) -> Eq View
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: View -> View -> Bool
== :: View -> View -> Bool
$c/= :: View -> View -> Bool
/= :: View -> View -> Bool
Eq)

instance SP.ManagedPtrNewtype View where
    toManagedPtr :: View -> ManagedPtr View
toManagedPtr (View ManagedPtr View
p) = ManagedPtr View
p

foreign import ccall "gtk_source_view_get_type"
    c_gtk_source_view_get_type :: IO B.Types.GType

instance B.Types.TypedObject View where
    glibType :: IO GType
glibType = IO GType
c_gtk_source_view_get_type

instance B.Types.GObject View

-- | Type class for types which can be safely cast to `View`, for instance with `toView`.
class (SP.GObject o, O.IsDescendantOf View o) => IsView o
instance (SP.GObject o, O.IsDescendantOf View o) => IsView o

instance O.HasParentTypes View
type instance O.ParentTypes View = '[Gtk.TextView.TextView, Gtk.Widget.Widget, GObject.Object.Object, Gtk.Accessible.Accessible, Gtk.Buildable.Buildable, Gtk.ConstraintTarget.ConstraintTarget, Gtk.Scrollable.Scrollable]

-- | Cast to `View`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toView :: (MIO.MonadIO m, IsView o) => o -> m View
toView :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m View
toView = IO View -> m View
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO View -> m View) -> (o -> IO View) -> o -> m View
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr View -> View) -> o -> IO View
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr View -> View
View

-- | Convert 'View' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe View) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_gtk_source_view_get_type
    gvalueSet_ :: Ptr GValue -> Maybe View -> IO ()
gvalueSet_ Ptr GValue
gv Maybe View
P.Nothing = Ptr GValue -> Ptr View -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr View
forall a. Ptr a
FP.nullPtr :: FP.Ptr View)
    gvalueSet_ Ptr GValue
gv (P.Just View
obj) = View -> (Ptr View -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr View
obj (Ptr GValue -> Ptr View -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe View)
gvalueGet_ Ptr GValue
gv = do
        Ptr View
ptr <- Ptr GValue -> IO (Ptr View)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr View)
        if Ptr View
ptr Ptr View -> Ptr View -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr View
forall a. Ptr a
FP.nullPtr
        then View -> Maybe View
forall a. a -> Maybe a
P.Just (View -> Maybe View) -> IO View -> IO (Maybe View)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr View -> View) -> Ptr View -> IO View
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr View -> View
View Ptr View
ptr
        else Maybe View -> IO (Maybe View)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe View
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveViewMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveViewMethod "actionSetEnabled" o = Gtk.Widget.WidgetActionSetEnabledMethodInfo
    ResolveViewMethod "activate" o = Gtk.Widget.WidgetActivateMethodInfo
    ResolveViewMethod "activateAction" o = Gtk.Widget.WidgetActivateActionMethodInfo
    ResolveViewMethod "activateDefault" o = Gtk.Widget.WidgetActivateDefaultMethodInfo
    ResolveViewMethod "addChildAtAnchor" o = Gtk.TextView.TextViewAddChildAtAnchorMethodInfo
    ResolveViewMethod "addController" o = Gtk.Widget.WidgetAddControllerMethodInfo
    ResolveViewMethod "addCssClass" o = Gtk.Widget.WidgetAddCssClassMethodInfo
    ResolveViewMethod "addMnemonicLabel" o = Gtk.Widget.WidgetAddMnemonicLabelMethodInfo
    ResolveViewMethod "addOverlay" o = Gtk.TextView.TextViewAddOverlayMethodInfo
    ResolveViewMethod "addTickCallback" o = Gtk.Widget.WidgetAddTickCallbackMethodInfo
    ResolveViewMethod "allocate" o = Gtk.Widget.WidgetAllocateMethodInfo
    ResolveViewMethod "backwardDisplayLine" o = Gtk.TextView.TextViewBackwardDisplayLineMethodInfo
    ResolveViewMethod "backwardDisplayLineStart" o = Gtk.TextView.TextViewBackwardDisplayLineStartMethodInfo
    ResolveViewMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveViewMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveViewMethod "bufferToWindowCoords" o = Gtk.TextView.TextViewBufferToWindowCoordsMethodInfo
    ResolveViewMethod "childFocus" o = Gtk.Widget.WidgetChildFocusMethodInfo
    ResolveViewMethod "computeBounds" o = Gtk.Widget.WidgetComputeBoundsMethodInfo
    ResolveViewMethod "computeExpand" o = Gtk.Widget.WidgetComputeExpandMethodInfo
    ResolveViewMethod "computePoint" o = Gtk.Widget.WidgetComputePointMethodInfo
    ResolveViewMethod "computeTransform" o = Gtk.Widget.WidgetComputeTransformMethodInfo
    ResolveViewMethod "contains" o = Gtk.Widget.WidgetContainsMethodInfo
    ResolveViewMethod "createPangoContext" o = Gtk.Widget.WidgetCreatePangoContextMethodInfo
    ResolveViewMethod "createPangoLayout" o = Gtk.Widget.WidgetCreatePangoLayoutMethodInfo
    ResolveViewMethod "disposeTemplate" o = Gtk.Widget.WidgetDisposeTemplateMethodInfo
    ResolveViewMethod "dragCheckThreshold" o = Gtk.Widget.WidgetDragCheckThresholdMethodInfo
    ResolveViewMethod "errorBell" o = Gtk.Widget.WidgetErrorBellMethodInfo
    ResolveViewMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveViewMethod "forwardDisplayLine" o = Gtk.TextView.TextViewForwardDisplayLineMethodInfo
    ResolveViewMethod "forwardDisplayLineEnd" o = Gtk.TextView.TextViewForwardDisplayLineEndMethodInfo
    ResolveViewMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveViewMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveViewMethod "grabFocus" o = Gtk.Widget.WidgetGrabFocusMethodInfo
    ResolveViewMethod "hasCssClass" o = Gtk.Widget.WidgetHasCssClassMethodInfo
    ResolveViewMethod "hasDefault" o = Gtk.Widget.WidgetHasDefaultMethodInfo
    ResolveViewMethod "hasFocus" o = Gtk.Widget.WidgetHasFocusMethodInfo
    ResolveViewMethod "hasVisibleFocus" o = Gtk.Widget.WidgetHasVisibleFocusMethodInfo
    ResolveViewMethod "hide" o = Gtk.Widget.WidgetHideMethodInfo
    ResolveViewMethod "imContextFilterKeypress" o = Gtk.TextView.TextViewImContextFilterKeypressMethodInfo
    ResolveViewMethod "inDestruction" o = Gtk.Widget.WidgetInDestructionMethodInfo
    ResolveViewMethod "indentLines" o = ViewIndentLinesMethodInfo
    ResolveViewMethod "initTemplate" o = Gtk.Widget.WidgetInitTemplateMethodInfo
    ResolveViewMethod "insertActionGroup" o = Gtk.Widget.WidgetInsertActionGroupMethodInfo
    ResolveViewMethod "insertAfter" o = Gtk.Widget.WidgetInsertAfterMethodInfo
    ResolveViewMethod "insertBefore" o = Gtk.Widget.WidgetInsertBeforeMethodInfo
    ResolveViewMethod "isAncestor" o = Gtk.Widget.WidgetIsAncestorMethodInfo
    ResolveViewMethod "isDrawable" o = Gtk.Widget.WidgetIsDrawableMethodInfo
    ResolveViewMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveViewMethod "isFocus" o = Gtk.Widget.WidgetIsFocusMethodInfo
    ResolveViewMethod "isSensitive" o = Gtk.Widget.WidgetIsSensitiveMethodInfo
    ResolveViewMethod "isVisible" o = Gtk.Widget.WidgetIsVisibleMethodInfo
    ResolveViewMethod "keynavFailed" o = Gtk.Widget.WidgetKeynavFailedMethodInfo
    ResolveViewMethod "listMnemonicLabels" o = Gtk.Widget.WidgetListMnemonicLabelsMethodInfo
    ResolveViewMethod "map" o = Gtk.Widget.WidgetMapMethodInfo
    ResolveViewMethod "measure" o = Gtk.Widget.WidgetMeasureMethodInfo
    ResolveViewMethod "mnemonicActivate" o = Gtk.Widget.WidgetMnemonicActivateMethodInfo
    ResolveViewMethod "moveMarkOnscreen" o = Gtk.TextView.TextViewMoveMarkOnscreenMethodInfo
    ResolveViewMethod "moveOverlay" o = Gtk.TextView.TextViewMoveOverlayMethodInfo
    ResolveViewMethod "moveVisually" o = Gtk.TextView.TextViewMoveVisuallyMethodInfo
    ResolveViewMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveViewMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveViewMethod "observeChildren" o = Gtk.Widget.WidgetObserveChildrenMethodInfo
    ResolveViewMethod "observeControllers" o = Gtk.Widget.WidgetObserveControllersMethodInfo
    ResolveViewMethod "pick" o = Gtk.Widget.WidgetPickMethodInfo
    ResolveViewMethod "placeCursorOnscreen" o = Gtk.TextView.TextViewPlaceCursorOnscreenMethodInfo
    ResolveViewMethod "pushSnippet" o = ViewPushSnippetMethodInfo
    ResolveViewMethod "queueAllocate" o = Gtk.Widget.WidgetQueueAllocateMethodInfo
    ResolveViewMethod "queueDraw" o = Gtk.Widget.WidgetQueueDrawMethodInfo
    ResolveViewMethod "queueResize" o = Gtk.Widget.WidgetQueueResizeMethodInfo
    ResolveViewMethod "realize" o = Gtk.Widget.WidgetRealizeMethodInfo
    ResolveViewMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveViewMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveViewMethod "remove" o = Gtk.TextView.TextViewRemoveMethodInfo
    ResolveViewMethod "removeController" o = Gtk.Widget.WidgetRemoveControllerMethodInfo
    ResolveViewMethod "removeCssClass" o = Gtk.Widget.WidgetRemoveCssClassMethodInfo
    ResolveViewMethod "removeMnemonicLabel" o = Gtk.Widget.WidgetRemoveMnemonicLabelMethodInfo
    ResolveViewMethod "removeTickCallback" o = Gtk.Widget.WidgetRemoveTickCallbackMethodInfo
    ResolveViewMethod "resetCursorBlink" o = Gtk.TextView.TextViewResetCursorBlinkMethodInfo
    ResolveViewMethod "resetImContext" o = Gtk.TextView.TextViewResetImContextMethodInfo
    ResolveViewMethod "resetProperty" o = Gtk.Accessible.AccessibleResetPropertyMethodInfo
    ResolveViewMethod "resetRelation" o = Gtk.Accessible.AccessibleResetRelationMethodInfo
    ResolveViewMethod "resetState" o = Gtk.Accessible.AccessibleResetStateMethodInfo
    ResolveViewMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveViewMethod "scrollMarkOnscreen" o = Gtk.TextView.TextViewScrollMarkOnscreenMethodInfo
    ResolveViewMethod "scrollToIter" o = Gtk.TextView.TextViewScrollToIterMethodInfo
    ResolveViewMethod "scrollToMark" o = Gtk.TextView.TextViewScrollToMarkMethodInfo
    ResolveViewMethod "shouldLayout" o = Gtk.Widget.WidgetShouldLayoutMethodInfo
    ResolveViewMethod "show" o = Gtk.Widget.WidgetShowMethodInfo
    ResolveViewMethod "sizeAllocate" o = Gtk.Widget.WidgetSizeAllocateMethodInfo
    ResolveViewMethod "snapshotChild" o = Gtk.Widget.WidgetSnapshotChildMethodInfo
    ResolveViewMethod "startsDisplayLine" o = Gtk.TextView.TextViewStartsDisplayLineMethodInfo
    ResolveViewMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveViewMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveViewMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveViewMethod "translateCoordinates" o = Gtk.Widget.WidgetTranslateCoordinatesMethodInfo
    ResolveViewMethod "triggerTooltipQuery" o = Gtk.Widget.WidgetTriggerTooltipQueryMethodInfo
    ResolveViewMethod "unindentLines" o = ViewUnindentLinesMethodInfo
    ResolveViewMethod "unmap" o = Gtk.Widget.WidgetUnmapMethodInfo
    ResolveViewMethod "unparent" o = Gtk.Widget.WidgetUnparentMethodInfo
    ResolveViewMethod "unrealize" o = Gtk.Widget.WidgetUnrealizeMethodInfo
    ResolveViewMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveViewMethod "unsetStateFlags" o = Gtk.Widget.WidgetUnsetStateFlagsMethodInfo
    ResolveViewMethod "updateNextAccessibleSibling" o = Gtk.Accessible.AccessibleUpdateNextAccessibleSiblingMethodInfo
    ResolveViewMethod "updateProperty" o = Gtk.Accessible.AccessibleUpdatePropertyMethodInfo
    ResolveViewMethod "updateRelation" o = Gtk.Accessible.AccessibleUpdateRelationMethodInfo
    ResolveViewMethod "updateState" o = Gtk.Accessible.AccessibleUpdateStateMethodInfo
    ResolveViewMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveViewMethod "windowToBufferCoords" o = Gtk.TextView.TextViewWindowToBufferCoordsMethodInfo
    ResolveViewMethod "getAcceptsTab" o = Gtk.TextView.TextViewGetAcceptsTabMethodInfo
    ResolveViewMethod "getAccessibleParent" o = Gtk.Accessible.AccessibleGetAccessibleParentMethodInfo
    ResolveViewMethod "getAccessibleRole" o = Gtk.Accessible.AccessibleGetAccessibleRoleMethodInfo
    ResolveViewMethod "getAllocatedBaseline" o = Gtk.Widget.WidgetGetAllocatedBaselineMethodInfo
    ResolveViewMethod "getAllocatedHeight" o = Gtk.Widget.WidgetGetAllocatedHeightMethodInfo
    ResolveViewMethod "getAllocatedWidth" o = Gtk.Widget.WidgetGetAllocatedWidthMethodInfo
    ResolveViewMethod "getAllocation" o = Gtk.Widget.WidgetGetAllocationMethodInfo
    ResolveViewMethod "getAncestor" o = Gtk.Widget.WidgetGetAncestorMethodInfo
    ResolveViewMethod "getAtContext" o = Gtk.Accessible.AccessibleGetAtContextMethodInfo
    ResolveViewMethod "getAutoIndent" o = ViewGetAutoIndentMethodInfo
    ResolveViewMethod "getBackgroundPattern" o = ViewGetBackgroundPatternMethodInfo
    ResolveViewMethod "getBorder" o = Gtk.Scrollable.ScrollableGetBorderMethodInfo
    ResolveViewMethod "getBottomMargin" o = Gtk.TextView.TextViewGetBottomMarginMethodInfo
    ResolveViewMethod "getBounds" o = Gtk.Accessible.AccessibleGetBoundsMethodInfo
    ResolveViewMethod "getBuffer" o = Gtk.TextView.TextViewGetBufferMethodInfo
    ResolveViewMethod "getBuildableId" o = Gtk.Buildable.BuildableGetBuildableIdMethodInfo
    ResolveViewMethod "getCanFocus" o = Gtk.Widget.WidgetGetCanFocusMethodInfo
    ResolveViewMethod "getCanTarget" o = Gtk.Widget.WidgetGetCanTargetMethodInfo
    ResolveViewMethod "getChildVisible" o = Gtk.Widget.WidgetGetChildVisibleMethodInfo
    ResolveViewMethod "getClipboard" o = Gtk.Widget.WidgetGetClipboardMethodInfo
    ResolveViewMethod "getColor" o = Gtk.Widget.WidgetGetColorMethodInfo
    ResolveViewMethod "getCompletion" o = ViewGetCompletionMethodInfo
    ResolveViewMethod "getCssClasses" o = Gtk.Widget.WidgetGetCssClassesMethodInfo
    ResolveViewMethod "getCssName" o = Gtk.Widget.WidgetGetCssNameMethodInfo
    ResolveViewMethod "getCursor" o = Gtk.Widget.WidgetGetCursorMethodInfo
    ResolveViewMethod "getCursorLocations" o = Gtk.TextView.TextViewGetCursorLocationsMethodInfo
    ResolveViewMethod "getCursorVisible" o = Gtk.TextView.TextViewGetCursorVisibleMethodInfo
    ResolveViewMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveViewMethod "getDirection" o = Gtk.Widget.WidgetGetDirectionMethodInfo
    ResolveViewMethod "getDisplay" o = Gtk.Widget.WidgetGetDisplayMethodInfo
    ResolveViewMethod "getEditable" o = Gtk.TextView.TextViewGetEditableMethodInfo
    ResolveViewMethod "getEnableSnippets" o = ViewGetEnableSnippetsMethodInfo
    ResolveViewMethod "getExtraMenu" o = Gtk.TextView.TextViewGetExtraMenuMethodInfo
    ResolveViewMethod "getFirstAccessibleChild" o = Gtk.Accessible.AccessibleGetFirstAccessibleChildMethodInfo
    ResolveViewMethod "getFirstChild" o = Gtk.Widget.WidgetGetFirstChildMethodInfo
    ResolveViewMethod "getFocusChild" o = Gtk.Widget.WidgetGetFocusChildMethodInfo
    ResolveViewMethod "getFocusOnClick" o = Gtk.Widget.WidgetGetFocusOnClickMethodInfo
    ResolveViewMethod "getFocusable" o = Gtk.Widget.WidgetGetFocusableMethodInfo
    ResolveViewMethod "getFontMap" o = Gtk.Widget.WidgetGetFontMapMethodInfo
    ResolveViewMethod "getFontOptions" o = Gtk.Widget.WidgetGetFontOptionsMethodInfo
    ResolveViewMethod "getFrameClock" o = Gtk.Widget.WidgetGetFrameClockMethodInfo
    ResolveViewMethod "getGutter" o = ViewGetGutterMethodInfo
    ResolveViewMethod "getHadjustment" o = Gtk.Scrollable.ScrollableGetHadjustmentMethodInfo
    ResolveViewMethod "getHalign" o = Gtk.Widget.WidgetGetHalignMethodInfo
    ResolveViewMethod "getHasTooltip" o = Gtk.Widget.WidgetGetHasTooltipMethodInfo
    ResolveViewMethod "getHeight" o = Gtk.Widget.WidgetGetHeightMethodInfo
    ResolveViewMethod "getHexpand" o = Gtk.Widget.WidgetGetHexpandMethodInfo
    ResolveViewMethod "getHexpandSet" o = Gtk.Widget.WidgetGetHexpandSetMethodInfo
    ResolveViewMethod "getHighlightCurrentLine" o = ViewGetHighlightCurrentLineMethodInfo
    ResolveViewMethod "getHover" o = ViewGetHoverMethodInfo
    ResolveViewMethod "getHscrollPolicy" o = Gtk.Scrollable.ScrollableGetHscrollPolicyMethodInfo
    ResolveViewMethod "getIndent" o = Gtk.TextView.TextViewGetIndentMethodInfo
    ResolveViewMethod "getIndentOnTab" o = ViewGetIndentOnTabMethodInfo
    ResolveViewMethod "getIndentWidth" o = ViewGetIndentWidthMethodInfo
    ResolveViewMethod "getIndenter" o = ViewGetIndenterMethodInfo
    ResolveViewMethod "getInputHints" o = Gtk.TextView.TextViewGetInputHintsMethodInfo
    ResolveViewMethod "getInputPurpose" o = Gtk.TextView.TextViewGetInputPurposeMethodInfo
    ResolveViewMethod "getInsertSpacesInsteadOfTabs" o = ViewGetInsertSpacesInsteadOfTabsMethodInfo
    ResolveViewMethod "getIterAtLocation" o = Gtk.TextView.TextViewGetIterAtLocationMethodInfo
    ResolveViewMethod "getIterAtPosition" o = Gtk.TextView.TextViewGetIterAtPositionMethodInfo
    ResolveViewMethod "getIterLocation" o = Gtk.TextView.TextViewGetIterLocationMethodInfo
    ResolveViewMethod "getJustification" o = Gtk.TextView.TextViewGetJustificationMethodInfo
    ResolveViewMethod "getLastChild" o = Gtk.Widget.WidgetGetLastChildMethodInfo
    ResolveViewMethod "getLayoutManager" o = Gtk.Widget.WidgetGetLayoutManagerMethodInfo
    ResolveViewMethod "getLeftMargin" o = Gtk.TextView.TextViewGetLeftMarginMethodInfo
    ResolveViewMethod "getLineAtY" o = Gtk.TextView.TextViewGetLineAtYMethodInfo
    ResolveViewMethod "getLineYrange" o = Gtk.TextView.TextViewGetLineYrangeMethodInfo
    ResolveViewMethod "getLtrContext" o = Gtk.TextView.TextViewGetLtrContextMethodInfo
    ResolveViewMethod "getMapped" o = Gtk.Widget.WidgetGetMappedMethodInfo
    ResolveViewMethod "getMarginBottom" o = Gtk.Widget.WidgetGetMarginBottomMethodInfo
    ResolveViewMethod "getMarginEnd" o = Gtk.Widget.WidgetGetMarginEndMethodInfo
    ResolveViewMethod "getMarginStart" o = Gtk.Widget.WidgetGetMarginStartMethodInfo
    ResolveViewMethod "getMarginTop" o = Gtk.Widget.WidgetGetMarginTopMethodInfo
    ResolveViewMethod "getMarkAttributes" o = ViewGetMarkAttributesMethodInfo
    ResolveViewMethod "getMonospace" o = Gtk.TextView.TextViewGetMonospaceMethodInfo
    ResolveViewMethod "getName" o = Gtk.Widget.WidgetGetNameMethodInfo
    ResolveViewMethod "getNative" o = Gtk.Widget.WidgetGetNativeMethodInfo
    ResolveViewMethod "getNextAccessibleSibling" o = Gtk.Accessible.AccessibleGetNextAccessibleSiblingMethodInfo
    ResolveViewMethod "getNextSibling" o = Gtk.Widget.WidgetGetNextSiblingMethodInfo
    ResolveViewMethod "getOpacity" o = Gtk.Widget.WidgetGetOpacityMethodInfo
    ResolveViewMethod "getOverflow" o = Gtk.Widget.WidgetGetOverflowMethodInfo
    ResolveViewMethod "getOverwrite" o = Gtk.TextView.TextViewGetOverwriteMethodInfo
    ResolveViewMethod "getPangoContext" o = Gtk.Widget.WidgetGetPangoContextMethodInfo
    ResolveViewMethod "getParent" o = Gtk.Widget.WidgetGetParentMethodInfo
    ResolveViewMethod "getPixelsAboveLines" o = Gtk.TextView.TextViewGetPixelsAboveLinesMethodInfo
    ResolveViewMethod "getPixelsBelowLines" o = Gtk.TextView.TextViewGetPixelsBelowLinesMethodInfo
    ResolveViewMethod "getPixelsInsideWrap" o = Gtk.TextView.TextViewGetPixelsInsideWrapMethodInfo
    ResolveViewMethod "getPlatformState" o = Gtk.Accessible.AccessibleGetPlatformStateMethodInfo
    ResolveViewMethod "getPreferredSize" o = Gtk.Widget.WidgetGetPreferredSizeMethodInfo
    ResolveViewMethod "getPrevSibling" o = Gtk.Widget.WidgetGetPrevSiblingMethodInfo
    ResolveViewMethod "getPrimaryClipboard" o = Gtk.Widget.WidgetGetPrimaryClipboardMethodInfo
    ResolveViewMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveViewMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveViewMethod "getRealized" o = Gtk.Widget.WidgetGetRealizedMethodInfo
    ResolveViewMethod "getReceivesDefault" o = Gtk.Widget.WidgetGetReceivesDefaultMethodInfo
    ResolveViewMethod "getRequestMode" o = Gtk.Widget.WidgetGetRequestModeMethodInfo
    ResolveViewMethod "getRightMargin" o = Gtk.TextView.TextViewGetRightMarginMethodInfo
    ResolveViewMethod "getRightMarginPosition" o = ViewGetRightMarginPositionMethodInfo
    ResolveViewMethod "getRoot" o = Gtk.Widget.WidgetGetRootMethodInfo
    ResolveViewMethod "getRtlContext" o = Gtk.TextView.TextViewGetRtlContextMethodInfo
    ResolveViewMethod "getScaleFactor" o = Gtk.Widget.WidgetGetScaleFactorMethodInfo
    ResolveViewMethod "getSensitive" o = Gtk.Widget.WidgetGetSensitiveMethodInfo
    ResolveViewMethod "getSettings" o = Gtk.Widget.WidgetGetSettingsMethodInfo
    ResolveViewMethod "getShowLineMarks" o = ViewGetShowLineMarksMethodInfo
    ResolveViewMethod "getShowLineNumbers" o = ViewGetShowLineNumbersMethodInfo
    ResolveViewMethod "getShowRightMargin" o = ViewGetShowRightMarginMethodInfo
    ResolveViewMethod "getSize" o = Gtk.Widget.WidgetGetSizeMethodInfo
    ResolveViewMethod "getSizeRequest" o = Gtk.Widget.WidgetGetSizeRequestMethodInfo
    ResolveViewMethod "getSmartBackspace" o = ViewGetSmartBackspaceMethodInfo
    ResolveViewMethod "getSmartHomeEnd" o = ViewGetSmartHomeEndMethodInfo
    ResolveViewMethod "getSpaceDrawer" o = ViewGetSpaceDrawerMethodInfo
    ResolveViewMethod "getStateFlags" o = Gtk.Widget.WidgetGetStateFlagsMethodInfo
    ResolveViewMethod "getStyleContext" o = Gtk.Widget.WidgetGetStyleContextMethodInfo
    ResolveViewMethod "getTabWidth" o = ViewGetTabWidthMethodInfo
    ResolveViewMethod "getTabs" o = Gtk.TextView.TextViewGetTabsMethodInfo
    ResolveViewMethod "getTemplateChild" o = Gtk.Widget.WidgetGetTemplateChildMethodInfo
    ResolveViewMethod "getTooltipMarkup" o = Gtk.Widget.WidgetGetTooltipMarkupMethodInfo
    ResolveViewMethod "getTooltipText" o = Gtk.Widget.WidgetGetTooltipTextMethodInfo
    ResolveViewMethod "getTopMargin" o = Gtk.TextView.TextViewGetTopMarginMethodInfo
    ResolveViewMethod "getVadjustment" o = Gtk.Scrollable.ScrollableGetVadjustmentMethodInfo
    ResolveViewMethod "getValign" o = Gtk.Widget.WidgetGetValignMethodInfo
    ResolveViewMethod "getVexpand" o = Gtk.Widget.WidgetGetVexpandMethodInfo
    ResolveViewMethod "getVexpandSet" o = Gtk.Widget.WidgetGetVexpandSetMethodInfo
    ResolveViewMethod "getVisible" o = Gtk.Widget.WidgetGetVisibleMethodInfo
    ResolveViewMethod "getVisibleRect" o = Gtk.TextView.TextViewGetVisibleRectMethodInfo
    ResolveViewMethod "getVisualColumn" o = ViewGetVisualColumnMethodInfo
    ResolveViewMethod "getVscrollPolicy" o = Gtk.Scrollable.ScrollableGetVscrollPolicyMethodInfo
    ResolveViewMethod "getWidth" o = Gtk.Widget.WidgetGetWidthMethodInfo
    ResolveViewMethod "getWrapMode" o = Gtk.TextView.TextViewGetWrapModeMethodInfo
    ResolveViewMethod "setAcceptsTab" o = Gtk.TextView.TextViewSetAcceptsTabMethodInfo
    ResolveViewMethod "setAccessibleParent" o = Gtk.Accessible.AccessibleSetAccessibleParentMethodInfo
    ResolveViewMethod "setAutoIndent" o = ViewSetAutoIndentMethodInfo
    ResolveViewMethod "setBackgroundPattern" o = ViewSetBackgroundPatternMethodInfo
    ResolveViewMethod "setBottomMargin" o = Gtk.TextView.TextViewSetBottomMarginMethodInfo
    ResolveViewMethod "setBuffer" o = Gtk.TextView.TextViewSetBufferMethodInfo
    ResolveViewMethod "setCanFocus" o = Gtk.Widget.WidgetSetCanFocusMethodInfo
    ResolveViewMethod "setCanTarget" o = Gtk.Widget.WidgetSetCanTargetMethodInfo
    ResolveViewMethod "setChildVisible" o = Gtk.Widget.WidgetSetChildVisibleMethodInfo
    ResolveViewMethod "setCssClasses" o = Gtk.Widget.WidgetSetCssClassesMethodInfo
    ResolveViewMethod "setCursor" o = Gtk.Widget.WidgetSetCursorMethodInfo
    ResolveViewMethod "setCursorFromName" o = Gtk.Widget.WidgetSetCursorFromNameMethodInfo
    ResolveViewMethod "setCursorVisible" o = Gtk.TextView.TextViewSetCursorVisibleMethodInfo
    ResolveViewMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveViewMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveViewMethod "setDirection" o = Gtk.Widget.WidgetSetDirectionMethodInfo
    ResolveViewMethod "setEditable" o = Gtk.TextView.TextViewSetEditableMethodInfo
    ResolveViewMethod "setEnableSnippets" o = ViewSetEnableSnippetsMethodInfo
    ResolveViewMethod "setExtraMenu" o = Gtk.TextView.TextViewSetExtraMenuMethodInfo
    ResolveViewMethod "setFocusChild" o = Gtk.Widget.WidgetSetFocusChildMethodInfo
    ResolveViewMethod "setFocusOnClick" o = Gtk.Widget.WidgetSetFocusOnClickMethodInfo
    ResolveViewMethod "setFocusable" o = Gtk.Widget.WidgetSetFocusableMethodInfo
    ResolveViewMethod "setFontMap" o = Gtk.Widget.WidgetSetFontMapMethodInfo
    ResolveViewMethod "setFontOptions" o = Gtk.Widget.WidgetSetFontOptionsMethodInfo
    ResolveViewMethod "setGutter" o = Gtk.TextView.TextViewSetGutterMethodInfo
    ResolveViewMethod "setHadjustment" o = Gtk.Scrollable.ScrollableSetHadjustmentMethodInfo
    ResolveViewMethod "setHalign" o = Gtk.Widget.WidgetSetHalignMethodInfo
    ResolveViewMethod "setHasTooltip" o = Gtk.Widget.WidgetSetHasTooltipMethodInfo
    ResolveViewMethod "setHexpand" o = Gtk.Widget.WidgetSetHexpandMethodInfo
    ResolveViewMethod "setHexpandSet" o = Gtk.Widget.WidgetSetHexpandSetMethodInfo
    ResolveViewMethod "setHighlightCurrentLine" o = ViewSetHighlightCurrentLineMethodInfo
    ResolveViewMethod "setHscrollPolicy" o = Gtk.Scrollable.ScrollableSetHscrollPolicyMethodInfo
    ResolveViewMethod "setIndent" o = Gtk.TextView.TextViewSetIndentMethodInfo
    ResolveViewMethod "setIndentOnTab" o = ViewSetIndentOnTabMethodInfo
    ResolveViewMethod "setIndentWidth" o = ViewSetIndentWidthMethodInfo
    ResolveViewMethod "setIndenter" o = ViewSetIndenterMethodInfo
    ResolveViewMethod "setInputHints" o = Gtk.TextView.TextViewSetInputHintsMethodInfo
    ResolveViewMethod "setInputPurpose" o = Gtk.TextView.TextViewSetInputPurposeMethodInfo
    ResolveViewMethod "setInsertSpacesInsteadOfTabs" o = ViewSetInsertSpacesInsteadOfTabsMethodInfo
    ResolveViewMethod "setJustification" o = Gtk.TextView.TextViewSetJustificationMethodInfo
    ResolveViewMethod "setLayoutManager" o = Gtk.Widget.WidgetSetLayoutManagerMethodInfo
    ResolveViewMethod "setLeftMargin" o = Gtk.TextView.TextViewSetLeftMarginMethodInfo
    ResolveViewMethod "setMarginBottom" o = Gtk.Widget.WidgetSetMarginBottomMethodInfo
    ResolveViewMethod "setMarginEnd" o = Gtk.Widget.WidgetSetMarginEndMethodInfo
    ResolveViewMethod "setMarginStart" o = Gtk.Widget.WidgetSetMarginStartMethodInfo
    ResolveViewMethod "setMarginTop" o = Gtk.Widget.WidgetSetMarginTopMethodInfo
    ResolveViewMethod "setMarkAttributes" o = ViewSetMarkAttributesMethodInfo
    ResolveViewMethod "setMonospace" o = Gtk.TextView.TextViewSetMonospaceMethodInfo
    ResolveViewMethod "setName" o = Gtk.Widget.WidgetSetNameMethodInfo
    ResolveViewMethod "setOpacity" o = Gtk.Widget.WidgetSetOpacityMethodInfo
    ResolveViewMethod "setOverflow" o = Gtk.Widget.WidgetSetOverflowMethodInfo
    ResolveViewMethod "setOverwrite" o = Gtk.TextView.TextViewSetOverwriteMethodInfo
    ResolveViewMethod "setParent" o = Gtk.Widget.WidgetSetParentMethodInfo
    ResolveViewMethod "setPixelsAboveLines" o = Gtk.TextView.TextViewSetPixelsAboveLinesMethodInfo
    ResolveViewMethod "setPixelsBelowLines" o = Gtk.TextView.TextViewSetPixelsBelowLinesMethodInfo
    ResolveViewMethod "setPixelsInsideWrap" o = Gtk.TextView.TextViewSetPixelsInsideWrapMethodInfo
    ResolveViewMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveViewMethod "setReceivesDefault" o = Gtk.Widget.WidgetSetReceivesDefaultMethodInfo
    ResolveViewMethod "setRightMargin" o = Gtk.TextView.TextViewSetRightMarginMethodInfo
    ResolveViewMethod "setRightMarginPosition" o = ViewSetRightMarginPositionMethodInfo
    ResolveViewMethod "setSensitive" o = Gtk.Widget.WidgetSetSensitiveMethodInfo
    ResolveViewMethod "setShowLineMarks" o = ViewSetShowLineMarksMethodInfo
    ResolveViewMethod "setShowLineNumbers" o = ViewSetShowLineNumbersMethodInfo
    ResolveViewMethod "setShowRightMargin" o = ViewSetShowRightMarginMethodInfo
    ResolveViewMethod "setSizeRequest" o = Gtk.Widget.WidgetSetSizeRequestMethodInfo
    ResolveViewMethod "setSmartBackspace" o = ViewSetSmartBackspaceMethodInfo
    ResolveViewMethod "setSmartHomeEnd" o = ViewSetSmartHomeEndMethodInfo
    ResolveViewMethod "setStateFlags" o = Gtk.Widget.WidgetSetStateFlagsMethodInfo
    ResolveViewMethod "setTabWidth" o = ViewSetTabWidthMethodInfo
    ResolveViewMethod "setTabs" o = Gtk.TextView.TextViewSetTabsMethodInfo
    ResolveViewMethod "setTooltipMarkup" o = Gtk.Widget.WidgetSetTooltipMarkupMethodInfo
    ResolveViewMethod "setTooltipText" o = Gtk.Widget.WidgetSetTooltipTextMethodInfo
    ResolveViewMethod "setTopMargin" o = Gtk.TextView.TextViewSetTopMarginMethodInfo
    ResolveViewMethod "setVadjustment" o = Gtk.Scrollable.ScrollableSetVadjustmentMethodInfo
    ResolveViewMethod "setValign" o = Gtk.Widget.WidgetSetValignMethodInfo
    ResolveViewMethod "setVexpand" o = Gtk.Widget.WidgetSetVexpandMethodInfo
    ResolveViewMethod "setVexpandSet" o = Gtk.Widget.WidgetSetVexpandSetMethodInfo
    ResolveViewMethod "setVisible" o = Gtk.Widget.WidgetSetVisibleMethodInfo
    ResolveViewMethod "setVscrollPolicy" o = Gtk.Scrollable.ScrollableSetVscrollPolicyMethodInfo
    ResolveViewMethod "setWrapMode" o = Gtk.TextView.TextViewSetWrapModeMethodInfo
    ResolveViewMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveViewMethod t View, O.OverloadedMethod info View p) => OL.IsLabel t (View -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveViewMethod t View, O.OverloadedMethod info View p, R.HasField t View p) => R.HasField t View p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveViewMethod t View, O.OverloadedMethodInfo info View) => OL.IsLabel t (O.MethodProxy info View) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal View::change-case
-- | Keybinding signal to change case of the text at the current cursor position.
type ViewChangeCaseCallback =
    GtkSource.Enums.ChangeCaseType
    -- ^ /@caseType@/: the case to use
    -> IO ()

type C_ViewChangeCaseCallback =
    Ptr View ->                             -- object
    CUInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewChangeCaseCallback`.
foreign import ccall "wrapper"
    mk_ViewChangeCaseCallback :: C_ViewChangeCaseCallback -> IO (FunPtr C_ViewChangeCaseCallback)

wrap_ViewChangeCaseCallback :: 
    GObject a => (a -> ViewChangeCaseCallback) ->
    C_ViewChangeCaseCallback
wrap_ViewChangeCaseCallback :: forall a.
GObject a =>
(a -> ViewChangeCaseCallback) -> C_ViewChangeCaseCallback
wrap_ViewChangeCaseCallback a -> ViewChangeCaseCallback
gi'cb Ptr View
gi'selfPtr CUInt
caseType Ptr ()
_ = do
    let caseType' :: ChangeCaseType
caseType' = (Int -> ChangeCaseType
forall a. Enum a => Int -> a
toEnum (Int -> ChangeCaseType)
-> (CUInt -> Int) -> CUInt -> ChangeCaseType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
caseType
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewChangeCaseCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  ChangeCaseType
caseType'


-- | Connect a signal handler for the [changeCase](#signal:changeCase) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #changeCase callback
-- @
-- 
-- 
onViewChangeCase :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewChangeCaseCallback) -> m SignalHandlerId
onViewChangeCase :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewChangeCaseCallback) -> m SignalHandlerId
onViewChangeCase a
obj (?self::a) => ViewChangeCaseCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewChangeCaseCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewChangeCaseCallback
ViewChangeCaseCallback
cb
    let wrapped' :: C_ViewChangeCaseCallback
wrapped' = (a -> ViewChangeCaseCallback) -> C_ViewChangeCaseCallback
forall a.
GObject a =>
(a -> ViewChangeCaseCallback) -> C_ViewChangeCaseCallback
wrap_ViewChangeCaseCallback a -> ViewChangeCaseCallback
wrapped
    FunPtr C_ViewChangeCaseCallback
wrapped'' <- C_ViewChangeCaseCallback -> IO (FunPtr C_ViewChangeCaseCallback)
mk_ViewChangeCaseCallback C_ViewChangeCaseCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewChangeCaseCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"change-case" FunPtr C_ViewChangeCaseCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [changeCase](#signal:changeCase) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #changeCase callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewChangeCase :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewChangeCaseCallback) -> m SignalHandlerId
afterViewChangeCase :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewChangeCaseCallback) -> m SignalHandlerId
afterViewChangeCase a
obj (?self::a) => ViewChangeCaseCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewChangeCaseCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewChangeCaseCallback
ViewChangeCaseCallback
cb
    let wrapped' :: C_ViewChangeCaseCallback
wrapped' = (a -> ViewChangeCaseCallback) -> C_ViewChangeCaseCallback
forall a.
GObject a =>
(a -> ViewChangeCaseCallback) -> C_ViewChangeCaseCallback
wrap_ViewChangeCaseCallback a -> ViewChangeCaseCallback
wrapped
    FunPtr C_ViewChangeCaseCallback
wrapped'' <- C_ViewChangeCaseCallback -> IO (FunPtr C_ViewChangeCaseCallback)
mk_ViewChangeCaseCallback C_ViewChangeCaseCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewChangeCaseCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"change-case" FunPtr C_ViewChangeCaseCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewChangeCaseSignalInfo
instance SignalInfo ViewChangeCaseSignalInfo where
    type HaskellCallbackType ViewChangeCaseSignalInfo = ViewChangeCaseCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewChangeCaseCallback cb
        cb'' <- mk_ViewChangeCaseCallback cb'
        connectSignalFunPtr obj "change-case" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::change-case"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:changeCase"})

#endif

-- signal View::change-number
-- | Keybinding signal to edit a number at the current cursor position.
type ViewChangeNumberCallback =
    Int32
    -- ^ /@count@/: the number to add to the number at the current position
    -> IO ()

type C_ViewChangeNumberCallback =
    Ptr View ->                             -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewChangeNumberCallback`.
foreign import ccall "wrapper"
    mk_ViewChangeNumberCallback :: C_ViewChangeNumberCallback -> IO (FunPtr C_ViewChangeNumberCallback)

wrap_ViewChangeNumberCallback :: 
    GObject a => (a -> ViewChangeNumberCallback) ->
    C_ViewChangeNumberCallback
wrap_ViewChangeNumberCallback :: forall a.
GObject a =>
(a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
wrap_ViewChangeNumberCallback a -> ViewChangeNumberCallback
gi'cb Ptr View
gi'selfPtr Int32
count Ptr ()
_ = do
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewChangeNumberCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  Int32
count


-- | Connect a signal handler for the [changeNumber](#signal:changeNumber) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #changeNumber callback
-- @
-- 
-- 
onViewChangeNumber :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewChangeNumberCallback) -> m SignalHandlerId
onViewChangeNumber :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewChangeNumberCallback) -> m SignalHandlerId
onViewChangeNumber a
obj (?self::a) => ViewChangeNumberCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewChangeNumberCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewChangeNumberCallback
ViewChangeNumberCallback
cb
    let wrapped' :: C_ViewChangeNumberCallback
wrapped' = (a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
forall a.
GObject a =>
(a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
wrap_ViewChangeNumberCallback a -> ViewChangeNumberCallback
wrapped
    FunPtr C_ViewChangeNumberCallback
wrapped'' <- C_ViewChangeNumberCallback
-> IO (FunPtr C_ViewChangeNumberCallback)
mk_ViewChangeNumberCallback C_ViewChangeNumberCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewChangeNumberCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"change-number" FunPtr C_ViewChangeNumberCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [changeNumber](#signal:changeNumber) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #changeNumber callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewChangeNumber :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewChangeNumberCallback) -> m SignalHandlerId
afterViewChangeNumber :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewChangeNumberCallback) -> m SignalHandlerId
afterViewChangeNumber a
obj (?self::a) => ViewChangeNumberCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewChangeNumberCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewChangeNumberCallback
ViewChangeNumberCallback
cb
    let wrapped' :: C_ViewChangeNumberCallback
wrapped' = (a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
forall a.
GObject a =>
(a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
wrap_ViewChangeNumberCallback a -> ViewChangeNumberCallback
wrapped
    FunPtr C_ViewChangeNumberCallback
wrapped'' <- C_ViewChangeNumberCallback
-> IO (FunPtr C_ViewChangeNumberCallback)
mk_ViewChangeNumberCallback C_ViewChangeNumberCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewChangeNumberCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"change-number" FunPtr C_ViewChangeNumberCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewChangeNumberSignalInfo
instance SignalInfo ViewChangeNumberSignalInfo where
    type HaskellCallbackType ViewChangeNumberSignalInfo = ViewChangeNumberCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewChangeNumberCallback cb
        cb'' <- mk_ViewChangeNumberCallback cb'
        connectSignalFunPtr obj "change-number" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::change-number"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:changeNumber"})

#endif

-- signal View::join-lines
-- | Keybinding signal to join the lines currently selected.
type ViewJoinLinesCallback =
    IO ()

type C_ViewJoinLinesCallback =
    Ptr View ->                             -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewJoinLinesCallback`.
foreign import ccall "wrapper"
    mk_ViewJoinLinesCallback :: C_ViewJoinLinesCallback -> IO (FunPtr C_ViewJoinLinesCallback)

wrap_ViewJoinLinesCallback :: 
    GObject a => (a -> ViewJoinLinesCallback) ->
    C_ViewJoinLinesCallback
wrap_ViewJoinLinesCallback :: forall a. GObject a => (a -> IO ()) -> C_ViewJoinLinesCallback
wrap_ViewJoinLinesCallback a -> IO ()
gi'cb Ptr View
gi'selfPtr Ptr ()
_ = do
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> IO ()
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self) 


-- | Connect a signal handler for the [joinLines](#signal:joinLines) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #joinLines callback
-- @
-- 
-- 
onViewJoinLines :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewJoinLinesCallback) -> m SignalHandlerId
onViewJoinLines :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onViewJoinLines a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ViewJoinLinesCallback
wrapped' = (a -> IO ()) -> C_ViewJoinLinesCallback
forall a. GObject a => (a -> IO ()) -> C_ViewJoinLinesCallback
wrap_ViewJoinLinesCallback a -> IO ()
wrapped
    FunPtr C_ViewJoinLinesCallback
wrapped'' <- C_ViewJoinLinesCallback -> IO (FunPtr C_ViewJoinLinesCallback)
mk_ViewJoinLinesCallback C_ViewJoinLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewJoinLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"join-lines" FunPtr C_ViewJoinLinesCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [joinLines](#signal:joinLines) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #joinLines callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewJoinLines :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewJoinLinesCallback) -> m SignalHandlerId
afterViewJoinLines :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterViewJoinLines a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ViewJoinLinesCallback
wrapped' = (a -> IO ()) -> C_ViewJoinLinesCallback
forall a. GObject a => (a -> IO ()) -> C_ViewJoinLinesCallback
wrap_ViewJoinLinesCallback a -> IO ()
wrapped
    FunPtr C_ViewJoinLinesCallback
wrapped'' <- C_ViewJoinLinesCallback -> IO (FunPtr C_ViewJoinLinesCallback)
mk_ViewJoinLinesCallback C_ViewJoinLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewJoinLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"join-lines" FunPtr C_ViewJoinLinesCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewJoinLinesSignalInfo
instance SignalInfo ViewJoinLinesSignalInfo where
    type HaskellCallbackType ViewJoinLinesSignalInfo = ViewJoinLinesCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewJoinLinesCallback cb
        cb'' <- mk_ViewJoinLinesCallback cb'
        connectSignalFunPtr obj "join-lines" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::join-lines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:joinLines"})

#endif

-- signal View::line-mark-activated
-- | Emitted when a line mark has been activated (for instance when there
-- was a button press in the line marks gutter).
-- 
-- You can use /@iter@/ to determine on which line the activation took place.
type ViewLineMarkActivatedCallback =
    Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Word32
    -- ^ /@button@/: the button that was pressed
    -> [Gdk.Flags.ModifierType]
    -- ^ /@state@/: the modifier state, if any
    -> Int32
    -- ^ /@nPresses@/: the number of presses
    -> IO ()

type C_ViewLineMarkActivatedCallback =
    Ptr View ->                             -- object
    Ptr Gtk.TextIter.TextIter ->
    Word32 ->
    CUInt ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewLineMarkActivatedCallback`.
foreign import ccall "wrapper"
    mk_ViewLineMarkActivatedCallback :: C_ViewLineMarkActivatedCallback -> IO (FunPtr C_ViewLineMarkActivatedCallback)

wrap_ViewLineMarkActivatedCallback :: 
    GObject a => (a -> ViewLineMarkActivatedCallback) ->
    C_ViewLineMarkActivatedCallback
wrap_ViewLineMarkActivatedCallback :: forall a.
GObject a =>
(a -> ViewLineMarkActivatedCallback)
-> C_ViewLineMarkActivatedCallback
wrap_ViewLineMarkActivatedCallback a -> ViewLineMarkActivatedCallback
gi'cb Ptr View
gi'selfPtr Ptr TextIter
iter Word32
button CUInt
state Int32
nPresses Ptr ()
_ = do
    Ptr TextIter -> (TextIter -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr TextIter
iter ((TextIter -> IO ()) -> IO ()) -> (TextIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        let state' :: [ModifierType]
state' = CUInt -> [ModifierType]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
state
        Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewLineMarkActivatedCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  TextIter
iter' Word32
button [ModifierType]
state' Int32
nPresses


-- | Connect a signal handler for the [lineMarkActivated](#signal:lineMarkActivated) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #lineMarkActivated callback
-- @
-- 
-- 
onViewLineMarkActivated :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewLineMarkActivatedCallback) -> m SignalHandlerId
onViewLineMarkActivated :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a
-> ((?self::a) => ViewLineMarkActivatedCallback)
-> m SignalHandlerId
onViewLineMarkActivated a
obj (?self::a) => ViewLineMarkActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewLineMarkActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewLineMarkActivatedCallback
ViewLineMarkActivatedCallback
cb
    let wrapped' :: C_ViewLineMarkActivatedCallback
wrapped' = (a -> ViewLineMarkActivatedCallback)
-> C_ViewLineMarkActivatedCallback
forall a.
GObject a =>
(a -> ViewLineMarkActivatedCallback)
-> C_ViewLineMarkActivatedCallback
wrap_ViewLineMarkActivatedCallback a -> ViewLineMarkActivatedCallback
wrapped
    FunPtr C_ViewLineMarkActivatedCallback
wrapped'' <- C_ViewLineMarkActivatedCallback
-> IO (FunPtr C_ViewLineMarkActivatedCallback)
mk_ViewLineMarkActivatedCallback C_ViewLineMarkActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewLineMarkActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"line-mark-activated" FunPtr C_ViewLineMarkActivatedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [lineMarkActivated](#signal:lineMarkActivated) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #lineMarkActivated callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewLineMarkActivated :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewLineMarkActivatedCallback) -> m SignalHandlerId
afterViewLineMarkActivated :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a
-> ((?self::a) => ViewLineMarkActivatedCallback)
-> m SignalHandlerId
afterViewLineMarkActivated a
obj (?self::a) => ViewLineMarkActivatedCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewLineMarkActivatedCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewLineMarkActivatedCallback
ViewLineMarkActivatedCallback
cb
    let wrapped' :: C_ViewLineMarkActivatedCallback
wrapped' = (a -> ViewLineMarkActivatedCallback)
-> C_ViewLineMarkActivatedCallback
forall a.
GObject a =>
(a -> ViewLineMarkActivatedCallback)
-> C_ViewLineMarkActivatedCallback
wrap_ViewLineMarkActivatedCallback a -> ViewLineMarkActivatedCallback
wrapped
    FunPtr C_ViewLineMarkActivatedCallback
wrapped'' <- C_ViewLineMarkActivatedCallback
-> IO (FunPtr C_ViewLineMarkActivatedCallback)
mk_ViewLineMarkActivatedCallback C_ViewLineMarkActivatedCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewLineMarkActivatedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"line-mark-activated" FunPtr C_ViewLineMarkActivatedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewLineMarkActivatedSignalInfo
instance SignalInfo ViewLineMarkActivatedSignalInfo where
    type HaskellCallbackType ViewLineMarkActivatedSignalInfo = ViewLineMarkActivatedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewLineMarkActivatedCallback cb
        cb'' <- mk_ViewLineMarkActivatedCallback cb'
        connectSignalFunPtr obj "line-mark-activated" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::line-mark-activated"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:lineMarkActivated"})

#endif

-- signal View::move-lines
-- | The signal is a keybinding which gets emitted when the user initiates moving a line.
-- 
-- The default binding key is Alt+Up\/Down arrow. And moves the currently selected lines,
-- or the current line up or down by one line.
type ViewMoveLinesCallback =
    Bool
    -- ^ /@down@/: 'P.True' to move down, 'P.False' to move up.
    -> IO ()

type C_ViewMoveLinesCallback =
    Ptr View ->                             -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewMoveLinesCallback`.
foreign import ccall "wrapper"
    mk_ViewMoveLinesCallback :: C_ViewMoveLinesCallback -> IO (FunPtr C_ViewMoveLinesCallback)

wrap_ViewMoveLinesCallback :: 
    GObject a => (a -> ViewMoveLinesCallback) ->
    C_ViewMoveLinesCallback
wrap_ViewMoveLinesCallback :: forall a.
GObject a =>
(a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
wrap_ViewMoveLinesCallback a -> ViewMoveLinesCallback
gi'cb Ptr View
gi'selfPtr CInt
down Ptr ()
_ = do
    let down' :: Bool
down' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
down
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewMoveLinesCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  Bool
down'


-- | Connect a signal handler for the [moveLines](#signal:moveLines) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #moveLines callback
-- @
-- 
-- 
onViewMoveLines :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewMoveLinesCallback) -> m SignalHandlerId
onViewMoveLines :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewMoveLinesCallback) -> m SignalHandlerId
onViewMoveLines a
obj (?self::a) => ViewMoveLinesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewMoveLinesCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewMoveLinesCallback
ViewMoveLinesCallback
cb
    let wrapped' :: C_ViewMoveLinesCallback
wrapped' = (a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
forall a.
GObject a =>
(a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
wrap_ViewMoveLinesCallback a -> ViewMoveLinesCallback
wrapped
    FunPtr C_ViewMoveLinesCallback
wrapped'' <- C_ViewMoveLinesCallback -> IO (FunPtr C_ViewMoveLinesCallback)
mk_ViewMoveLinesCallback C_ViewMoveLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewMoveLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-lines" FunPtr C_ViewMoveLinesCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [moveLines](#signal:moveLines) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #moveLines callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewMoveLines :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewMoveLinesCallback) -> m SignalHandlerId
afterViewMoveLines :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewMoveLinesCallback) -> m SignalHandlerId
afterViewMoveLines a
obj (?self::a) => ViewMoveLinesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewMoveLinesCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewMoveLinesCallback
ViewMoveLinesCallback
cb
    let wrapped' :: C_ViewMoveLinesCallback
wrapped' = (a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
forall a.
GObject a =>
(a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
wrap_ViewMoveLinesCallback a -> ViewMoveLinesCallback
wrapped
    FunPtr C_ViewMoveLinesCallback
wrapped'' <- C_ViewMoveLinesCallback -> IO (FunPtr C_ViewMoveLinesCallback)
mk_ViewMoveLinesCallback C_ViewMoveLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewMoveLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-lines" FunPtr C_ViewMoveLinesCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewMoveLinesSignalInfo
instance SignalInfo ViewMoveLinesSignalInfo where
    type HaskellCallbackType ViewMoveLinesSignalInfo = ViewMoveLinesCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewMoveLinesCallback cb
        cb'' <- mk_ViewMoveLinesCallback cb'
        connectSignalFunPtr obj "move-lines" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::move-lines"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:moveLines"})

#endif

-- signal View::move-to-matching-bracket
-- | Keybinding signal to move the cursor to the matching bracket.
type ViewMoveToMatchingBracketCallback =
    Bool
    -- ^ /@extendSelection@/: 'P.True' if the move should extend the selection
    -> IO ()

type C_ViewMoveToMatchingBracketCallback =
    Ptr View ->                             -- object
    CInt ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewMoveToMatchingBracketCallback`.
foreign import ccall "wrapper"
    mk_ViewMoveToMatchingBracketCallback :: C_ViewMoveToMatchingBracketCallback -> IO (FunPtr C_ViewMoveToMatchingBracketCallback)

wrap_ViewMoveToMatchingBracketCallback :: 
    GObject a => (a -> ViewMoveToMatchingBracketCallback) ->
    C_ViewMoveToMatchingBracketCallback
wrap_ViewMoveToMatchingBracketCallback :: forall a.
GObject a =>
(a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
wrap_ViewMoveToMatchingBracketCallback a -> ViewMoveLinesCallback
gi'cb Ptr View
gi'selfPtr CInt
extendSelection Ptr ()
_ = do
    let extendSelection' :: Bool
extendSelection' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
extendSelection
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewMoveLinesCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  Bool
extendSelection'


-- | Connect a signal handler for the [moveToMatchingBracket](#signal:moveToMatchingBracket) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #moveToMatchingBracket callback
-- @
-- 
-- 
onViewMoveToMatchingBracket :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewMoveToMatchingBracketCallback) -> m SignalHandlerId
onViewMoveToMatchingBracket :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewMoveLinesCallback) -> m SignalHandlerId
onViewMoveToMatchingBracket a
obj (?self::a) => ViewMoveLinesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewMoveLinesCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewMoveLinesCallback
ViewMoveLinesCallback
cb
    let wrapped' :: C_ViewMoveLinesCallback
wrapped' = (a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
forall a.
GObject a =>
(a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
wrap_ViewMoveToMatchingBracketCallback a -> ViewMoveLinesCallback
wrapped
    FunPtr C_ViewMoveLinesCallback
wrapped'' <- C_ViewMoveLinesCallback -> IO (FunPtr C_ViewMoveLinesCallback)
mk_ViewMoveToMatchingBracketCallback C_ViewMoveLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewMoveLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-to-matching-bracket" FunPtr C_ViewMoveLinesCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [moveToMatchingBracket](#signal:moveToMatchingBracket) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #moveToMatchingBracket callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewMoveToMatchingBracket :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewMoveToMatchingBracketCallback) -> m SignalHandlerId
afterViewMoveToMatchingBracket :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewMoveLinesCallback) -> m SignalHandlerId
afterViewMoveToMatchingBracket a
obj (?self::a) => ViewMoveLinesCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewMoveLinesCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewMoveLinesCallback
ViewMoveLinesCallback
cb
    let wrapped' :: C_ViewMoveLinesCallback
wrapped' = (a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
forall a.
GObject a =>
(a -> ViewMoveLinesCallback) -> C_ViewMoveLinesCallback
wrap_ViewMoveToMatchingBracketCallback a -> ViewMoveLinesCallback
wrapped
    FunPtr C_ViewMoveLinesCallback
wrapped'' <- C_ViewMoveLinesCallback -> IO (FunPtr C_ViewMoveLinesCallback)
mk_ViewMoveToMatchingBracketCallback C_ViewMoveLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewMoveLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-to-matching-bracket" FunPtr C_ViewMoveLinesCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewMoveToMatchingBracketSignalInfo
instance SignalInfo ViewMoveToMatchingBracketSignalInfo where
    type HaskellCallbackType ViewMoveToMatchingBracketSignalInfo = ViewMoveToMatchingBracketCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewMoveToMatchingBracketCallback cb
        cb'' <- mk_ViewMoveToMatchingBracketCallback cb'
        connectSignalFunPtr obj "move-to-matching-bracket" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::move-to-matching-bracket"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:moveToMatchingBracket"})

#endif

-- signal View::move-words
-- | The signal is a keybinding which gets emitted when the user initiates moving a word.
-- 
-- The default binding key is Alt+Left\/Right Arrow and moves the current selection, or the current
-- word by one word.
type ViewMoveWordsCallback =
    Int32
    -- ^ /@count@/: the number of words to move over
    -> IO ()

type C_ViewMoveWordsCallback =
    Ptr View ->                             -- object
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewMoveWordsCallback`.
foreign import ccall "wrapper"
    mk_ViewMoveWordsCallback :: C_ViewMoveWordsCallback -> IO (FunPtr C_ViewMoveWordsCallback)

wrap_ViewMoveWordsCallback :: 
    GObject a => (a -> ViewMoveWordsCallback) ->
    C_ViewMoveWordsCallback
wrap_ViewMoveWordsCallback :: forall a.
GObject a =>
(a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
wrap_ViewMoveWordsCallback a -> ViewChangeNumberCallback
gi'cb Ptr View
gi'selfPtr Int32
count Ptr ()
_ = do
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewChangeNumberCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  Int32
count


-- | Connect a signal handler for the [moveWords](#signal:moveWords) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #moveWords callback
-- @
-- 
-- 
onViewMoveWords :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewMoveWordsCallback) -> m SignalHandlerId
onViewMoveWords :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewChangeNumberCallback) -> m SignalHandlerId
onViewMoveWords a
obj (?self::a) => ViewChangeNumberCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewChangeNumberCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewChangeNumberCallback
ViewChangeNumberCallback
cb
    let wrapped' :: C_ViewChangeNumberCallback
wrapped' = (a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
forall a.
GObject a =>
(a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
wrap_ViewMoveWordsCallback a -> ViewChangeNumberCallback
wrapped
    FunPtr C_ViewChangeNumberCallback
wrapped'' <- C_ViewChangeNumberCallback
-> IO (FunPtr C_ViewChangeNumberCallback)
mk_ViewMoveWordsCallback C_ViewChangeNumberCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewChangeNumberCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-words" FunPtr C_ViewChangeNumberCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [moveWords](#signal:moveWords) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #moveWords callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewMoveWords :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewMoveWordsCallback) -> m SignalHandlerId
afterViewMoveWords :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewChangeNumberCallback) -> m SignalHandlerId
afterViewMoveWords a
obj (?self::a) => ViewChangeNumberCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewChangeNumberCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewChangeNumberCallback
ViewChangeNumberCallback
cb
    let wrapped' :: C_ViewChangeNumberCallback
wrapped' = (a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
forall a.
GObject a =>
(a -> ViewChangeNumberCallback) -> C_ViewChangeNumberCallback
wrap_ViewMoveWordsCallback a -> ViewChangeNumberCallback
wrapped
    FunPtr C_ViewChangeNumberCallback
wrapped'' <- C_ViewChangeNumberCallback
-> IO (FunPtr C_ViewChangeNumberCallback)
mk_ViewMoveWordsCallback C_ViewChangeNumberCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewChangeNumberCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"move-words" FunPtr C_ViewChangeNumberCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewMoveWordsSignalInfo
instance SignalInfo ViewMoveWordsSignalInfo where
    type HaskellCallbackType ViewMoveWordsSignalInfo = ViewMoveWordsCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewMoveWordsCallback cb
        cb'' <- mk_ViewMoveWordsCallback cb'
        connectSignalFunPtr obj "move-words" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::move-words"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:moveWords"})

#endif

-- signal View::push-snippet
-- | The signal is emitted to insert a new snippet into the view.
-- 
-- If another snippet was active, it will be paused until all focus positions of /@snippet@/ have been exhausted.
-- 
-- /@location@/ will be updated to point at the end of the snippet.
type ViewPushSnippetCallback =
    GtkSource.Snippet.Snippet
    -- ^ /@snippet@/: a t'GI.GtkSource.Objects.Snippet.Snippet'
    -> Gtk.TextIter.TextIter
    -- ^ /@location@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> IO (Gtk.TextIter.TextIter)

type C_ViewPushSnippetCallback =
    Ptr View ->                             -- object
    Ptr GtkSource.Snippet.Snippet ->
    Ptr (Ptr Gtk.TextIter.TextIter) ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewPushSnippetCallback`.
foreign import ccall "wrapper"
    mk_ViewPushSnippetCallback :: C_ViewPushSnippetCallback -> IO (FunPtr C_ViewPushSnippetCallback)

wrap_ViewPushSnippetCallback :: 
    GObject a => (a -> ViewPushSnippetCallback) ->
    C_ViewPushSnippetCallback
wrap_ViewPushSnippetCallback :: forall a.
GObject a =>
(a -> ViewPushSnippetCallback) -> C_ViewPushSnippetCallback
wrap_ViewPushSnippetCallback a -> ViewPushSnippetCallback
gi'cb Ptr View
gi'selfPtr Ptr Snippet
snippet Ptr (Ptr TextIter)
location Ptr ()
_ = do
    Snippet
snippet' <- ((ManagedPtr Snippet -> Snippet) -> Ptr Snippet -> IO Snippet
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Snippet -> Snippet
GtkSource.Snippet.Snippet) Ptr Snippet
snippet
    Ptr TextIter
location' <- Ptr (Ptr TextIter) -> IO (Ptr TextIter)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr TextIter)
location
    TextIter
location'' <- ((ManagedPtr TextIter -> TextIter) -> Ptr TextIter -> IO TextIter
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr TextIter -> TextIter
Gtk.TextIter.TextIter) Ptr TextIter
location'
    TextIter
outlocation <- Ptr View -> (View -> IO TextIter) -> IO TextIter
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO TextIter) -> IO TextIter)
-> (View -> IO TextIter) -> IO TextIter
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewPushSnippetCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  Snippet
snippet' TextIter
location''
    Ptr TextIter
outlocation' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed TextIter
outlocation
    Ptr (Ptr TextIter) -> Ptr TextIter -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (Ptr TextIter)
location Ptr TextIter
outlocation'


-- | Connect a signal handler for the [pushSnippet](#signal:pushSnippet) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #pushSnippet callback
-- @
-- 
-- 
onViewPushSnippet :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewPushSnippetCallback) -> m SignalHandlerId
onViewPushSnippet :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewPushSnippetCallback) -> m SignalHandlerId
onViewPushSnippet a
obj (?self::a) => ViewPushSnippetCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewPushSnippetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewPushSnippetCallback
ViewPushSnippetCallback
cb
    let wrapped' :: C_ViewPushSnippetCallback
wrapped' = (a -> ViewPushSnippetCallback) -> C_ViewPushSnippetCallback
forall a.
GObject a =>
(a -> ViewPushSnippetCallback) -> C_ViewPushSnippetCallback
wrap_ViewPushSnippetCallback a -> ViewPushSnippetCallback
wrapped
    FunPtr C_ViewPushSnippetCallback
wrapped'' <- C_ViewPushSnippetCallback -> IO (FunPtr C_ViewPushSnippetCallback)
mk_ViewPushSnippetCallback C_ViewPushSnippetCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewPushSnippetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"push-snippet" FunPtr C_ViewPushSnippetCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [pushSnippet](#signal:pushSnippet) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #pushSnippet callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewPushSnippet :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewPushSnippetCallback) -> m SignalHandlerId
afterViewPushSnippet :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewPushSnippetCallback) -> m SignalHandlerId
afterViewPushSnippet a
obj (?self::a) => ViewPushSnippetCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewPushSnippetCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewPushSnippetCallback
ViewPushSnippetCallback
cb
    let wrapped' :: C_ViewPushSnippetCallback
wrapped' = (a -> ViewPushSnippetCallback) -> C_ViewPushSnippetCallback
forall a.
GObject a =>
(a -> ViewPushSnippetCallback) -> C_ViewPushSnippetCallback
wrap_ViewPushSnippetCallback a -> ViewPushSnippetCallback
wrapped
    FunPtr C_ViewPushSnippetCallback
wrapped'' <- C_ViewPushSnippetCallback -> IO (FunPtr C_ViewPushSnippetCallback)
mk_ViewPushSnippetCallback C_ViewPushSnippetCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewPushSnippetCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"push-snippet" FunPtr C_ViewPushSnippetCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewPushSnippetSignalInfo
instance SignalInfo ViewPushSnippetSignalInfo where
    type HaskellCallbackType ViewPushSnippetSignalInfo = ViewPushSnippetCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewPushSnippetCallback cb
        cb'' <- mk_ViewPushSnippetCallback cb'
        connectSignalFunPtr obj "push-snippet" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::push-snippet"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:pushSnippet"})

#endif

-- signal View::show-completion
-- | The signal is a key binding signal which gets
-- emitted when the user requests a completion, by pressing
-- \<keycombo>\<keycap>Control\<\/keycap>\<keycap>space\<\/keycap>\<\/keycombo>.
-- 
-- This will create a [class/@completionContext@/] with the activation
-- type as 'GI.GtkSource.Enums.CompletionActivationUserRequested'.
-- 
-- Applications should not connect to it, but may emit it with
-- @/GObject.signal_emit_by_name/@ if they need to activate the completion by
-- another means, for example with another key binding or a menu entry.
type ViewShowCompletionCallback =
    IO ()

type C_ViewShowCompletionCallback =
    Ptr View ->                             -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewShowCompletionCallback`.
foreign import ccall "wrapper"
    mk_ViewShowCompletionCallback :: C_ViewShowCompletionCallback -> IO (FunPtr C_ViewShowCompletionCallback)

wrap_ViewShowCompletionCallback :: 
    GObject a => (a -> ViewShowCompletionCallback) ->
    C_ViewShowCompletionCallback
wrap_ViewShowCompletionCallback :: forall a. GObject a => (a -> IO ()) -> C_ViewJoinLinesCallback
wrap_ViewShowCompletionCallback a -> IO ()
gi'cb Ptr View
gi'selfPtr Ptr ()
_ = do
    Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> IO ()
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self) 


-- | Connect a signal handler for the [showCompletion](#signal:showCompletion) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #showCompletion callback
-- @
-- 
-- 
onViewShowCompletion :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewShowCompletionCallback) -> m SignalHandlerId
onViewShowCompletion :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onViewShowCompletion a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ViewJoinLinesCallback
wrapped' = (a -> IO ()) -> C_ViewJoinLinesCallback
forall a. GObject a => (a -> IO ()) -> C_ViewJoinLinesCallback
wrap_ViewShowCompletionCallback a -> IO ()
wrapped
    FunPtr C_ViewJoinLinesCallback
wrapped'' <- C_ViewJoinLinesCallback -> IO (FunPtr C_ViewJoinLinesCallback)
mk_ViewShowCompletionCallback C_ViewJoinLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewJoinLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-completion" FunPtr C_ViewJoinLinesCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [showCompletion](#signal:showCompletion) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #showCompletion callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewShowCompletion :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewShowCompletionCallback) -> m SignalHandlerId
afterViewShowCompletion :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterViewShowCompletion a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ViewJoinLinesCallback
wrapped' = (a -> IO ()) -> C_ViewJoinLinesCallback
forall a. GObject a => (a -> IO ()) -> C_ViewJoinLinesCallback
wrap_ViewShowCompletionCallback a -> IO ()
wrapped
    FunPtr C_ViewJoinLinesCallback
wrapped'' <- C_ViewJoinLinesCallback -> IO (FunPtr C_ViewJoinLinesCallback)
mk_ViewShowCompletionCallback C_ViewJoinLinesCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewJoinLinesCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"show-completion" FunPtr C_ViewJoinLinesCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewShowCompletionSignalInfo
instance SignalInfo ViewShowCompletionSignalInfo where
    type HaskellCallbackType ViewShowCompletionSignalInfo = ViewShowCompletionCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewShowCompletionCallback cb
        cb'' <- mk_ViewShowCompletionCallback cb'
        connectSignalFunPtr obj "show-completion" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::show-completion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:showCompletion"})

#endif

-- signal View::smart-home-end
-- | Emitted when a the cursor was moved according to the smart home end setting.
-- 
-- The signal is emitted after the cursor is moved, but
-- during the [TextView::moveCursor]("GI.Gtk.Objects.TextView#g:signal:moveCursor") action. This can be used to find
-- out whether the cursor was moved by a normal home\/end or by a smart
-- home\/end.
type ViewSmartHomeEndCallback =
    Gtk.TextIter.TextIter
    -- ^ /@iter@/: a t'GI.Gtk.Structs.TextIter.TextIter'
    -> Int32
    -- ^ /@count@/: the count
    -> IO ()

type C_ViewSmartHomeEndCallback =
    Ptr View ->                             -- object
    Ptr Gtk.TextIter.TextIter ->
    Int32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ViewSmartHomeEndCallback`.
foreign import ccall "wrapper"
    mk_ViewSmartHomeEndCallback :: C_ViewSmartHomeEndCallback -> IO (FunPtr C_ViewSmartHomeEndCallback)

wrap_ViewSmartHomeEndCallback :: 
    GObject a => (a -> ViewSmartHomeEndCallback) ->
    C_ViewSmartHomeEndCallback
wrap_ViewSmartHomeEndCallback :: forall a.
GObject a =>
(a -> ViewSmartHomeEndCallback) -> C_ViewSmartHomeEndCallback
wrap_ViewSmartHomeEndCallback a -> ViewSmartHomeEndCallback
gi'cb Ptr View
gi'selfPtr Ptr TextIter
iter Int32
count Ptr ()
_ = do
    Ptr TextIter -> (TextIter -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr TextIter
iter ((TextIter -> IO ()) -> IO ()) -> (TextIter -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \TextIter
iter' -> do
        Ptr View -> (View -> IO ()) -> IO ()
forall o b.
(HasCallStack, GObject o) =>
Ptr o -> (o -> IO b) -> IO b
B.ManagedPtr.withNewObject Ptr View
gi'selfPtr ((View -> IO ()) -> IO ()) -> (View -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \View
gi'self -> a -> ViewSmartHomeEndCallback
gi'cb (View -> a
forall a b. Coercible a b => a -> b
Coerce.coerce View
gi'self)  TextIter
iter' Int32
count


-- | Connect a signal handler for the [smartHomeEnd](#signal:smartHomeEnd) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' view #smartHomeEnd callback
-- @
-- 
-- 
onViewSmartHomeEnd :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewSmartHomeEndCallback) -> m SignalHandlerId
onViewSmartHomeEnd :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewSmartHomeEndCallback) -> m SignalHandlerId
onViewSmartHomeEnd a
obj (?self::a) => ViewSmartHomeEndCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewSmartHomeEndCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewSmartHomeEndCallback
ViewSmartHomeEndCallback
cb
    let wrapped' :: C_ViewSmartHomeEndCallback
wrapped' = (a -> ViewSmartHomeEndCallback) -> C_ViewSmartHomeEndCallback
forall a.
GObject a =>
(a -> ViewSmartHomeEndCallback) -> C_ViewSmartHomeEndCallback
wrap_ViewSmartHomeEndCallback a -> ViewSmartHomeEndCallback
wrapped
    FunPtr C_ViewSmartHomeEndCallback
wrapped'' <- C_ViewSmartHomeEndCallback
-> IO (FunPtr C_ViewSmartHomeEndCallback)
mk_ViewSmartHomeEndCallback C_ViewSmartHomeEndCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewSmartHomeEndCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"smart-home-end" FunPtr C_ViewSmartHomeEndCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [smartHomeEnd](#signal:smartHomeEnd) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' view #smartHomeEnd callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterViewSmartHomeEnd :: (IsView a, MonadIO m) => a -> ((?self :: a) => ViewSmartHomeEndCallback) -> m SignalHandlerId
afterViewSmartHomeEnd :: forall a (m :: * -> *).
(IsView a, MonadIO m) =>
a -> ((?self::a) => ViewSmartHomeEndCallback) -> m SignalHandlerId
afterViewSmartHomeEnd a
obj (?self::a) => ViewSmartHomeEndCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ViewSmartHomeEndCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ViewSmartHomeEndCallback
ViewSmartHomeEndCallback
cb
    let wrapped' :: C_ViewSmartHomeEndCallback
wrapped' = (a -> ViewSmartHomeEndCallback) -> C_ViewSmartHomeEndCallback
forall a.
GObject a =>
(a -> ViewSmartHomeEndCallback) -> C_ViewSmartHomeEndCallback
wrap_ViewSmartHomeEndCallback a -> ViewSmartHomeEndCallback
wrapped
    FunPtr C_ViewSmartHomeEndCallback
wrapped'' <- C_ViewSmartHomeEndCallback
-> IO (FunPtr C_ViewSmartHomeEndCallback)
mk_ViewSmartHomeEndCallback C_ViewSmartHomeEndCallback
wrapped'
    a
-> Text
-> FunPtr C_ViewSmartHomeEndCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"smart-home-end" FunPtr C_ViewSmartHomeEndCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ViewSmartHomeEndSignalInfo
instance SignalInfo ViewSmartHomeEndSignalInfo where
    type HaskellCallbackType ViewSmartHomeEndSignalInfo = ViewSmartHomeEndCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ViewSmartHomeEndCallback cb
        cb'' <- mk_ViewSmartHomeEndCallback cb'
        connectSignalFunPtr obj "smart-home-end" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View::smart-home-end"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:signal:smartHomeEnd"})

#endif

-- VVV Prop "auto-indent"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@auto-indent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #autoIndent
-- @
getViewAutoIndent :: (MonadIO m, IsView o) => o -> m Bool
getViewAutoIndent :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewAutoIndent o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"auto-indent"

-- | Set the value of the “@auto-indent@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #autoIndent 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewAutoIndent :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewAutoIndent :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewAutoIndent o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"auto-indent" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@auto-indent@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewAutoIndent :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewAutoIndent :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewAutoIndent Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"auto-indent" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewAutoIndentPropertyInfo
instance AttrInfo ViewAutoIndentPropertyInfo where
    type AttrAllowedOps ViewAutoIndentPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewAutoIndentPropertyInfo = IsView
    type AttrSetTypeConstraint ViewAutoIndentPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewAutoIndentPropertyInfo = (~) Bool
    type AttrTransferType ViewAutoIndentPropertyInfo = Bool
    type AttrGetType ViewAutoIndentPropertyInfo = Bool
    type AttrLabel ViewAutoIndentPropertyInfo = "auto-indent"
    type AttrOrigin ViewAutoIndentPropertyInfo = View
    attrGet = getViewAutoIndent
    attrSet = setViewAutoIndent
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewAutoIndent
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.autoIndent"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:autoIndent"
        })
#endif

-- VVV Prop "background-pattern"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "BackgroundPatternType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@background-pattern@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #backgroundPattern
-- @
getViewBackgroundPattern :: (MonadIO m, IsView o) => o -> m GtkSource.Enums.BackgroundPatternType
getViewBackgroundPattern :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> m BackgroundPatternType
getViewBackgroundPattern o
obj = IO BackgroundPatternType -> m BackgroundPatternType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO BackgroundPatternType -> m BackgroundPatternType)
-> IO BackgroundPatternType -> m BackgroundPatternType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO BackgroundPatternType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"background-pattern"

-- | Set the value of the “@background-pattern@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #backgroundPattern 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewBackgroundPattern :: (MonadIO m, IsView o) => o -> GtkSource.Enums.BackgroundPatternType -> m ()
setViewBackgroundPattern :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> BackgroundPatternType -> m ()
setViewBackgroundPattern o
obj BackgroundPatternType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> BackgroundPatternType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"background-pattern" BackgroundPatternType
val

-- | Construct a `GValueConstruct` with valid value for the “@background-pattern@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewBackgroundPattern :: (IsView o, MIO.MonadIO m) => GtkSource.Enums.BackgroundPatternType -> m (GValueConstruct o)
constructViewBackgroundPattern :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
BackgroundPatternType -> m (GValueConstruct o)
constructViewBackgroundPattern BackgroundPatternType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> BackgroundPatternType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"background-pattern" BackgroundPatternType
val

#if defined(ENABLE_OVERLOADING)
data ViewBackgroundPatternPropertyInfo
instance AttrInfo ViewBackgroundPatternPropertyInfo where
    type AttrAllowedOps ViewBackgroundPatternPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewBackgroundPatternPropertyInfo = IsView
    type AttrSetTypeConstraint ViewBackgroundPatternPropertyInfo = (~) GtkSource.Enums.BackgroundPatternType
    type AttrTransferTypeConstraint ViewBackgroundPatternPropertyInfo = (~) GtkSource.Enums.BackgroundPatternType
    type AttrTransferType ViewBackgroundPatternPropertyInfo = GtkSource.Enums.BackgroundPatternType
    type AttrGetType ViewBackgroundPatternPropertyInfo = GtkSource.Enums.BackgroundPatternType
    type AttrLabel ViewBackgroundPatternPropertyInfo = "background-pattern"
    type AttrOrigin ViewBackgroundPatternPropertyInfo = View
    attrGet = getViewBackgroundPattern
    attrSet = setViewBackgroundPattern
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewBackgroundPattern
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.backgroundPattern"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:backgroundPattern"
        })
#endif

-- VVV Prop "completion"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "Completion"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@completion@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #completion
-- @
getViewCompletion :: (MonadIO m, IsView o) => o -> m GtkSource.Completion.Completion
getViewCompletion :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Completion
getViewCompletion o
obj = IO Completion -> m Completion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Completion -> m Completion) -> IO Completion -> m Completion
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe Completion) -> IO Completion
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getViewCompletion" (IO (Maybe Completion) -> IO Completion)
-> IO (Maybe Completion) -> IO Completion
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Completion -> Completion)
-> IO (Maybe Completion)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"completion" ManagedPtr Completion -> Completion
GtkSource.Completion.Completion

#if defined(ENABLE_OVERLOADING)
data ViewCompletionPropertyInfo
instance AttrInfo ViewCompletionPropertyInfo where
    type AttrAllowedOps ViewCompletionPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ViewCompletionPropertyInfo = IsView
    type AttrSetTypeConstraint ViewCompletionPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ViewCompletionPropertyInfo = (~) ()
    type AttrTransferType ViewCompletionPropertyInfo = ()
    type AttrGetType ViewCompletionPropertyInfo = GtkSource.Completion.Completion
    type AttrLabel ViewCompletionPropertyInfo = "completion"
    type AttrOrigin ViewCompletionPropertyInfo = View
    attrGet = getViewCompletion
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.completion"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:completion"
        })
#endif

-- VVV Prop "enable-snippets"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@enable-snippets@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #enableSnippets
-- @
getViewEnableSnippets :: (MonadIO m, IsView o) => o -> m Bool
getViewEnableSnippets :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewEnableSnippets o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"enable-snippets"

-- | Set the value of the “@enable-snippets@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #enableSnippets 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewEnableSnippets :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewEnableSnippets :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewEnableSnippets o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"enable-snippets" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@enable-snippets@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewEnableSnippets :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewEnableSnippets :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewEnableSnippets Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"enable-snippets" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewEnableSnippetsPropertyInfo
instance AttrInfo ViewEnableSnippetsPropertyInfo where
    type AttrAllowedOps ViewEnableSnippetsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewEnableSnippetsPropertyInfo = IsView
    type AttrSetTypeConstraint ViewEnableSnippetsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewEnableSnippetsPropertyInfo = (~) Bool
    type AttrTransferType ViewEnableSnippetsPropertyInfo = Bool
    type AttrGetType ViewEnableSnippetsPropertyInfo = Bool
    type AttrLabel ViewEnableSnippetsPropertyInfo = "enable-snippets"
    type AttrOrigin ViewEnableSnippetsPropertyInfo = View
    attrGet = getViewEnableSnippets
    attrSet = setViewEnableSnippets
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewEnableSnippets
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.enableSnippets"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:enableSnippets"
        })
#endif

-- VVV Prop "highlight-current-line"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@highlight-current-line@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #highlightCurrentLine
-- @
getViewHighlightCurrentLine :: (MonadIO m, IsView o) => o -> m Bool
getViewHighlightCurrentLine :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewHighlightCurrentLine o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"highlight-current-line"

-- | Set the value of the “@highlight-current-line@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #highlightCurrentLine 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewHighlightCurrentLine :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewHighlightCurrentLine :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewHighlightCurrentLine o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"highlight-current-line" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@highlight-current-line@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewHighlightCurrentLine :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewHighlightCurrentLine :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewHighlightCurrentLine Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"highlight-current-line" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewHighlightCurrentLinePropertyInfo
instance AttrInfo ViewHighlightCurrentLinePropertyInfo where
    type AttrAllowedOps ViewHighlightCurrentLinePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewHighlightCurrentLinePropertyInfo = IsView
    type AttrSetTypeConstraint ViewHighlightCurrentLinePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewHighlightCurrentLinePropertyInfo = (~) Bool
    type AttrTransferType ViewHighlightCurrentLinePropertyInfo = Bool
    type AttrGetType ViewHighlightCurrentLinePropertyInfo = Bool
    type AttrLabel ViewHighlightCurrentLinePropertyInfo = "highlight-current-line"
    type AttrOrigin ViewHighlightCurrentLinePropertyInfo = View
    attrGet = getViewHighlightCurrentLine
    attrSet = setViewHighlightCurrentLine
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewHighlightCurrentLine
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.highlightCurrentLine"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:highlightCurrentLine"
        })
#endif

-- VVV Prop "indent-on-tab"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@indent-on-tab@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #indentOnTab
-- @
getViewIndentOnTab :: (MonadIO m, IsView o) => o -> m Bool
getViewIndentOnTab :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewIndentOnTab o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"indent-on-tab"

-- | Set the value of the “@indent-on-tab@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #indentOnTab 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewIndentOnTab :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewIndentOnTab :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewIndentOnTab o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"indent-on-tab" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@indent-on-tab@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewIndentOnTab :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewIndentOnTab :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewIndentOnTab Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"indent-on-tab" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewIndentOnTabPropertyInfo
instance AttrInfo ViewIndentOnTabPropertyInfo where
    type AttrAllowedOps ViewIndentOnTabPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewIndentOnTabPropertyInfo = IsView
    type AttrSetTypeConstraint ViewIndentOnTabPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewIndentOnTabPropertyInfo = (~) Bool
    type AttrTransferType ViewIndentOnTabPropertyInfo = Bool
    type AttrGetType ViewIndentOnTabPropertyInfo = Bool
    type AttrLabel ViewIndentOnTabPropertyInfo = "indent-on-tab"
    type AttrOrigin ViewIndentOnTabPropertyInfo = View
    attrGet = getViewIndentOnTab
    attrSet = setViewIndentOnTab
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewIndentOnTab
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.indentOnTab"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:indentOnTab"
        })
#endif

-- VVV Prop "indent-width"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@indent-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #indentWidth
-- @
getViewIndentWidth :: (MonadIO m, IsView o) => o -> m Int32
getViewIndentWidth :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Int32
getViewIndentWidth o
obj = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"indent-width"

-- | Set the value of the “@indent-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #indentWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewIndentWidth :: (MonadIO m, IsView o) => o -> Int32 -> m ()
setViewIndentWidth :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Int32 -> m ()
setViewIndentWidth o
obj Int32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewChangeNumberCallback
forall a. GObject a => a -> String -> ViewChangeNumberCallback
B.Properties.setObjectPropertyInt32 o
obj String
"indent-width" Int32
val

-- | Construct a `GValueConstruct` with valid value for the “@indent-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewIndentWidth :: (IsView o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructViewIndentWidth :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructViewIndentWidth Int32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"indent-width" Int32
val

#if defined(ENABLE_OVERLOADING)
data ViewIndentWidthPropertyInfo
instance AttrInfo ViewIndentWidthPropertyInfo where
    type AttrAllowedOps ViewIndentWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewIndentWidthPropertyInfo = IsView
    type AttrSetTypeConstraint ViewIndentWidthPropertyInfo = (~) Int32
    type AttrTransferTypeConstraint ViewIndentWidthPropertyInfo = (~) Int32
    type AttrTransferType ViewIndentWidthPropertyInfo = Int32
    type AttrGetType ViewIndentWidthPropertyInfo = Int32
    type AttrLabel ViewIndentWidthPropertyInfo = "indent-width"
    type AttrOrigin ViewIndentWidthPropertyInfo = View
    attrGet = getViewIndentWidth
    attrSet = setViewIndentWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewIndentWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.indentWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:indentWidth"
        })
#endif

-- VVV Prop "indenter"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "Indenter"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just True,Just True)

-- | Get the value of the “@indenter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #indenter
-- @
getViewIndenter :: (MonadIO m, IsView o) => o -> m (Maybe GtkSource.Indenter.Indenter)
getViewIndenter :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> m (Maybe Indenter)
getViewIndenter o
obj = IO (Maybe Indenter) -> m (Maybe Indenter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe Indenter) -> m (Maybe Indenter))
-> IO (Maybe Indenter) -> m (Maybe Indenter)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr Indenter -> Indenter)
-> IO (Maybe Indenter)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"indenter" ManagedPtr Indenter -> Indenter
GtkSource.Indenter.Indenter

-- | Set the value of the “@indenter@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #indenter 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewIndenter :: (MonadIO m, IsView o, GtkSource.Indenter.IsIndenter a) => o -> a -> m ()
setViewIndenter :: forall (m :: * -> *) o a.
(MonadIO m, IsView o, IsIndenter a) =>
o -> a -> m ()
setViewIndenter o
obj a
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Maybe a -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"indenter" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

-- | Construct a `GValueConstruct` with valid value for the “@indenter@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewIndenter :: (IsView o, MIO.MonadIO m, GtkSource.Indenter.IsIndenter a) => a -> m (GValueConstruct o)
constructViewIndenter :: forall o (m :: * -> *) a.
(IsView o, MonadIO m, IsIndenter a) =>
a -> m (GValueConstruct o)
constructViewIndenter a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"indenter" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

-- | Set the value of the “@indenter@” property to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #indenter
-- @
clearViewIndenter :: (MonadIO m, IsView o) => o -> m ()
clearViewIndenter :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m ()
clearViewIndenter o
obj = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Maybe Indenter -> IO ()
forall a b.
(GObject a, GObject b) =>
a -> String -> Maybe b -> IO ()
B.Properties.setObjectPropertyObject o
obj String
"indenter" (Maybe Indenter
forall a. Maybe a
Nothing :: Maybe GtkSource.Indenter.Indenter)

#if defined(ENABLE_OVERLOADING)
data ViewIndenterPropertyInfo
instance AttrInfo ViewIndenterPropertyInfo where
    type AttrAllowedOps ViewIndenterPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ViewIndenterPropertyInfo = IsView
    type AttrSetTypeConstraint ViewIndenterPropertyInfo = GtkSource.Indenter.IsIndenter
    type AttrTransferTypeConstraint ViewIndenterPropertyInfo = GtkSource.Indenter.IsIndenter
    type AttrTransferType ViewIndenterPropertyInfo = GtkSource.Indenter.Indenter
    type AttrGetType ViewIndenterPropertyInfo = (Maybe GtkSource.Indenter.Indenter)
    type AttrLabel ViewIndenterPropertyInfo = "indenter"
    type AttrOrigin ViewIndenterPropertyInfo = View
    attrGet = getViewIndenter
    attrSet = setViewIndenter
    attrTransfer _ v = do
        unsafeCastTo GtkSource.Indenter.Indenter v
    attrConstruct = constructViewIndenter
    attrClear = clearViewIndenter
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.indenter"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:indenter"
        })
#endif

-- VVV Prop "insert-spaces-instead-of-tabs"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@insert-spaces-instead-of-tabs@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #insertSpacesInsteadOfTabs
-- @
getViewInsertSpacesInsteadOfTabs :: (MonadIO m, IsView o) => o -> m Bool
getViewInsertSpacesInsteadOfTabs :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewInsertSpacesInsteadOfTabs o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"insert-spaces-instead-of-tabs"

-- | Set the value of the “@insert-spaces-instead-of-tabs@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #insertSpacesInsteadOfTabs 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewInsertSpacesInsteadOfTabs :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewInsertSpacesInsteadOfTabs :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewInsertSpacesInsteadOfTabs o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"insert-spaces-instead-of-tabs" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@insert-spaces-instead-of-tabs@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewInsertSpacesInsteadOfTabs :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewInsertSpacesInsteadOfTabs :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewInsertSpacesInsteadOfTabs Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"insert-spaces-instead-of-tabs" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewInsertSpacesInsteadOfTabsPropertyInfo
instance AttrInfo ViewInsertSpacesInsteadOfTabsPropertyInfo where
    type AttrAllowedOps ViewInsertSpacesInsteadOfTabsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewInsertSpacesInsteadOfTabsPropertyInfo = IsView
    type AttrSetTypeConstraint ViewInsertSpacesInsteadOfTabsPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewInsertSpacesInsteadOfTabsPropertyInfo = (~) Bool
    type AttrTransferType ViewInsertSpacesInsteadOfTabsPropertyInfo = Bool
    type AttrGetType ViewInsertSpacesInsteadOfTabsPropertyInfo = Bool
    type AttrLabel ViewInsertSpacesInsteadOfTabsPropertyInfo = "insert-spaces-instead-of-tabs"
    type AttrOrigin ViewInsertSpacesInsteadOfTabsPropertyInfo = View
    attrGet = getViewInsertSpacesInsteadOfTabs
    attrSet = setViewInsertSpacesInsteadOfTabs
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewInsertSpacesInsteadOfTabs
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.insertSpacesInsteadOfTabs"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:insertSpacesInsteadOfTabs"
        })
#endif

-- VVV Prop "right-margin-position"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@right-margin-position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #rightMarginPosition
-- @
getViewRightMarginPosition :: (MonadIO m, IsView o) => o -> m Word32
getViewRightMarginPosition :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Word32
getViewRightMarginPosition o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"right-margin-position"

-- | Set the value of the “@right-margin-position@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #rightMarginPosition 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewRightMarginPosition :: (MonadIO m, IsView o) => o -> Word32 -> m ()
setViewRightMarginPosition :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> Word32 -> m ()
setViewRightMarginPosition o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"right-margin-position" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@right-margin-position@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewRightMarginPosition :: (IsView o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructViewRightMarginPosition :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructViewRightMarginPosition Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"right-margin-position" Word32
val

#if defined(ENABLE_OVERLOADING)
data ViewRightMarginPositionPropertyInfo
instance AttrInfo ViewRightMarginPositionPropertyInfo where
    type AttrAllowedOps ViewRightMarginPositionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewRightMarginPositionPropertyInfo = IsView
    type AttrSetTypeConstraint ViewRightMarginPositionPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint ViewRightMarginPositionPropertyInfo = (~) Word32
    type AttrTransferType ViewRightMarginPositionPropertyInfo = Word32
    type AttrGetType ViewRightMarginPositionPropertyInfo = Word32
    type AttrLabel ViewRightMarginPositionPropertyInfo = "right-margin-position"
    type AttrOrigin ViewRightMarginPositionPropertyInfo = View
    attrGet = getViewRightMarginPosition
    attrSet = setViewRightMarginPosition
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewRightMarginPosition
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.rightMarginPosition"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:rightMarginPosition"
        })
#endif

-- VVV Prop "show-line-marks"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@show-line-marks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #showLineMarks
-- @
getViewShowLineMarks :: (MonadIO m, IsView o) => o -> m Bool
getViewShowLineMarks :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewShowLineMarks o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"show-line-marks"

-- | Set the value of the “@show-line-marks@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #showLineMarks 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewShowLineMarks :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewShowLineMarks :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewShowLineMarks o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"show-line-marks" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-line-marks@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewShowLineMarks :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewShowLineMarks :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewShowLineMarks Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-line-marks" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewShowLineMarksPropertyInfo
instance AttrInfo ViewShowLineMarksPropertyInfo where
    type AttrAllowedOps ViewShowLineMarksPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewShowLineMarksPropertyInfo = IsView
    type AttrSetTypeConstraint ViewShowLineMarksPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewShowLineMarksPropertyInfo = (~) Bool
    type AttrTransferType ViewShowLineMarksPropertyInfo = Bool
    type AttrGetType ViewShowLineMarksPropertyInfo = Bool
    type AttrLabel ViewShowLineMarksPropertyInfo = "show-line-marks"
    type AttrOrigin ViewShowLineMarksPropertyInfo = View
    attrGet = getViewShowLineMarks
    attrSet = setViewShowLineMarks
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewShowLineMarks
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.showLineMarks"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:showLineMarks"
        })
#endif

-- VVV Prop "show-line-numbers"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@show-line-numbers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #showLineNumbers
-- @
getViewShowLineNumbers :: (MonadIO m, IsView o) => o -> m Bool
getViewShowLineNumbers :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewShowLineNumbers o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"show-line-numbers"

-- | Set the value of the “@show-line-numbers@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #showLineNumbers 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewShowLineNumbers :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewShowLineNumbers :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewShowLineNumbers o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"show-line-numbers" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-line-numbers@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewShowLineNumbers :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewShowLineNumbers :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewShowLineNumbers Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-line-numbers" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewShowLineNumbersPropertyInfo
instance AttrInfo ViewShowLineNumbersPropertyInfo where
    type AttrAllowedOps ViewShowLineNumbersPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewShowLineNumbersPropertyInfo = IsView
    type AttrSetTypeConstraint ViewShowLineNumbersPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewShowLineNumbersPropertyInfo = (~) Bool
    type AttrTransferType ViewShowLineNumbersPropertyInfo = Bool
    type AttrGetType ViewShowLineNumbersPropertyInfo = Bool
    type AttrLabel ViewShowLineNumbersPropertyInfo = "show-line-numbers"
    type AttrOrigin ViewShowLineNumbersPropertyInfo = View
    attrGet = getViewShowLineNumbers
    attrSet = setViewShowLineNumbers
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewShowLineNumbers
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.showLineNumbers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:showLineNumbers"
        })
#endif

-- VVV Prop "show-right-margin"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@show-right-margin@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #showRightMargin
-- @
getViewShowRightMargin :: (MonadIO m, IsView o) => o -> m Bool
getViewShowRightMargin :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewShowRightMargin o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"show-right-margin"

-- | Set the value of the “@show-right-margin@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #showRightMargin 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewShowRightMargin :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewShowRightMargin :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewShowRightMargin o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"show-right-margin" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@show-right-margin@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewShowRightMargin :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewShowRightMargin :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewShowRightMargin Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"show-right-margin" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewShowRightMarginPropertyInfo
instance AttrInfo ViewShowRightMarginPropertyInfo where
    type AttrAllowedOps ViewShowRightMarginPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewShowRightMarginPropertyInfo = IsView
    type AttrSetTypeConstraint ViewShowRightMarginPropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewShowRightMarginPropertyInfo = (~) Bool
    type AttrTransferType ViewShowRightMarginPropertyInfo = Bool
    type AttrGetType ViewShowRightMarginPropertyInfo = Bool
    type AttrLabel ViewShowRightMarginPropertyInfo = "show-right-margin"
    type AttrOrigin ViewShowRightMarginPropertyInfo = View
    attrGet = getViewShowRightMargin
    attrSet = setViewShowRightMargin
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewShowRightMargin
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.showRightMargin"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:showRightMargin"
        })
#endif

-- VVV Prop "smart-backspace"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@smart-backspace@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #smartBackspace
-- @
getViewSmartBackspace :: (MonadIO m, IsView o) => o -> m Bool
getViewSmartBackspace :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Bool
getViewSmartBackspace o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"smart-backspace"

-- | Set the value of the “@smart-backspace@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #smartBackspace 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewSmartBackspace :: (MonadIO m, IsView o) => o -> Bool -> m ()
setViewSmartBackspace :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> Bool -> m ()
setViewSmartBackspace o
obj Bool
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> ViewMoveLinesCallback
forall a. GObject a => a -> String -> ViewMoveLinesCallback
B.Properties.setObjectPropertyBool o
obj String
"smart-backspace" Bool
val

-- | Construct a `GValueConstruct` with valid value for the “@smart-backspace@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewSmartBackspace :: (IsView o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructViewSmartBackspace :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructViewSmartBackspace Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"smart-backspace" Bool
val

#if defined(ENABLE_OVERLOADING)
data ViewSmartBackspacePropertyInfo
instance AttrInfo ViewSmartBackspacePropertyInfo where
    type AttrAllowedOps ViewSmartBackspacePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewSmartBackspacePropertyInfo = IsView
    type AttrSetTypeConstraint ViewSmartBackspacePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint ViewSmartBackspacePropertyInfo = (~) Bool
    type AttrTransferType ViewSmartBackspacePropertyInfo = Bool
    type AttrGetType ViewSmartBackspacePropertyInfo = Bool
    type AttrLabel ViewSmartBackspacePropertyInfo = "smart-backspace"
    type AttrOrigin ViewSmartBackspacePropertyInfo = View
    attrGet = getViewSmartBackspace
    attrSet = setViewSmartBackspace
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewSmartBackspace
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.smartBackspace"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:smartBackspace"
        })
#endif

-- VVV Prop "smart-home-end"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "SmartHomeEndType"})
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@smart-home-end@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #smartHomeEnd
-- @
getViewSmartHomeEnd :: (MonadIO m, IsView o) => o -> m GtkSource.Enums.SmartHomeEndType
getViewSmartHomeEnd :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> m SmartHomeEndType
getViewSmartHomeEnd o
obj = IO SmartHomeEndType -> m SmartHomeEndType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SmartHomeEndType -> m SmartHomeEndType)
-> IO SmartHomeEndType -> m SmartHomeEndType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO SmartHomeEndType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"smart-home-end"

-- | Set the value of the “@smart-home-end@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #smartHomeEnd 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewSmartHomeEnd :: (MonadIO m, IsView o) => o -> GtkSource.Enums.SmartHomeEndType -> m ()
setViewSmartHomeEnd :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> SmartHomeEndType -> m ()
setViewSmartHomeEnd o
obj SmartHomeEndType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> SmartHomeEndType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"smart-home-end" SmartHomeEndType
val

-- | Construct a `GValueConstruct` with valid value for the “@smart-home-end@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewSmartHomeEnd :: (IsView o, MIO.MonadIO m) => GtkSource.Enums.SmartHomeEndType -> m (GValueConstruct o)
constructViewSmartHomeEnd :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
SmartHomeEndType -> m (GValueConstruct o)
constructViewSmartHomeEnd SmartHomeEndType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> SmartHomeEndType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"smart-home-end" SmartHomeEndType
val

#if defined(ENABLE_OVERLOADING)
data ViewSmartHomeEndPropertyInfo
instance AttrInfo ViewSmartHomeEndPropertyInfo where
    type AttrAllowedOps ViewSmartHomeEndPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewSmartHomeEndPropertyInfo = IsView
    type AttrSetTypeConstraint ViewSmartHomeEndPropertyInfo = (~) GtkSource.Enums.SmartHomeEndType
    type AttrTransferTypeConstraint ViewSmartHomeEndPropertyInfo = (~) GtkSource.Enums.SmartHomeEndType
    type AttrTransferType ViewSmartHomeEndPropertyInfo = GtkSource.Enums.SmartHomeEndType
    type AttrGetType ViewSmartHomeEndPropertyInfo = GtkSource.Enums.SmartHomeEndType
    type AttrLabel ViewSmartHomeEndPropertyInfo = "smart-home-end"
    type AttrOrigin ViewSmartHomeEndPropertyInfo = View
    attrGet = getViewSmartHomeEnd
    attrSet = setViewSmartHomeEnd
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewSmartHomeEnd
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.smartHomeEnd"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:smartHomeEnd"
        })
#endif

-- VVV Prop "space-drawer"
   -- Type: TInterface (Name {namespace = "GtkSource", name = "SpaceDrawer"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@space-drawer@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #spaceDrawer
-- @
getViewSpaceDrawer :: (MonadIO m, IsView o) => o -> m GtkSource.SpaceDrawer.SpaceDrawer
getViewSpaceDrawer :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m SpaceDrawer
getViewSpaceDrawer o
obj = IO SpaceDrawer -> m SpaceDrawer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO SpaceDrawer -> m SpaceDrawer)
-> IO SpaceDrawer -> m SpaceDrawer
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe SpaceDrawer) -> IO SpaceDrawer
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing Text
"getViewSpaceDrawer" (IO (Maybe SpaceDrawer) -> IO SpaceDrawer)
-> IO (Maybe SpaceDrawer) -> IO SpaceDrawer
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr SpaceDrawer -> SpaceDrawer)
-> IO (Maybe SpaceDrawer)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"space-drawer" ManagedPtr SpaceDrawer -> SpaceDrawer
GtkSource.SpaceDrawer.SpaceDrawer

#if defined(ENABLE_OVERLOADING)
data ViewSpaceDrawerPropertyInfo
instance AttrInfo ViewSpaceDrawerPropertyInfo where
    type AttrAllowedOps ViewSpaceDrawerPropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ViewSpaceDrawerPropertyInfo = IsView
    type AttrSetTypeConstraint ViewSpaceDrawerPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ViewSpaceDrawerPropertyInfo = (~) ()
    type AttrTransferType ViewSpaceDrawerPropertyInfo = ()
    type AttrGetType ViewSpaceDrawerPropertyInfo = GtkSource.SpaceDrawer.SpaceDrawer
    type AttrLabel ViewSpaceDrawerPropertyInfo = "space-drawer"
    type AttrOrigin ViewSpaceDrawerPropertyInfo = View
    attrGet = getViewSpaceDrawer
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.spaceDrawer"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:spaceDrawer"
        })
#endif

-- VVV Prop "tab-width"
   -- Type: TBasicType TUInt
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

-- | Get the value of the “@tab-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' view #tabWidth
-- @
getViewTabWidth :: (MonadIO m, IsView o) => o -> m Word32
getViewTabWidth :: forall (m :: * -> *) o. (MonadIO m, IsView o) => o -> m Word32
getViewTabWidth o
obj = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Word32
forall a. GObject a => a -> String -> IO Word32
B.Properties.getObjectPropertyUInt32 o
obj String
"tab-width"

-- | Set the value of the “@tab-width@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' view [ #tabWidth 'Data.GI.Base.Attributes.:=' value ]
-- @
setViewTabWidth :: (MonadIO m, IsView o) => o -> Word32 -> m ()
setViewTabWidth :: forall (m :: * -> *) o.
(MonadIO m, IsView o) =>
o -> Word32 -> m ()
setViewTabWidth o
obj Word32
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    o -> String -> Word32 -> IO ()
forall a. GObject a => a -> String -> Word32 -> IO ()
B.Properties.setObjectPropertyUInt32 o
obj String
"tab-width" Word32
val

-- | Construct a `GValueConstruct` with valid value for the “@tab-width@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructViewTabWidth :: (IsView o, MIO.MonadIO m) => Word32 -> m (GValueConstruct o)
constructViewTabWidth :: forall o (m :: * -> *).
(IsView o, MonadIO m) =>
Word32 -> m (GValueConstruct o)
constructViewTabWidth Word32
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Word32 -> IO (GValueConstruct o)
forall o. String -> Word32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyUInt32 String
"tab-width" Word32
val

#if defined(ENABLE_OVERLOADING)
data ViewTabWidthPropertyInfo
instance AttrInfo ViewTabWidthPropertyInfo where
    type AttrAllowedOps ViewTabWidthPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint ViewTabWidthPropertyInfo = IsView
    type AttrSetTypeConstraint ViewTabWidthPropertyInfo = (~) Word32
    type AttrTransferTypeConstraint ViewTabWidthPropertyInfo = (~) Word32
    type AttrTransferType ViewTabWidthPropertyInfo = Word32
    type AttrGetType ViewTabWidthPropertyInfo = Word32
    type AttrLabel ViewTabWidthPropertyInfo = "tab-width"
    type AttrOrigin ViewTabWidthPropertyInfo = View
    attrGet = getViewTabWidth
    attrSet = setViewTabWidth
    attrTransfer _ v = do
        return v
    attrConstruct = constructViewTabWidth
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.tabWidth"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#g:attr:tabWidth"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList View
type instance O.AttributeList View = ViewAttributeList
type ViewAttributeList = ('[ '("acceptsTab", Gtk.TextView.TextViewAcceptsTabPropertyInfo), '("accessibleRole", Gtk.Accessible.AccessibleAccessibleRolePropertyInfo), '("autoIndent", ViewAutoIndentPropertyInfo), '("backgroundPattern", ViewBackgroundPatternPropertyInfo), '("bottomMargin", Gtk.TextView.TextViewBottomMarginPropertyInfo), '("buffer", Gtk.TextView.TextViewBufferPropertyInfo), '("canFocus", Gtk.Widget.WidgetCanFocusPropertyInfo), '("canTarget", Gtk.Widget.WidgetCanTargetPropertyInfo), '("completion", ViewCompletionPropertyInfo), '("cssClasses", Gtk.Widget.WidgetCssClassesPropertyInfo), '("cssName", Gtk.Widget.WidgetCssNamePropertyInfo), '("cursor", Gtk.Widget.WidgetCursorPropertyInfo), '("cursorVisible", Gtk.TextView.TextViewCursorVisiblePropertyInfo), '("editable", Gtk.TextView.TextViewEditablePropertyInfo), '("enableSnippets", ViewEnableSnippetsPropertyInfo), '("extraMenu", Gtk.TextView.TextViewExtraMenuPropertyInfo), '("focusOnClick", Gtk.Widget.WidgetFocusOnClickPropertyInfo), '("focusable", Gtk.Widget.WidgetFocusablePropertyInfo), '("hadjustment", Gtk.Scrollable.ScrollableHadjustmentPropertyInfo), '("halign", Gtk.Widget.WidgetHalignPropertyInfo), '("hasDefault", Gtk.Widget.WidgetHasDefaultPropertyInfo), '("hasFocus", Gtk.Widget.WidgetHasFocusPropertyInfo), '("hasTooltip", Gtk.Widget.WidgetHasTooltipPropertyInfo), '("heightRequest", Gtk.Widget.WidgetHeightRequestPropertyInfo), '("hexpand", Gtk.Widget.WidgetHexpandPropertyInfo), '("hexpandSet", Gtk.Widget.WidgetHexpandSetPropertyInfo), '("highlightCurrentLine", ViewHighlightCurrentLinePropertyInfo), '("hscrollPolicy", Gtk.Scrollable.ScrollableHscrollPolicyPropertyInfo), '("imModule", Gtk.TextView.TextViewImModulePropertyInfo), '("indent", Gtk.TextView.TextViewIndentPropertyInfo), '("indentOnTab", ViewIndentOnTabPropertyInfo), '("indentWidth", ViewIndentWidthPropertyInfo), '("indenter", ViewIndenterPropertyInfo), '("inputHints", Gtk.TextView.TextViewInputHintsPropertyInfo), '("inputPurpose", Gtk.TextView.TextViewInputPurposePropertyInfo), '("insertSpacesInsteadOfTabs", ViewInsertSpacesInsteadOfTabsPropertyInfo), '("justification", Gtk.TextView.TextViewJustificationPropertyInfo), '("layoutManager", Gtk.Widget.WidgetLayoutManagerPropertyInfo), '("leftMargin", Gtk.TextView.TextViewLeftMarginPropertyInfo), '("marginBottom", Gtk.Widget.WidgetMarginBottomPropertyInfo), '("marginEnd", Gtk.Widget.WidgetMarginEndPropertyInfo), '("marginStart", Gtk.Widget.WidgetMarginStartPropertyInfo), '("marginTop", Gtk.Widget.WidgetMarginTopPropertyInfo), '("monospace", Gtk.TextView.TextViewMonospacePropertyInfo), '("name", Gtk.Widget.WidgetNamePropertyInfo), '("opacity", Gtk.Widget.WidgetOpacityPropertyInfo), '("overflow", Gtk.Widget.WidgetOverflowPropertyInfo), '("overwrite", Gtk.TextView.TextViewOverwritePropertyInfo), '("parent", Gtk.Widget.WidgetParentPropertyInfo), '("pixelsAboveLines", Gtk.TextView.TextViewPixelsAboveLinesPropertyInfo), '("pixelsBelowLines", Gtk.TextView.TextViewPixelsBelowLinesPropertyInfo), '("pixelsInsideWrap", Gtk.TextView.TextViewPixelsInsideWrapPropertyInfo), '("receivesDefault", Gtk.Widget.WidgetReceivesDefaultPropertyInfo), '("rightMargin", Gtk.TextView.TextViewRightMarginPropertyInfo), '("rightMarginPosition", ViewRightMarginPositionPropertyInfo), '("root", Gtk.Widget.WidgetRootPropertyInfo), '("scaleFactor", Gtk.Widget.WidgetScaleFactorPropertyInfo), '("sensitive", Gtk.Widget.WidgetSensitivePropertyInfo), '("showLineMarks", ViewShowLineMarksPropertyInfo), '("showLineNumbers", ViewShowLineNumbersPropertyInfo), '("showRightMargin", ViewShowRightMarginPropertyInfo), '("smartBackspace", ViewSmartBackspacePropertyInfo), '("smartHomeEnd", ViewSmartHomeEndPropertyInfo), '("spaceDrawer", ViewSpaceDrawerPropertyInfo), '("tabWidth", ViewTabWidthPropertyInfo), '("tabs", Gtk.TextView.TextViewTabsPropertyInfo), '("tooltipMarkup", Gtk.Widget.WidgetTooltipMarkupPropertyInfo), '("tooltipText", Gtk.Widget.WidgetTooltipTextPropertyInfo), '("topMargin", Gtk.TextView.TextViewTopMarginPropertyInfo), '("vadjustment", Gtk.Scrollable.ScrollableVadjustmentPropertyInfo), '("valign", Gtk.Widget.WidgetValignPropertyInfo), '("vexpand", Gtk.Widget.WidgetVexpandPropertyInfo), '("vexpandSet", Gtk.Widget.WidgetVexpandSetPropertyInfo), '("visible", Gtk.Widget.WidgetVisiblePropertyInfo), '("vscrollPolicy", Gtk.Scrollable.ScrollableVscrollPolicyPropertyInfo), '("widthRequest", Gtk.Widget.WidgetWidthRequestPropertyInfo), '("wrapMode", Gtk.TextView.TextViewWrapModePropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
viewAutoIndent :: AttrLabelProxy "autoIndent"
viewAutoIndent = AttrLabelProxy

viewBackgroundPattern :: AttrLabelProxy "backgroundPattern"
viewBackgroundPattern = AttrLabelProxy

viewCompletion :: AttrLabelProxy "completion"
viewCompletion = AttrLabelProxy

viewEnableSnippets :: AttrLabelProxy "enableSnippets"
viewEnableSnippets = AttrLabelProxy

viewHighlightCurrentLine :: AttrLabelProxy "highlightCurrentLine"
viewHighlightCurrentLine = AttrLabelProxy

viewIndentOnTab :: AttrLabelProxy "indentOnTab"
viewIndentOnTab = AttrLabelProxy

viewIndentWidth :: AttrLabelProxy "indentWidth"
viewIndentWidth = AttrLabelProxy

viewIndenter :: AttrLabelProxy "indenter"
viewIndenter = AttrLabelProxy

viewInsertSpacesInsteadOfTabs :: AttrLabelProxy "insertSpacesInsteadOfTabs"
viewInsertSpacesInsteadOfTabs = AttrLabelProxy

viewRightMarginPosition :: AttrLabelProxy "rightMarginPosition"
viewRightMarginPosition = AttrLabelProxy

viewShowLineMarks :: AttrLabelProxy "showLineMarks"
viewShowLineMarks = AttrLabelProxy

viewShowLineNumbers :: AttrLabelProxy "showLineNumbers"
viewShowLineNumbers = AttrLabelProxy

viewShowRightMargin :: AttrLabelProxy "showRightMargin"
viewShowRightMargin = AttrLabelProxy

viewSmartBackspace :: AttrLabelProxy "smartBackspace"
viewSmartBackspace = AttrLabelProxy

viewSmartHomeEnd :: AttrLabelProxy "smartHomeEnd"
viewSmartHomeEnd = AttrLabelProxy

viewSpaceDrawer :: AttrLabelProxy "spaceDrawer"
viewSpaceDrawer = AttrLabelProxy

viewTabWidth :: AttrLabelProxy "tabWidth"
viewTabWidth = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList View = ViewSignalList
type ViewSignalList = ('[ '("backspace", Gtk.TextView.TextViewBackspaceSignalInfo), '("changeCase", ViewChangeCaseSignalInfo), '("changeNumber", ViewChangeNumberSignalInfo), '("copyClipboard", Gtk.TextView.TextViewCopyClipboardSignalInfo), '("cutClipboard", Gtk.TextView.TextViewCutClipboardSignalInfo), '("deleteFromCursor", Gtk.TextView.TextViewDeleteFromCursorSignalInfo), '("destroy", Gtk.Widget.WidgetDestroySignalInfo), '("directionChanged", Gtk.Widget.WidgetDirectionChangedSignalInfo), '("extendSelection", Gtk.TextView.TextViewExtendSelectionSignalInfo), '("hide", Gtk.Widget.WidgetHideSignalInfo), '("insertAtCursor", Gtk.TextView.TextViewInsertAtCursorSignalInfo), '("insertEmoji", Gtk.TextView.TextViewInsertEmojiSignalInfo), '("joinLines", ViewJoinLinesSignalInfo), '("keynavFailed", Gtk.Widget.WidgetKeynavFailedSignalInfo), '("lineMarkActivated", ViewLineMarkActivatedSignalInfo), '("map", Gtk.Widget.WidgetMapSignalInfo), '("mnemonicActivate", Gtk.Widget.WidgetMnemonicActivateSignalInfo), '("moveCursor", Gtk.TextView.TextViewMoveCursorSignalInfo), '("moveFocus", Gtk.Widget.WidgetMoveFocusSignalInfo), '("moveLines", ViewMoveLinesSignalInfo), '("moveToMatchingBracket", ViewMoveToMatchingBracketSignalInfo), '("moveViewport", Gtk.TextView.TextViewMoveViewportSignalInfo), '("moveWords", ViewMoveWordsSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pasteClipboard", Gtk.TextView.TextViewPasteClipboardSignalInfo), '("preeditChanged", Gtk.TextView.TextViewPreeditChangedSignalInfo), '("pushSnippet", ViewPushSnippetSignalInfo), '("queryTooltip", Gtk.Widget.WidgetQueryTooltipSignalInfo), '("realize", Gtk.Widget.WidgetRealizeSignalInfo), '("selectAll", Gtk.TextView.TextViewSelectAllSignalInfo), '("setAnchor", Gtk.TextView.TextViewSetAnchorSignalInfo), '("show", Gtk.Widget.WidgetShowSignalInfo), '("showCompletion", ViewShowCompletionSignalInfo), '("smartHomeEnd", ViewSmartHomeEndSignalInfo), '("stateFlagsChanged", Gtk.Widget.WidgetStateFlagsChangedSignalInfo), '("toggleCursorVisible", Gtk.TextView.TextViewToggleCursorVisibleSignalInfo), '("toggleOverwrite", Gtk.TextView.TextViewToggleOverwriteSignalInfo), '("unmap", Gtk.Widget.WidgetUnmapSignalInfo), '("unrealize", Gtk.Widget.WidgetUnrealizeSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method View::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GtkSource" , name = "View" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_new" gtk_source_view_new :: 
    IO (Ptr View)

-- | Creates a new @GtkSourceView@.
-- 
-- By default, an empty [class/@buffer@/] will be lazily created and can be
-- retrieved with 'GI.Gtk.Objects.TextView.textViewGetBuffer'.
-- 
-- If you want to specify your own buffer, either override the
-- t'GI.Gtk.Objects.TextView.TextView'.@/create_buffer/@() factory method, or use
-- [ctor/@view@/.new_with_buffer].
viewNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m View
    -- ^ __Returns:__ a new t'GI.GtkSource.Objects.View.View'.
viewNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m View
viewNew  = IO View -> m View
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO View -> m View) -> IO View -> m View
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
result <- IO (Ptr View)
gtk_source_view_new
    Text -> Ptr View -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewNew" Ptr View
result
    View
result' <- ((ManagedPtr View -> View) -> Ptr View -> IO View
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr View -> View
View) Ptr View
result
    View -> IO View
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return View
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method View::new_with_buffer
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "buffer"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Buffer" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceBuffer."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GtkSource" , name = "View" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_new_with_buffer" gtk_source_view_new_with_buffer :: 
    Ptr GtkSource.Buffer.Buffer ->          -- buffer : TInterface (Name {namespace = "GtkSource", name = "Buffer"})
    IO (Ptr View)

-- | Creates a new t'GI.GtkSource.Objects.View.View' widget displaying the buffer /@buffer@/.
-- 
-- One buffer can be shared among many widgets.
viewNewWithBuffer ::
    (B.CallStack.HasCallStack, MonadIO m, GtkSource.Buffer.IsBuffer a) =>
    a
    -- ^ /@buffer@/: a t'GI.GtkSource.Objects.Buffer.Buffer'.
    -> m View
    -- ^ __Returns:__ a new t'GI.GtkSource.Objects.View.View'.
viewNewWithBuffer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuffer a) =>
a -> m View
viewNewWithBuffer a
buffer = IO View -> m View
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO View -> m View) -> IO View -> m View
forall a b. (a -> b) -> a -> b
$ do
    Ptr Buffer
buffer' <- a -> IO (Ptr Buffer)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
buffer
    Ptr View
result <- Ptr Buffer -> IO (Ptr View)
gtk_source_view_new_with_buffer Ptr Buffer
buffer'
    Text -> Ptr View -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewNewWithBuffer" Ptr View
result
    View
result' <- ((ManagedPtr View -> View) -> Ptr View -> IO View
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr View -> View
View) Ptr View
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
buffer
    View -> IO View
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return View
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method View::get_auto_indent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_auto_indent" gtk_source_view_get_auto_indent :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether auto-indentation of text is enabled.
viewGetAutoIndent ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if auto indentation is enabled.
viewGetAutoIndent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetAutoIndent a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_auto_indent Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetAutoIndentMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetAutoIndentMethodInfo a signature where
    overloadedMethod = viewGetAutoIndent

instance O.OverloadedMethodInfo ViewGetAutoIndentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetAutoIndent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetAutoIndent"
        })


#endif

-- method View::get_background_pattern
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "BackgroundPatternType" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_background_pattern" gtk_source_view_get_background_pattern :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CUInt

-- | Returns the t'GI.GtkSource.Enums.BackgroundPatternType' specifying if and how
-- the background pattern should be displayed for this /@view@/.
viewGetBackgroundPattern ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'
    -> m GtkSource.Enums.BackgroundPatternType
    -- ^ __Returns:__ the t'GI.GtkSource.Enums.BackgroundPatternType'.
viewGetBackgroundPattern :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m BackgroundPatternType
viewGetBackgroundPattern a
view = IO BackgroundPatternType -> m BackgroundPatternType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BackgroundPatternType -> m BackgroundPatternType)
-> IO BackgroundPatternType -> m BackgroundPatternType
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CUInt
result <- Ptr View -> IO CUInt
gtk_source_view_get_background_pattern Ptr View
view'
    let result' :: BackgroundPatternType
result' = (Int -> BackgroundPatternType
forall a. Enum a => Int -> a
toEnum (Int -> BackgroundPatternType)
-> (CUInt -> Int) -> CUInt -> BackgroundPatternType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    BackgroundPatternType -> IO BackgroundPatternType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BackgroundPatternType
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetBackgroundPatternMethodInfo
instance (signature ~ (m GtkSource.Enums.BackgroundPatternType), MonadIO m, IsView a) => O.OverloadedMethod ViewGetBackgroundPatternMethodInfo a signature where
    overloadedMethod = viewGetBackgroundPattern

instance O.OverloadedMethodInfo ViewGetBackgroundPatternMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetBackgroundPattern",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetBackgroundPattern"
        })


#endif

-- method View::get_completion
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GtkSource" , name = "Completion" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_completion" gtk_source_view_get_completion :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO (Ptr GtkSource.Completion.Completion)

-- | Gets the [class/@completion@/] associated with /@view@/.
-- 
-- The returned object is guaranteed to be the same for the lifetime of /@view@/.
-- Each @GtkSourceView@ object has a different [class/@completion@/].
viewGetCompletion ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m GtkSource.Completion.Completion
    -- ^ __Returns:__ the t'GI.GtkSource.Objects.Completion.Completion' associated with /@view@/.
viewGetCompletion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Completion
viewGetCompletion a
view = IO Completion -> m Completion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Completion -> m Completion) -> IO Completion -> m Completion
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr Completion
result <- Ptr View -> IO (Ptr Completion)
gtk_source_view_get_completion Ptr View
view'
    Text -> Ptr Completion -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewGetCompletion" Ptr Completion
result
    Completion
result' <- ((ManagedPtr Completion -> Completion)
-> Ptr Completion -> IO Completion
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Completion -> Completion
GtkSource.Completion.Completion) Ptr Completion
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Completion -> IO Completion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Completion
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetCompletionMethodInfo
instance (signature ~ (m GtkSource.Completion.Completion), MonadIO m, IsView a) => O.OverloadedMethod ViewGetCompletionMethodInfo a signature where
    overloadedMethod = viewGetCompletion

instance O.OverloadedMethodInfo ViewGetCompletionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetCompletion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetCompletion"
        })


#endif

-- method View::get_enable_snippets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_enable_snippets" gtk_source_view_get_enable_snippets :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Gets the [property/@view@/:enable-snippets] property.
-- 
-- If 'P.True', matching snippets found in the [class/@snippetManager@/]
-- may be expanded when the user presses Tab after a word in the [class/@view@/].
viewGetEnableSnippets ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if enabled
viewGetEnableSnippets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetEnableSnippets a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_enable_snippets Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetEnableSnippetsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetEnableSnippetsMethodInfo a signature where
    overloadedMethod = viewGetEnableSnippets

instance O.OverloadedMethodInfo ViewGetEnableSnippetsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetEnableSnippets",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetEnableSnippets"
        })


#endif

-- method View::get_gutter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "window_type"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextWindowType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the gutter window type."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GtkSource" , name = "Gutter" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_gutter" gtk_source_view_get_gutter :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CUInt ->                                -- window_type : TInterface (Name {namespace = "Gtk", name = "TextWindowType"})
    IO (Ptr GtkSource.Gutter.Gutter)

-- | Returns the [class/@gutter@/] object associated with /@windowType@/ for /@view@/.
-- 
-- Only 'GI.Gtk.Enums.TextWindowTypeLeft' and 'GI.Gtk.Enums.TextWindowTypeRight' are supported,
-- respectively corresponding to the left and right gutter. The line numbers
-- and mark category icons are rendered in the left gutter.
viewGetGutter ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Gtk.Enums.TextWindowType
    -- ^ /@windowType@/: the gutter window type.
    -> m GtkSource.Gutter.Gutter
    -- ^ __Returns:__ the t'GI.GtkSource.Objects.Gutter.Gutter'.
viewGetGutter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> TextWindowType -> m Gutter
viewGetGutter a
view TextWindowType
windowType = IO Gutter -> m Gutter
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Gutter -> m Gutter) -> IO Gutter -> m Gutter
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let windowType' :: CUInt
windowType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (TextWindowType -> Int) -> TextWindowType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TextWindowType -> Int
forall a. Enum a => a -> Int
fromEnum) TextWindowType
windowType
    Ptr Gutter
result <- Ptr View -> CUInt -> IO (Ptr Gutter)
gtk_source_view_get_gutter Ptr View
view' CUInt
windowType'
    Text -> Ptr Gutter -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewGetGutter" Ptr Gutter
result
    Gutter
result' <- ((ManagedPtr Gutter -> Gutter) -> Ptr Gutter -> IO Gutter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Gutter -> Gutter
GtkSource.Gutter.Gutter) Ptr Gutter
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Gutter -> IO Gutter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Gutter
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetGutterMethodInfo
instance (signature ~ (Gtk.Enums.TextWindowType -> m GtkSource.Gutter.Gutter), MonadIO m, IsView a) => O.OverloadedMethod ViewGetGutterMethodInfo a signature where
    overloadedMethod = viewGetGutter

instance O.OverloadedMethodInfo ViewGetGutterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetGutter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetGutter"
        })


#endif

-- method View::get_highlight_current_line
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_highlight_current_line" gtk_source_view_get_highlight_current_line :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether the current line is highlighted.
viewGetHighlightCurrentLine ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the current line is highlighted.
viewGetHighlightCurrentLine :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetHighlightCurrentLine a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_highlight_current_line Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetHighlightCurrentLineMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetHighlightCurrentLineMethodInfo a signature where
    overloadedMethod = viewGetHighlightCurrentLine

instance O.OverloadedMethodInfo ViewGetHighlightCurrentLineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetHighlightCurrentLine",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetHighlightCurrentLine"
        })


#endif

-- method View::get_hover
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GtkSource" , name = "Hover" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_hover" gtk_source_view_get_hover :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO (Ptr GtkSource.Hover.Hover)

-- | Gets the [class/@hover@/] associated with /@view@/.
-- 
-- The returned object is guaranteed to be the same for the lifetime of /@view@/.
-- Each [class/@view@/] object has a different [class/@hover@/].
viewGetHover ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m GtkSource.Hover.Hover
    -- ^ __Returns:__ a t'GI.GtkSource.Objects.Hover.Hover' associated with /@view@/.
viewGetHover :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Hover
viewGetHover a
view = IO Hover -> m Hover
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Hover -> m Hover) -> IO Hover -> m Hover
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr Hover
result <- Ptr View -> IO (Ptr Hover)
gtk_source_view_get_hover Ptr View
view'
    Text -> Ptr Hover -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewGetHover" Ptr Hover
result
    Hover
result' <- ((ManagedPtr Hover -> Hover) -> Ptr Hover -> IO Hover
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Hover -> Hover
GtkSource.Hover.Hover) Ptr Hover
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Hover -> IO Hover
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Hover
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetHoverMethodInfo
instance (signature ~ (m GtkSource.Hover.Hover), MonadIO m, IsView a) => O.OverloadedMethod ViewGetHoverMethodInfo a signature where
    overloadedMethod = viewGetHover

instance O.OverloadedMethodInfo ViewGetHoverMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetHover",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetHover"
        })


#endif

-- method View::get_indent_on_tab
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_indent_on_tab" gtk_source_view_get_indent_on_tab :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether when the tab key is pressed the current selection
-- should get indented instead of replaced with the @\\t@ character.
viewGetIndentOnTab ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the selection is indented when tab is pressed.
viewGetIndentOnTab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetIndentOnTab a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_indent_on_tab Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetIndentOnTabMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetIndentOnTabMethodInfo a signature where
    overloadedMethod = viewGetIndentOnTab

instance O.OverloadedMethodInfo ViewGetIndentOnTabMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetIndentOnTab",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetIndentOnTab"
        })


#endif

-- method View::get_indent_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_indent_width" gtk_source_view_get_indent_width :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO Int32

-- | Returns the number of spaces to use for each step of indent.
-- 
-- See [method/@view@/.set_indent_width] for details.
viewGetIndentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Int32
    -- ^ __Returns:__ indent width.
viewGetIndentWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Int32
viewGetIndentWidth a
view = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Int32
result <- Ptr View -> IO Int32
gtk_source_view_get_indent_width Ptr View
view'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result

#if defined(ENABLE_OVERLOADING)
data ViewGetIndentWidthMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsView a) => O.OverloadedMethod ViewGetIndentWidthMethodInfo a signature where
    overloadedMethod = viewGetIndentWidth

instance O.OverloadedMethodInfo ViewGetIndentWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetIndentWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetIndentWidth"
        })


#endif

-- method View::get_indenter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "GtkSource" , name = "Indenter" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_indenter" gtk_source_view_get_indenter :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO (Ptr GtkSource.Indenter.Indenter)

-- | Gets the [property/@view@/:indenter] property.
viewGetIndenter ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'
    -> m (Maybe GtkSource.Indenter.Indenter)
    -- ^ __Returns:__ a t'GI.GtkSource.Interfaces.Indenter.Indenter' or 'P.Nothing'
viewGetIndenter :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m (Maybe Indenter)
viewGetIndenter a
view = IO (Maybe Indenter) -> m (Maybe Indenter)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Indenter) -> m (Maybe Indenter))
-> IO (Maybe Indenter) -> m (Maybe Indenter)
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr Indenter
result <- Ptr View -> IO (Ptr Indenter)
gtk_source_view_get_indenter Ptr View
view'
    Maybe Indenter
maybeResult <- Ptr Indenter
-> (Ptr Indenter -> IO Indenter) -> IO (Maybe Indenter)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Indenter
result ((Ptr Indenter -> IO Indenter) -> IO (Maybe Indenter))
-> (Ptr Indenter -> IO Indenter) -> IO (Maybe Indenter)
forall a b. (a -> b) -> a -> b
$ \Ptr Indenter
result' -> do
        Indenter
result'' <- ((ManagedPtr Indenter -> Indenter) -> Ptr Indenter -> IO Indenter
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Indenter -> Indenter
GtkSource.Indenter.Indenter) Ptr Indenter
result'
        Indenter -> IO Indenter
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Indenter
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Maybe Indenter -> IO (Maybe Indenter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Indenter
maybeResult

#if defined(ENABLE_OVERLOADING)
data ViewGetIndenterMethodInfo
instance (signature ~ (m (Maybe GtkSource.Indenter.Indenter)), MonadIO m, IsView a) => O.OverloadedMethod ViewGetIndenterMethodInfo a signature where
    overloadedMethod = viewGetIndenter

instance O.OverloadedMethodInfo ViewGetIndenterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetIndenter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetIndenter"
        })


#endif

-- method View::get_insert_spaces_instead_of_tabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_insert_spaces_instead_of_tabs" gtk_source_view_get_insert_spaces_instead_of_tabs :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether when inserting a tabulator character it should
-- be replaced by a group of space characters.
viewGetInsertSpacesInsteadOfTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if spaces are inserted instead of tabs.
viewGetInsertSpacesInsteadOfTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetInsertSpacesInsteadOfTabs a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_insert_spaces_instead_of_tabs Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetInsertSpacesInsteadOfTabsMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetInsertSpacesInsteadOfTabsMethodInfo a signature where
    overloadedMethod = viewGetInsertSpacesInsteadOfTabs

instance O.OverloadedMethodInfo ViewGetInsertSpacesInsteadOfTabsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetInsertSpacesInsteadOfTabs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetInsertSpacesInsteadOfTabs"
        })


#endif

-- method View::get_mark_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the category." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "place where priority of the category will be stored."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "MarkAttributes" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_mark_attributes" gtk_source_view_get_mark_attributes :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CString ->                              -- category : TBasicType TUTF8
    Int32 ->                                -- priority : TBasicType TInt
    IO (Ptr GtkSource.MarkAttributes.MarkAttributes)

-- | Gets attributes and priority for the /@category@/.
viewGetMarkAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> T.Text
    -- ^ /@category@/: the category.
    -> Int32
    -- ^ /@priority@/: place where priority of the category will be stored.
    -> m GtkSource.MarkAttributes.MarkAttributes
    -- ^ __Returns:__ t'GI.GtkSource.Objects.MarkAttributes.MarkAttributes' for the /@category@/.
    -- The object belongs to /@view@/, so it must not be unreffed.
viewGetMarkAttributes :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Text -> Int32 -> m MarkAttributes
viewGetMarkAttributes a
view Text
category Int32
priority = IO MarkAttributes -> m MarkAttributes
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MarkAttributes -> m MarkAttributes)
-> IO MarkAttributes -> m MarkAttributes
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CString
category' <- Text -> IO CString
textToCString Text
category
    Ptr MarkAttributes
result <- Ptr View -> CString -> Int32 -> IO (Ptr MarkAttributes)
gtk_source_view_get_mark_attributes Ptr View
view' CString
category' Int32
priority
    Text -> Ptr MarkAttributes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewGetMarkAttributes" Ptr MarkAttributes
result
    MarkAttributes
result' <- ((ManagedPtr MarkAttributes -> MarkAttributes)
-> Ptr MarkAttributes -> IO MarkAttributes
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr MarkAttributes -> MarkAttributes
GtkSource.MarkAttributes.MarkAttributes) Ptr MarkAttributes
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
category'
    MarkAttributes -> IO MarkAttributes
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MarkAttributes
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetMarkAttributesMethodInfo
instance (signature ~ (T.Text -> Int32 -> m GtkSource.MarkAttributes.MarkAttributes), MonadIO m, IsView a) => O.OverloadedMethod ViewGetMarkAttributesMethodInfo a signature where
    overloadedMethod = viewGetMarkAttributes

instance O.OverloadedMethodInfo ViewGetMarkAttributesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetMarkAttributes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetMarkAttributes"
        })


#endif

-- method View::get_right_margin_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_right_margin_position" gtk_source_view_get_right_margin_position :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO Word32

-- | Gets the position of the right margin in the given /@view@/.
viewGetRightMarginPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Word32
    -- ^ __Returns:__ the position of the right margin.
viewGetRightMarginPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Word32
viewGetRightMarginPosition a
view = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Word32
result <- Ptr View -> IO Word32
gtk_source_view_get_right_margin_position Ptr View
view'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ViewGetRightMarginPositionMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsView a) => O.OverloadedMethod ViewGetRightMarginPositionMethodInfo a signature where
    overloadedMethod = viewGetRightMarginPosition

instance O.OverloadedMethodInfo ViewGetRightMarginPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetRightMarginPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetRightMarginPosition"
        })


#endif

-- method View::get_show_line_marks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_show_line_marks" gtk_source_view_get_show_line_marks :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether line marks are displayed beside the text.
viewGetShowLineMarks ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the line marks are displayed.
viewGetShowLineMarks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetShowLineMarks a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_show_line_marks Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetShowLineMarksMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetShowLineMarksMethodInfo a signature where
    overloadedMethod = viewGetShowLineMarks

instance O.OverloadedMethodInfo ViewGetShowLineMarksMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetShowLineMarks",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetShowLineMarks"
        })


#endif

-- method View::get_show_line_numbers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_show_line_numbers" gtk_source_view_get_show_line_numbers :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether line numbers are displayed beside the text.
viewGetShowLineNumbers ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the line numbers are displayed.
viewGetShowLineNumbers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetShowLineNumbers a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_show_line_numbers Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetShowLineNumbersMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetShowLineNumbersMethodInfo a signature where
    overloadedMethod = viewGetShowLineNumbers

instance O.OverloadedMethodInfo ViewGetShowLineNumbersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetShowLineNumbers",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetShowLineNumbers"
        })


#endif

-- method View::get_show_right_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_show_right_margin" gtk_source_view_get_show_right_margin :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns whether a right margin is displayed.
viewGetShowRightMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the right margin is shown.
viewGetShowRightMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetShowRightMargin a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_show_right_margin Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetShowRightMarginMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetShowRightMarginMethodInfo a signature where
    overloadedMethod = viewGetShowRightMargin

instance O.OverloadedMethodInfo ViewGetShowRightMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetShowRightMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetShowRightMargin"
        })


#endif

-- method View::get_smart_backspace
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_smart_backspace" gtk_source_view_get_smart_backspace :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CInt

-- | Returns 'P.True' if pressing the Backspace key will try to delete spaces
-- up to the previous tab stop.
viewGetSmartBackspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Bool
    -- ^ __Returns:__ 'P.True' if smart Backspace handling is enabled.
viewGetSmartBackspace :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Bool
viewGetSmartBackspace a
view = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CInt
result <- Ptr View -> IO CInt
gtk_source_view_get_smart_backspace Ptr View
view'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetSmartBackspaceMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsView a) => O.OverloadedMethod ViewGetSmartBackspaceMethodInfo a signature where
    overloadedMethod = viewGetSmartBackspace

instance O.OverloadedMethodInfo ViewGetSmartBackspaceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetSmartBackspace",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetSmartBackspace"
        })


#endif

-- method View::get_smart_home_end
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "SmartHomeEndType" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_smart_home_end" gtk_source_view_get_smart_home_end :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO CUInt

-- | Returns a [enum/@smartHomeEndType@/] end value specifying
-- how the cursor will move when HOME and END keys are pressed.
viewGetSmartHomeEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m GtkSource.Enums.SmartHomeEndType
    -- ^ __Returns:__ a t'GI.GtkSource.Enums.SmartHomeEndType' value.
viewGetSmartHomeEnd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m SmartHomeEndType
viewGetSmartHomeEnd a
view = IO SmartHomeEndType -> m SmartHomeEndType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SmartHomeEndType -> m SmartHomeEndType)
-> IO SmartHomeEndType -> m SmartHomeEndType
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CUInt
result <- Ptr View -> IO CUInt
gtk_source_view_get_smart_home_end Ptr View
view'
    let result' :: SmartHomeEndType
result' = (Int -> SmartHomeEndType
forall a. Enum a => Int -> a
toEnum (Int -> SmartHomeEndType)
-> (CUInt -> Int) -> CUInt -> SmartHomeEndType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    SmartHomeEndType -> IO SmartHomeEndType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SmartHomeEndType
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetSmartHomeEndMethodInfo
instance (signature ~ (m GtkSource.Enums.SmartHomeEndType), MonadIO m, IsView a) => O.OverloadedMethod ViewGetSmartHomeEndMethodInfo a signature where
    overloadedMethod = viewGetSmartHomeEnd

instance O.OverloadedMethodInfo ViewGetSmartHomeEndMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetSmartHomeEnd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetSmartHomeEnd"
        })


#endif

-- method View::get_space_drawer
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "GtkSource" , name = "SpaceDrawer" })
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_space_drawer" gtk_source_view_get_space_drawer :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO (Ptr GtkSource.SpaceDrawer.SpaceDrawer)

-- | Gets the [class/@spaceDrawer@/] associated with /@view@/.
-- 
-- The returned object is guaranteed to be the same for the lifetime of /@view@/.
-- Each [class/@view@/] object has a different [class/@spaceDrawer@/].
viewGetSpaceDrawer ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m GtkSource.SpaceDrawer.SpaceDrawer
    -- ^ __Returns:__ the t'GI.GtkSource.Objects.SpaceDrawer.SpaceDrawer' associated with /@view@/.
viewGetSpaceDrawer :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m SpaceDrawer
viewGetSpaceDrawer a
view = IO SpaceDrawer -> m SpaceDrawer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SpaceDrawer -> m SpaceDrawer)
-> IO SpaceDrawer -> m SpaceDrawer
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr SpaceDrawer
result <- Ptr View -> IO (Ptr SpaceDrawer)
gtk_source_view_get_space_drawer Ptr View
view'
    Text -> Ptr SpaceDrawer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"viewGetSpaceDrawer" Ptr SpaceDrawer
result
    SpaceDrawer
result' <- ((ManagedPtr SpaceDrawer -> SpaceDrawer)
-> Ptr SpaceDrawer -> IO SpaceDrawer
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SpaceDrawer -> SpaceDrawer
GtkSource.SpaceDrawer.SpaceDrawer) Ptr SpaceDrawer
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    SpaceDrawer -> IO SpaceDrawer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SpaceDrawer
result'

#if defined(ENABLE_OVERLOADING)
data ViewGetSpaceDrawerMethodInfo
instance (signature ~ (m GtkSource.SpaceDrawer.SpaceDrawer), MonadIO m, IsView a) => O.OverloadedMethod ViewGetSpaceDrawerMethodInfo a signature where
    overloadedMethod = viewGetSpaceDrawer

instance O.OverloadedMethodInfo ViewGetSpaceDrawerMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetSpaceDrawer",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetSpaceDrawer"
        })


#endif

-- method View::get_tab_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_tab_width" gtk_source_view_get_tab_width :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    IO Word32

-- | Returns the width of tabulation in characters.
viewGetTabWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> m Word32
    -- ^ __Returns:__ width of tab.
viewGetTabWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> m Word32
viewGetTabWidth a
view = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Word32
result <- Ptr View -> IO Word32
gtk_source_view_get_tab_width Ptr View
view'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ViewGetTabWidthMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsView a) => O.OverloadedMethod ViewGetTabWidthMethodInfo a signature where
    overloadedMethod = viewGetTabWidth

instance O.OverloadedMethodInfo ViewGetTabWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetTabWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetTabWidth"
        })


#endif

-- method View::get_visual_column
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "iter"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a position in @view."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_get_visual_column" gtk_source_view_get_visual_column :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Ptr Gtk.TextIter.TextIter ->            -- iter : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO Word32

-- | Determines the visual column at /@iter@/ taking into consideration the
-- [property/@view@/:tab-width] of /@view@/.
viewGetVisualColumn ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Gtk.TextIter.TextIter
    -- ^ /@iter@/: a position in /@view@/.
    -> m Word32
    -- ^ __Returns:__ the visual column at /@iter@/.
viewGetVisualColumn :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> TextIter -> m Word32
viewGetVisualColumn a
view TextIter
iter = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr TextIter
iter' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
iter
    Word32
result <- Ptr View -> Ptr TextIter -> IO Word32
gtk_source_view_get_visual_column Ptr View
view' Ptr TextIter
iter'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
iter
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ViewGetVisualColumnMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> m Word32), MonadIO m, IsView a) => O.OverloadedMethod ViewGetVisualColumnMethodInfo a signature where
    overloadedMethod = viewGetVisualColumn

instance O.OverloadedMethodInfo ViewGetVisualColumnMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewGetVisualColumn",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewGetVisualColumn"
        })


#endif

-- method View::indent_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GtkTextIter of the first line to indent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GtkTextIter of the last line to indent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_indent_lines" gtk_source_view_indent_lines :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

-- | Inserts one indentation level at the beginning of the specified lines. The
-- empty lines are not indented.
viewIndentLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: t'GI.Gtk.Structs.TextIter.TextIter' of the first line to indent
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: t'GI.Gtk.Structs.TextIter.TextIter' of the last line to indent
    -> m ()
viewIndentLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> TextIter -> TextIter -> m ()
viewIndentLines a
view TextIter
start TextIter
end = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr TextIter
start' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
start
    Ptr TextIter
end' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
end
    Ptr View -> Ptr TextIter -> Ptr TextIter -> IO ()
gtk_source_view_indent_lines Ptr View
view' Ptr TextIter
start' Ptr TextIter
end'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
start
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
end
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewIndentLinesMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewIndentLinesMethodInfo a signature where
    overloadedMethod = viewIndentLines

instance O.OverloadedMethodInfo ViewIndentLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewIndentLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewIndentLines"
        })


#endif

-- method View::push_snippet
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "snippet"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Snippet" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceSnippet"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "location"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GtkTextIter or %NULL for the cursor position"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_push_snippet" gtk_source_view_push_snippet :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Ptr GtkSource.Snippet.Snippet ->        -- snippet : TInterface (Name {namespace = "GtkSource", name = "Snippet"})
    Ptr Gtk.TextIter.TextIter ->            -- location : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

-- | Inserts a new snippet at /@location@/
-- 
-- If another snippet was already active, it will be paused and the new
-- snippet will become active. Once the focus positions of /@snippet@/ have
-- been exhausted, editing will return to the previous snippet.
viewPushSnippet ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a, GtkSource.Snippet.IsSnippet b) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'
    -> b
    -- ^ /@snippet@/: a t'GI.GtkSource.Objects.Snippet.Snippet'
    -> Maybe (Gtk.TextIter.TextIter)
    -- ^ /@location@/: a t'GI.Gtk.Structs.TextIter.TextIter' or 'P.Nothing' for the cursor position
    -> m ()
viewPushSnippet :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsView a, IsSnippet b) =>
a -> b -> Maybe TextIter -> m ()
viewPushSnippet a
view b
snippet Maybe TextIter
location = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr Snippet
snippet' <- b -> IO (Ptr Snippet)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
snippet
    Ptr TextIter
maybeLocation <- case Maybe TextIter
location of
        Maybe TextIter
Nothing -> Ptr TextIter -> IO (Ptr TextIter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TextIter
forall a. Ptr a
nullPtr
        Just TextIter
jLocation -> do
            Ptr TextIter
jLocation' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
jLocation
            Ptr TextIter -> IO (Ptr TextIter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr TextIter
jLocation'
    Ptr View -> Ptr Snippet -> Ptr TextIter -> IO ()
gtk_source_view_push_snippet Ptr View
view' Ptr Snippet
snippet' Ptr TextIter
maybeLocation
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
snippet
    Maybe TextIter -> (TextIter -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe TextIter
location TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewPushSnippetMethodInfo
instance (signature ~ (b -> Maybe (Gtk.TextIter.TextIter) -> m ()), MonadIO m, IsView a, GtkSource.Snippet.IsSnippet b) => O.OverloadedMethod ViewPushSnippetMethodInfo a signature where
    overloadedMethod = viewPushSnippet

instance O.OverloadedMethodInfo ViewPushSnippetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewPushSnippet",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewPushSnippet"
        })


#endif

-- method View::set_auto_indent
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable auto indentation."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_auto_indent" gtk_source_view_set_auto_indent :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- enable : TBasicType TBoolean
    IO ()

-- | If 'P.True' auto-indentation of text is enabled.
-- 
-- When Enter is pressed to create a new line, the auto-indentation inserts the
-- same indentation as the previous line. This is **not** a
-- \"smart indentation\" where an indentation level is added or removed depending
-- on the context.
viewSetAutoIndent ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@enable@/: whether to enable auto indentation.
    -> m ()
viewSetAutoIndent :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetAutoIndent a
view Bool
enable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enable
    Ptr View -> CInt -> IO ()
gtk_source_view_set_auto_indent Ptr View
view' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetAutoIndentMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetAutoIndentMethodInfo a signature where
    overloadedMethod = viewSetAutoIndent

instance O.OverloadedMethodInfo ViewSetAutoIndentMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetAutoIndent",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetAutoIndent"
        })


#endif

-- method View::set_background_pattern
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "background_pattern"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "BackgroundPatternType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GtkSourceBackgroundPatternType."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_background_pattern" gtk_source_view_set_background_pattern :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CUInt ->                                -- background_pattern : TInterface (Name {namespace = "GtkSource", name = "BackgroundPatternType"})
    IO ()

-- | Set if and how the background pattern should be displayed.
viewSetBackgroundPattern ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> GtkSource.Enums.BackgroundPatternType
    -- ^ /@backgroundPattern@/: the t'GI.GtkSource.Enums.BackgroundPatternType'.
    -> m ()
viewSetBackgroundPattern :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> BackgroundPatternType -> m ()
viewSetBackgroundPattern a
view BackgroundPatternType
backgroundPattern = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let backgroundPattern' :: CUInt
backgroundPattern' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (BackgroundPatternType -> Int) -> BackgroundPatternType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BackgroundPatternType -> Int
forall a. Enum a => a -> Int
fromEnum) BackgroundPatternType
backgroundPattern
    Ptr View -> CUInt -> IO ()
gtk_source_view_set_background_pattern Ptr View
view' CUInt
backgroundPattern'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetBackgroundPatternMethodInfo
instance (signature ~ (GtkSource.Enums.BackgroundPatternType -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetBackgroundPatternMethodInfo a signature where
    overloadedMethod = viewSetBackgroundPattern

instance O.OverloadedMethodInfo ViewSetBackgroundPatternMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetBackgroundPattern",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetBackgroundPattern"
        })


#endif

-- method View::set_enable_snippets
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable_snippets"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "if snippets should be enabled"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_enable_snippets" gtk_source_view_set_enable_snippets :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- enable_snippets : TBasicType TBoolean
    IO ()

-- | Sets the [property/@view@/:enable-snippets] property.
-- 
-- If /@enableSnippets@/ is 'P.True', matching snippets found in the
-- [class/@snippetManager@/] may be expanded when the user presses
-- Tab after a word in the [class/@view@/].
viewSetEnableSnippets ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'
    -> Bool
    -- ^ /@enableSnippets@/: if snippets should be enabled
    -> m ()
viewSetEnableSnippets :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetEnableSnippets a
view Bool
enableSnippets = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let enableSnippets' :: CInt
enableSnippets' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enableSnippets
    Ptr View -> CInt -> IO ()
gtk_source_view_set_enable_snippets Ptr View
view' CInt
enableSnippets'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetEnableSnippetsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetEnableSnippetsMethodInfo a signature where
    overloadedMethod = viewSetEnableSnippets

instance O.OverloadedMethodInfo ViewSetEnableSnippetsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetEnableSnippets",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetEnableSnippets"
        })


#endif

-- method View::set_highlight_current_line
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "highlight"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to highlight the current line."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_highlight_current_line" gtk_source_view_set_highlight_current_line :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- highlight : TBasicType TBoolean
    IO ()

-- | If /@highlight@/ is 'P.True' the current line will be highlighted.
viewSetHighlightCurrentLine ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@highlight@/: whether to highlight the current line.
    -> m ()
viewSetHighlightCurrentLine :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetHighlightCurrentLine a
view Bool
highlight = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let highlight' :: CInt
highlight' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
highlight
    Ptr View -> CInt -> IO ()
gtk_source_view_set_highlight_current_line Ptr View
view' CInt
highlight'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetHighlightCurrentLineMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetHighlightCurrentLineMethodInfo a signature where
    overloadedMethod = viewSetHighlightCurrentLine

instance O.OverloadedMethodInfo ViewSetHighlightCurrentLineMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetHighlightCurrentLine",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetHighlightCurrentLine"
        })


#endif

-- method View::set_indent_on_tab
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "whether to indent a block when tab is pressed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_indent_on_tab" gtk_source_view_set_indent_on_tab :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- enable : TBasicType TBoolean
    IO ()

-- | If 'P.True', when the tab key is pressed when several lines are selected, the
-- selected lines are indented of one level instead of being replaced with a @\\t@
-- character. Shift+Tab unindents the selection.
-- 
-- If the first or last line is not selected completely, it is also indented or
-- unindented.
-- 
-- When the selection doesn\'t span several lines, the tab key always replaces
-- the selection with a normal @\\t@ character.
viewSetIndentOnTab ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@enable@/: whether to indent a block when tab is pressed.
    -> m ()
viewSetIndentOnTab :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetIndentOnTab a
view Bool
enable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enable
    Ptr View -> CInt -> IO ()
gtk_source_view_set_indent_on_tab Ptr View
view' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetIndentOnTabMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetIndentOnTabMethodInfo a signature where
    overloadedMethod = viewSetIndentOnTab

instance O.OverloadedMethodInfo ViewSetIndentOnTabMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetIndentOnTab",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetIndentOnTab"
        })


#endif

-- method View::set_indent_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "indent width in characters."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_indent_width" gtk_source_view_set_indent_width :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Int32 ->                                -- width : TBasicType TInt
    IO ()

-- | Sets the number of spaces to use for each step of indent when the tab key is
-- pressed.
-- 
-- If /@width@/ is -1, the value of the [property/@view@/:tab-width] property
-- will be used.
-- 
-- The [property/@view@/:indent-width] interacts with the
-- [property/@view@/:insert-spaces-instead-of-tabs] property and
-- [property/@view@/:tab-width]. An example will be clearer:
-- 
-- If the [property/@view@/:indent-width] is 4 and [property/@view@/:tab-width] is 8 and
-- [property/@view@/:insert-spaces-instead-of-tabs] is 'P.False', then pressing the tab
-- key at the beginning of a line will insert 4 spaces. So far so good. Pressing
-- the tab key a second time will remove the 4 spaces and insert a @\\t@ character
-- instead (since [property/@view@/:tab-width] is 8). On the other hand, if
-- [property/@view@/:insert-spaces-instead-of-tabs] is 'P.True', the second tab key
-- pressed will insert 4 more spaces for a total of 8 spaces in the
-- t'GI.Gtk.Objects.TextBuffer.TextBuffer'.
-- 
-- The test-widget program (available in the GtkSourceView repository) may be
-- useful to better understand the indentation settings (enable the space
-- drawing!).
viewSetIndentWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Int32
    -- ^ /@width@/: indent width in characters.
    -> m ()
viewSetIndentWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Int32 -> m ()
viewSetIndentWidth a
view Int32
width = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr View -> ViewChangeNumberCallback
gtk_source_view_set_indent_width Ptr View
view' Int32
width
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetIndentWidthMethodInfo
instance (signature ~ (Int32 -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetIndentWidthMethodInfo a signature where
    overloadedMethod = viewSetIndentWidth

instance O.OverloadedMethodInfo ViewSetIndentWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetIndentWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetIndentWidth"
        })


#endif

-- method View::set_indenter
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "indenter"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "Indenter" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceIndenter or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_indenter" gtk_source_view_set_indenter :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Ptr GtkSource.Indenter.Indenter ->      -- indenter : TInterface (Name {namespace = "GtkSource", name = "Indenter"})
    IO ()

-- | Sets the indenter for /@view@/ to /@indenter@/.
-- 
-- Note that the indenter will not be used unless [View:autoIndent]("GI.GtkSource.Objects.View#g:attr:autoIndent")
-- has been set to 'P.True'.
viewSetIndenter ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a, GtkSource.Indenter.IsIndenter b) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'
    -> Maybe (b)
    -- ^ /@indenter@/: a t'GI.GtkSource.Interfaces.Indenter.Indenter' or 'P.Nothing'
    -> m ()
viewSetIndenter :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsView a, IsIndenter b) =>
a -> Maybe b -> m ()
viewSetIndenter a
view Maybe b
indenter = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr Indenter
maybeIndenter <- case Maybe b
indenter of
        Maybe b
Nothing -> Ptr Indenter -> IO (Ptr Indenter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Indenter
forall a. Ptr a
nullPtr
        Just b
jIndenter -> do
            Ptr Indenter
jIndenter' <- b -> IO (Ptr Indenter)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jIndenter
            Ptr Indenter -> IO (Ptr Indenter)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Indenter
jIndenter'
    Ptr View -> Ptr Indenter -> IO ()
gtk_source_view_set_indenter Ptr View
view' Ptr Indenter
maybeIndenter
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
indenter b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetIndenterMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsView a, GtkSource.Indenter.IsIndenter b) => O.OverloadedMethod ViewSetIndenterMethodInfo a signature where
    overloadedMethod = viewSetIndenter

instance O.OverloadedMethodInfo ViewSetIndenterMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetIndenter",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetIndenter"
        })


#endif

-- method View::set_insert_spaces_instead_of_tabs
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "enable"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to insert spaces instead of tabs."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_insert_spaces_instead_of_tabs" gtk_source_view_set_insert_spaces_instead_of_tabs :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- enable : TBasicType TBoolean
    IO ()

-- | If 'P.True' a tab key pressed is replaced by a group of space characters.
-- 
-- Of course it is still possible to insert a real @\\t@ programmatically with the
-- t'GI.Gtk.Objects.TextBuffer.TextBuffer' API.
viewSetInsertSpacesInsteadOfTabs ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@enable@/: whether to insert spaces instead of tabs.
    -> m ()
viewSetInsertSpacesInsteadOfTabs :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetInsertSpacesInsteadOfTabs a
view Bool
enable = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let enable' :: CInt
enable' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
enable
    Ptr View -> CInt -> IO ()
gtk_source_view_set_insert_spaces_instead_of_tabs Ptr View
view' CInt
enable'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetInsertSpacesInsteadOfTabsMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetInsertSpacesInsteadOfTabsMethodInfo a signature where
    overloadedMethod = viewSetInsertSpacesInsteadOfTabs

instance O.OverloadedMethodInfo ViewSetInsertSpacesInsteadOfTabsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetInsertSpacesInsteadOfTabs",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetInsertSpacesInsteadOfTabs"
        })


#endif

-- method View::set_mark_attributes
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "category"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the category." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "attributes"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "MarkAttributes" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "mark attributes." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "priority of the category."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_mark_attributes" gtk_source_view_set_mark_attributes :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CString ->                              -- category : TBasicType TUTF8
    Ptr GtkSource.MarkAttributes.MarkAttributes -> -- attributes : TInterface (Name {namespace = "GtkSource", name = "MarkAttributes"})
    Int32 ->                                -- priority : TBasicType TInt
    IO ()

-- | Sets attributes and priority for the /@category@/.
viewSetMarkAttributes ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a, GtkSource.MarkAttributes.IsMarkAttributes b) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> T.Text
    -- ^ /@category@/: the category.
    -> b
    -- ^ /@attributes@/: mark attributes.
    -> Int32
    -- ^ /@priority@/: priority of the category.
    -> m ()
viewSetMarkAttributes :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsView a, IsMarkAttributes b) =>
a -> Text -> b -> Int32 -> m ()
viewSetMarkAttributes a
view Text
category b
attributes Int32
priority = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    CString
category' <- Text -> IO CString
textToCString Text
category
    Ptr MarkAttributes
attributes' <- b -> IO (Ptr MarkAttributes)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
attributes
    Ptr View
-> CString -> Ptr MarkAttributes -> ViewChangeNumberCallback
gtk_source_view_set_mark_attributes Ptr View
view' CString
category' Ptr MarkAttributes
attributes' Int32
priority
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
attributes
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
category'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetMarkAttributesMethodInfo
instance (signature ~ (T.Text -> b -> Int32 -> m ()), MonadIO m, IsView a, GtkSource.MarkAttributes.IsMarkAttributes b) => O.OverloadedMethod ViewSetMarkAttributesMethodInfo a signature where
    overloadedMethod = viewSetMarkAttributes

instance O.OverloadedMethodInfo ViewSetMarkAttributesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetMarkAttributes",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetMarkAttributes"
        })


#endif

-- method View::set_right_margin_position
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "pos"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the width in characters where to position the right margin."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_right_margin_position" gtk_source_view_set_right_margin_position :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Word32 ->                               -- pos : TBasicType TUInt
    IO ()

-- | Sets the position of the right margin in the given /@view@/.
viewSetRightMarginPosition ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Word32
    -- ^ /@pos@/: the width in characters where to position the right margin.
    -> m ()
viewSetRightMarginPosition :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Word32 -> m ()
viewSetRightMarginPosition a
view Word32
pos = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr View -> Word32 -> IO ()
gtk_source_view_set_right_margin_position Ptr View
view' Word32
pos
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetRightMarginPositionMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetRightMarginPositionMethodInfo a signature where
    overloadedMethod = viewSetRightMarginPosition

instance O.OverloadedMethodInfo ViewSetRightMarginPositionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetRightMarginPosition",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetRightMarginPosition"
        })


#endif

-- method View::set_show_line_marks
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether line marks should be displayed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_show_line_marks" gtk_source_view_set_show_line_marks :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- show : TBasicType TBoolean
    IO ()

-- | If 'P.True' line marks will be displayed beside the text.
viewSetShowLineMarks ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@show@/: whether line marks should be displayed.
    -> m ()
viewSetShowLineMarks :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetShowLineMarks a
view Bool
show_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let show_' :: CInt
show_' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
show_
    Ptr View -> CInt -> IO ()
gtk_source_view_set_show_line_marks Ptr View
view' CInt
show_'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetShowLineMarksMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetShowLineMarksMethodInfo a signature where
    overloadedMethod = viewSetShowLineMarks

instance O.OverloadedMethodInfo ViewSetShowLineMarksMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetShowLineMarks",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetShowLineMarks"
        })


#endif

-- method View::set_show_line_numbers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether line numbers should be displayed."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_show_line_numbers" gtk_source_view_set_show_line_numbers :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- show : TBasicType TBoolean
    IO ()

-- | If 'P.True' line numbers will be displayed beside the text.
viewSetShowLineNumbers ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@show@/: whether line numbers should be displayed.
    -> m ()
viewSetShowLineNumbers :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetShowLineNumbers a
view Bool
show_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let show_' :: CInt
show_' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
show_
    Ptr View -> CInt -> IO ()
gtk_source_view_set_show_line_numbers Ptr View
view' CInt
show_'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetShowLineNumbersMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetShowLineNumbersMethodInfo a signature where
    overloadedMethod = viewSetShowLineNumbers

instance O.OverloadedMethodInfo ViewSetShowLineNumbersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetShowLineNumbers",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetShowLineNumbers"
        })


#endif

-- method View::set_show_right_margin
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "show"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to show a right margin."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_show_right_margin" gtk_source_view_set_show_right_margin :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- show : TBasicType TBoolean
    IO ()

-- | If 'P.True' a right margin is displayed.
viewSetShowRightMargin ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@show@/: whether to show a right margin.
    -> m ()
viewSetShowRightMargin :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetShowRightMargin a
view Bool
show_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let show_' :: CInt
show_' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
show_
    Ptr View -> CInt -> IO ()
gtk_source_view_set_show_right_margin Ptr View
view' CInt
show_'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetShowRightMarginMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetShowRightMarginMethodInfo a signature where
    overloadedMethod = viewSetShowRightMargin

instance O.OverloadedMethodInfo ViewSetShowRightMarginMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetShowRightMargin",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetShowRightMargin"
        })


#endif

-- method View::set_smart_backspace
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "smart_backspace"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "whether to enable smart Backspace handling."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_smart_backspace" gtk_source_view_set_smart_backspace :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CInt ->                                 -- smart_backspace : TBasicType TBoolean
    IO ()

-- | When set to 'P.True', pressing the Backspace key will try to delete spaces
-- up to the previous tab stop.
viewSetSmartBackspace ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Bool
    -- ^ /@smartBackspace@/: whether to enable smart Backspace handling.
    -> m ()
viewSetSmartBackspace :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Bool -> m ()
viewSetSmartBackspace a
view Bool
smartBackspace = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let smartBackspace' :: CInt
smartBackspace' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
smartBackspace
    Ptr View -> CInt -> IO ()
gtk_source_view_set_smart_backspace Ptr View
view' CInt
smartBackspace'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetSmartBackspaceMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetSmartBackspaceMethodInfo a signature where
    overloadedMethod = viewSetSmartBackspace

instance O.OverloadedMethodInfo ViewSetSmartBackspaceMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetSmartBackspace",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetSmartBackspace"
        })


#endif

-- method View::set_smart_home_end
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "smart_home_end"
--           , argType =
--               TInterface
--                 Name { namespace = "GtkSource" , name = "SmartHomeEndType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the desired behavior among #GtkSourceSmartHomeEndType."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_smart_home_end" gtk_source_view_set_smart_home_end :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    CUInt ->                                -- smart_home_end : TInterface (Name {namespace = "GtkSource", name = "SmartHomeEndType"})
    IO ()

-- | Set the desired movement of the cursor when HOME and END keys
-- are pressed.
viewSetSmartHomeEnd ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> GtkSource.Enums.SmartHomeEndType
    -- ^ /@smartHomeEnd@/: the desired behavior among t'GI.GtkSource.Enums.SmartHomeEndType'.
    -> m ()
viewSetSmartHomeEnd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> SmartHomeEndType -> m ()
viewSetSmartHomeEnd a
view SmartHomeEndType
smartHomeEnd = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    let smartHomeEnd' :: CUInt
smartHomeEnd' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (SmartHomeEndType -> Int) -> SmartHomeEndType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SmartHomeEndType -> Int
forall a. Enum a => a -> Int
fromEnum) SmartHomeEndType
smartHomeEnd
    Ptr View -> CUInt -> IO ()
gtk_source_view_set_smart_home_end Ptr View
view' CUInt
smartHomeEnd'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetSmartHomeEndMethodInfo
instance (signature ~ (GtkSource.Enums.SmartHomeEndType -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetSmartHomeEndMethodInfo a signature where
    overloadedMethod = viewSetSmartHomeEnd

instance O.OverloadedMethodInfo ViewSetSmartHomeEndMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetSmartHomeEnd",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetSmartHomeEnd"
        })


#endif

-- method View::set_tab_width
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "width"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "width of tab in characters."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_set_tab_width" gtk_source_view_set_tab_width :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Word32 ->                               -- width : TBasicType TUInt
    IO ()

-- | Sets the width of tabulation in characters.
-- 
-- The t'GI.Gtk.Objects.TextBuffer.TextBuffer' still contains @\\t@ characters,
-- but they can take a different visual width in a [class/@view@/] widget.
viewSetTabWidth ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Word32
    -- ^ /@width@/: width of tab in characters.
    -> m ()
viewSetTabWidth :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> Word32 -> m ()
viewSetTabWidth a
view Word32
width = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr View -> Word32 -> IO ()
gtk_source_view_set_tab_width Ptr View
view' Word32
width
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewSetTabWidthMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewSetTabWidthMethodInfo a signature where
    overloadedMethod = viewSetTabWidth

instance O.OverloadedMethodInfo ViewSetTabWidthMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewSetTabWidth",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewSetTabWidth"
        })


#endif

-- method View::unindent_lines
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "view"
--           , argType =
--               TInterface Name { namespace = "GtkSource" , name = "View" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GtkSourceView." , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GtkTextIter of the first line to indent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType =
--               TInterface Name { namespace = "Gtk" , name = "TextIter" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "#GtkTextIter of the last line to indent"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , argCallbackUserData = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "gtk_source_view_unindent_lines" gtk_source_view_unindent_lines :: 
    Ptr View ->                             -- view : TInterface (Name {namespace = "GtkSource", name = "View"})
    Ptr Gtk.TextIter.TextIter ->            -- start : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    Ptr Gtk.TextIter.TextIter ->            -- end : TInterface (Name {namespace = "Gtk", name = "TextIter"})
    IO ()

-- | Removes one indentation level at the beginning of the
-- specified lines.
viewUnindentLines ::
    (B.CallStack.HasCallStack, MonadIO m, IsView a) =>
    a
    -- ^ /@view@/: a t'GI.GtkSource.Objects.View.View'.
    -> Gtk.TextIter.TextIter
    -- ^ /@start@/: t'GI.Gtk.Structs.TextIter.TextIter' of the first line to indent
    -> Gtk.TextIter.TextIter
    -- ^ /@end@/: t'GI.Gtk.Structs.TextIter.TextIter' of the last line to indent
    -> m ()
viewUnindentLines :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsView a) =>
a -> TextIter -> TextIter -> m ()
viewUnindentLines a
view TextIter
start TextIter
end = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr View
view' <- a -> IO (Ptr View)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
view
    Ptr TextIter
start' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
start
    Ptr TextIter
end' <- TextIter -> IO (Ptr TextIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr TextIter
end
    Ptr View -> Ptr TextIter -> Ptr TextIter -> IO ()
gtk_source_view_unindent_lines Ptr View
view' Ptr TextIter
start' Ptr TextIter
end'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
view
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
start
    TextIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr TextIter
end
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ViewUnindentLinesMethodInfo
instance (signature ~ (Gtk.TextIter.TextIter -> Gtk.TextIter.TextIter -> m ()), MonadIO m, IsView a) => O.OverloadedMethod ViewUnindentLinesMethodInfo a signature where
    overloadedMethod = viewUnindentLines

instance O.OverloadedMethodInfo ViewUnindentLinesMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.GtkSource.Objects.View.viewUnindentLines",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gtksource-5.0.0/docs/GI-GtkSource-Objects-View.html#v:viewUnindentLines"
        })


#endif