{-# LANGUAGE CPP #-}
-- -*-haskell-*-
--  GIMP Toolkit (GTK) Widget Entry
--
--  Author : Axel Simon, Andy Stewart
--
--  Created: 23 May 2001
--
--  Copyright (C) 1999-2005 Axel Simon
--  Copyright (C) 2010 Andy Stewart
--
--  This library is free software; you can redistribute it and/or
--  modify it under the terms of the GNU Lesser General Public
--  License as published by the Free Software Foundation; either
--  version 2.1 of the License, or (at your option) any later version.
--
--  This library is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--  Lesser General Public License for more details.
--
-- |
-- Maintainer  : gtk2hs-users@lists.sourceforge.net
-- Stability   : provisional
-- Portability : portable (depends on GHC)
--
-- A single line text entry field
--
module Graphics.UI.Gtk.Entry.Entry (
-- * Detail
--
-- | The 'Entry' widget is a single line text entry widget. A fairly large set
-- of key bindings are supported by default. If the entered text is longer than
-- the allocation of the widget, the widget will scroll so that the cursor
-- position is visible.

-- * Class Hierarchy
-- |
-- @
-- |  'GObject'
-- |   +----'Object'
-- |         +----'Widget'
-- |               +----Entry
-- |                     +----'SpinButton'
-- @

-- * Types
  Entry,
  EntryClass,
  castToEntry, gTypeEntry,
  toEntry,

-- * Constructors
  entryNew,
#if GTK_CHECK_VERSION(2,18,0)
  entryNewWithBuffer,
#endif

-- * Methods
  entrySetText,
  entryGetText,
#if GTK_MAJOR_VERSION < 3
#ifndef DISABLE_DEPRECATED
  entryAppendText,
  entryPrependText,
#endif
#endif
  entrySetVisibility,
  entryGetVisibility,
  entrySetInvisibleChar,
  entryGetInvisibleChar,
  entrySetMaxLength,
  entryGetMaxLength,
  entryGetActivatesDefault,
  entrySetActivatesDefault,
  entryGetHasFrame,
  entrySetHasFrame,
  entryGetWidthChars,
  entrySetWidthChars,
#if GTK_CHECK_VERSION(3,2,0)
  entrySetPlaceholderText,
  entryGetPlaceholderText,
#endif
#if GTK_CHECK_VERSION(2,4,0)
  entrySetAlignment,
  entryGetAlignment,
  entrySetCompletion,
  entryGetCompletion,
#endif
#if GTK_CHECK_VERSION (2,18,0)
  entryGetBuffer,
  entrySetBuffer,
#endif
#if GTK_MAJOR_VERSION < 3
#if GTK_CHECK_VERSION(2,20,0)
  entryGetIconWindow,
  entryGetTextWindow,
#endif
#endif
#if GTK_CHECK_VERSION(2,22,0)
  entryImContextFilterKeypress,
  entryResetImContext,
#endif

-- * Attributes
  entryCursorPosition,
  entrySelectionBound,
  entryEditable,
  entryMaxLength,
  entryVisibility,
  entryHasFrame,
  entryInvisibleChar,
  entryActivatesDefault,
  entryWidthChars,
  entryScrollOffset,
  entryText,
#if GTK_CHECK_VERSION(3,2,0)
  entryPlaceholderText,
#endif
#if GTK_CHECK_VERSION(2,4,0)
  entryXalign,
  entryAlignment,
  entryCompletion,
#endif
#if GTK_CHECK_VERSION (2,18,0)
  entryBuffer,
#endif

-- * Signals
  entryActivated,
  entryActivate,
  entryBackspace,
  entryCopyClipboard,
  entryCutClipboard,
  entryPasteClipboard,
  entryDeleteFromCursor,
  entryInsertAtCursor,
  entryMoveCursor,
  entryPopulatePopup,
  entryToggleOverwirte,
  entryToggleOverwrite,
#if GTK_CHECK_VERSION(2,20,0)
  entryPreeditChanged,
#endif
#if GTK_CHECK_VERSION(2,16,0)
  entryIconPress,
  entryIconRelease,
#endif

-- * Deprecated
#ifndef DISABLE_DEPRECATED
  onEntryActivate,
  afterEntryActivate,
  onCopyClipboard,
  afterCopyClipboard,
  onCutClipboard,
  afterCutClipboard,
  onPasteClipboard,
  afterPasteClipboard,
  onToggleOverwrite,
  afterToggleOverwrite,
#endif
  ) where

import Control.Monad    (liftM)
import Control.Monad.Reader (runReaderT)
import Data.Char        (ord, chr)

import System.Glib.FFI
import System.Glib.UTFString
import System.Glib.Attributes
import System.Glib.Properties
import Graphics.UI.Gtk.Abstract.Object  (makeNewObject)
import Graphics.UI.Gtk.General.Enums (DeleteType (..), MovementStep (..)
#if GTK_CHECK_VERSION(2,16,0)
  , EntryIconPosition (..)
#endif
  )
import Graphics.UI.Gtk.Gdk.EventM       (EventM, EButton, EKey)
import Control.Monad.Reader             ( ask )
import Control.Monad.Trans              ( liftIO )
#if GTK_CHECK_VERSION (2,18,0)
import Graphics.UI.Gtk.Entry.EntryBuffer
#endif
{#import Graphics.UI.Gtk.Types#}
{#import Graphics.UI.Gtk.Signals#}

{# context lib="gtk" prefix="gtk" #}

--------------------
-- Interfaces

instance EditableClass Entry

--------------------
-- Constructors

-- | Creates a new 'Entry' widget.
--
entryNew :: IO Entry
entryNew =
  makeNewObject mkEntry $
  liftM (castPtr :: Ptr Widget -> Ptr Entry) $
  {# call unsafe entry_new #}

#if GTK_CHECK_VERSION(2,18,0)
-- | Creates a new 'Entry' widget backed by a particular 'EntryBuffer'. One
-- buffer can be shared among many widgets.
--
entryNewWithBuffer :: EntryBufferClass buffer => buffer -> IO Entry
entryNewWithBuffer buffer =
  makeNewObject mkEntry $
  liftM (castPtr :: Ptr Widget -> Ptr Entry) $
  {# call unsafe entry_new_with_buffer #}
    (toEntryBuffer buffer)

--------------------
-- Methods

-- Although the documentation doesn't say one way or the other, a look at the
-- source indicates that gtk_entry_get_buffer doesn't increment the reference
-- count of the GtkEntryBuffer it returns, so, like textViewGetBuffer, we must
-- increment it ourselves.

-- | Get the 'EntryBuffer' object which holds the text for this widget.
entryGetBuffer :: EntryClass self => self
  -> IO EntryBuffer
entryGetBuffer self =
  makeNewGObject mkEntryBuffer $
  {# call gtk_entry_get_buffer #}
    (toEntry self)

-- | Set the 'EntryBuffer' object which holds the text for this widget.
entrySetBuffer :: (EntryClass self, EntryBufferClass buffer) => self
  -> buffer -> IO ()
entrySetBuffer self =
  {# call gtk_entry_set_buffer #}
    (toEntry self) . toEntryBuffer
#endif

-- | Sets the text in the widget to the given value, replacing the current
-- contents.
--
entrySetText :: (EntryClass self, GlibString string) => self -> string -> IO ()
entrySetText self text =
  withUTFString text $ \textPtr ->
  {# call entry_set_text #}
    (toEntry self)
    textPtr

-- | Retrieves the contents of the entry widget.
-- See also 'Graphics.UI.Gtk.Display.Entry.Editable.editableGetChars'.
--
entryGetText :: (EntryClass self, GlibString string) => self -> IO string
entryGetText self =
  {# call entry_get_text #}
    (toEntry self)
  >>= peekUTFString
#if GTK_MAJOR_VERSION < 3
#ifndef DISABLE_DEPRECATED
-- | Appends the given text to the contents of the widget.
--
-- * Warning: this function is deprecated and should not be used in
-- newly-written code.
--
-- Removed in Gtk3.
entryAppendText :: (EntryClass self, GlibString string) => self -> string -> IO ()
entryAppendText self text =
  withUTFString text $ \textPtr ->
  {# call entry_append_text #}
    (toEntry self)
    textPtr

-- | Prepends the given text to the contents of the widget.
--
-- * Warning: this function is deprecated and should not be used in
-- newly-written code.
--
-- Removed in Gtk3.
entryPrependText :: (EntryClass self, GlibString string) => self -> string -> IO ()
entryPrependText self text =
  withUTFString text $ \textPtr ->
  {# call entry_prepend_text #}
    (toEntry self)
    textPtr
#endif
#endif

-- | Sets whether the contents of the entry are visible or not. When
-- visibility is set to @False@, characters are displayed as the invisible
-- char, and will also appear that way when the text in the entry widget is
-- copied elsewhere.
--
-- The default invisible char is the asterisk \'*\', but it can be changed
-- with 'entrySetInvisibleChar'.
--
entrySetVisibility :: EntryClass self => self
 -> Bool  -- ^ @visible@ - @True@ if the contents of the entry are displayed
          -- as plaintext.
 -> IO ()
entrySetVisibility self visible =
  {# call entry_set_visibility #}
    (toEntry self)
    (fromBool visible)

-- | Retrieves whether the text in @entry@ is visible. See
-- 'entrySetVisibility'.
--
entryGetVisibility :: EntryClass self => self
 -> IO Bool -- ^ returns @True@ if the text is currently visible
entryGetVisibility self =
  liftM toBool $
  {# call entry_get_visibility #}
    (toEntry self)

-- | Sets the character to use in place of the actual text when
-- 'entrySetVisibility' has been called to set text visibility to @False@. i.e.
-- this is the character used in \"password mode\" to show the user how many
-- characters have been typed. The default invisible char is an asterisk
-- (\'*\'). If you set the invisible char to @\'\\0\'@, then the user will get
-- no feedback at all; there will be no text on the screen as they type.
--
entrySetInvisibleChar :: EntryClass self => self -> Char -> IO ()
entrySetInvisibleChar self ch =
  {# call unsafe entry_set_invisible_char #}
    (toEntry self)
    ((fromIntegral . ord) ch)

-- | Retrieves the character displayed in place of the real characters for
-- entries with visisbility set to false. See 'entrySetInvisibleChar'.
--
entryGetInvisibleChar :: EntryClass self => self
 -> IO Char -- ^ returns the current invisible char, or @\'\\0\'@, if the
            -- entry does not show invisible text at all.
entryGetInvisibleChar self =
  liftM (chr . fromIntegral) $
  {# call unsafe entry_get_invisible_char #}
    (toEntry self)

-- | Sets the maximum allowed length of the contents of the widget. If the
-- current contents are longer than the given length, then they will be
-- truncated to fit.
--
entrySetMaxLength :: EntryClass self => self
 -> Int   -- ^ @max@ - the maximum length of the entry, or 0 for no maximum.
          -- (other than the maximum length of entries.) The value passed in
          -- will be clamped to the range 0-65536.
 -> IO ()
entrySetMaxLength self max =
  {# call entry_set_max_length #}
    (toEntry self)
    (fromIntegral max)

-- | Retrieves the maximum allowed length of the text in @entry@. See
-- 'entrySetMaxLength'.
--
entryGetMaxLength :: EntryClass self => self
 -> IO Int -- ^ returns the maximum allowed number of characters in 'Entry',
           -- or 0 if there is no maximum.
entryGetMaxLength self =
  liftM fromIntegral $
  {# call unsafe entry_get_max_length #}
    (toEntry self)

-- | Query whether pressing return will activate the default widget.
--
entryGetActivatesDefault :: EntryClass self => self
 -> IO Bool -- ^ returns @True@ if the entry will activate the default widget
entryGetActivatesDefault self =
  liftM toBool $
  {# call unsafe entry_get_activates_default #}
    (toEntry self)

-- | If @setting@ is @True@, pressing Enter in the @entry@ will activate the
-- default widget for the window containing the entry. This usually means that
-- the dialog box containing the entry will be closed, since the default widget
-- is usually one of the dialog buttons.
--
-- (For experts: if @setting@ is @True@, the entry calls
-- 'Graphics.UI.Gtk.Windows.Window.windowActivateDefault' on the window
-- containing the entry, in the default
-- handler for the \"activate\" signal.)
--
-- This setting is useful in 'Dialog' boxes where enter should press the
-- default button.
--
entrySetActivatesDefault :: EntryClass self => self
 -> Bool  -- ^ @setting@ - @True@ to activate window's default widget on Enter
          -- keypress
 -> IO ()
entrySetActivatesDefault self setting =
  {# call entry_set_activates_default #}
    (toEntry self)
    (fromBool setting)

-- | Query if the text 'Entry' is displayed with a frame around it.
--
entryGetHasFrame :: EntryClass self => self
 -> IO Bool -- ^ returns whether the entry has a beveled frame
entryGetHasFrame self =
  liftM toBool $
  {# call unsafe entry_get_has_frame #}
    (toEntry self)

-- | Sets whether the entry has a beveled frame around it.
--
entrySetHasFrame :: EntryClass self => self -> Bool -> IO ()
entrySetHasFrame self setting =
  {# call entry_set_has_frame #}
    (toEntry self)
    (fromBool setting)

-- | Gets the value set by 'entrySetWidthChars'.
--
entryGetWidthChars :: EntryClass self => self
 -> IO Int -- ^ returns number of chars to request space for, or negative if
           -- unset
entryGetWidthChars self =
  liftM fromIntegral $
  {# call unsafe entry_get_width_chars #}
    (toEntry self)

-- | Changes the size request of the entry to be about the right size for
-- @nChars@ characters. Note that it changes the size /request/, the size can
-- still be affected by how you pack the widget into containers. If @nChars@ is
-- -1, the size reverts to the default entry size.
--
-- This setting is only considered when the widget formulates its size
-- request. Make sure that it is not mapped (shown) before you change this
-- value.
--
entrySetWidthChars :: EntryClass self => self
 -> Int   -- ^ @nChars@ - width in chars
 -> IO ()
entrySetWidthChars self nChars =
  {# call entry_set_width_chars #}
    (toEntry self)
    (fromIntegral nChars)

#if GTK_CHECK_VERSION(3,2,0)
-- | Sets text to be displayed in entry when it is empty and unfocused.
-- This can be used to give a visual hint of the expected contents of the `Entry`.
--
-- Note that since the placeholder text gets removed when the entry received
-- focus, using this feature is a bit problematic if the entry is given the
-- initial focus in a window. Sometimes this can be worked around by delaying
-- the initial focus setting until the first key event arrives.
--
-- * Available since Gtk version 3.2
--
entrySetPlaceholderText :: (EntryClass self, GlibString text) => self
 -> Maybe text -- ^ @text@ a string to be displayed when entry is empty an unfocused, or `Nothing`
 -> IO ()
entrySetPlaceholderText self text =
  maybeWith withUTFString text $ \ textPtr ->
  {# call entry_set_placeholder_text #}
    (toEntry self)
    textPtr

-- | Retrieves the text that will be displayed when entry is empty and unfocused.
--
-- * Available since Gtk version 3.2
--
entryGetPlaceholderText :: (EntryClass self, GlibString text) => self
 -> IO (Maybe text) -- ^ returns placeholder text
entryGetPlaceholderText self =
  {# call unsafe entry_get_placeholder_text #}
    (toEntry self)
  >>= maybePeek peekUTFString
#endif

#if GTK_CHECK_VERSION(2,4,0)
-- | Sets the alignment for the contents of the entry. This controls the
-- horizontal positioning of the contents when the displayed text is shorter
-- than the width of the entry.
--
-- * Available since Gtk version 2.4
--
entrySetAlignment :: EntryClass self => self
 -> Float -- ^ @xalign@ - The horizontal alignment, from 0 (left) to 1
          -- (right). Reversed for RTL layouts
 -> IO ()
entrySetAlignment self xalign =
  {# call entry_set_alignment #}
    (toEntry self)
    (realToFrac xalign)

-- | Gets the value set by 'entrySetAlignment'.
--
-- * Available since Gtk version 2.4
--
entryGetAlignment :: EntryClass self => self
 -> IO Float -- ^ returns the alignment
entryGetAlignment self =
  liftM realToFrac $
  {# call unsafe entry_get_alignment #}
    (toEntry self)

-- | Sets the auxiliary completion object to use with the entry. All further
-- configuration of the completion mechanism is done on completion using the
-- 'EntryCompletion' API.
--
-- * Available since Gtk version 2.4
--
entrySetCompletion :: EntryClass self => self -> EntryCompletion -> IO ()
entrySetCompletion self completion =
  {# call gtk_entry_set_completion #}
    (toEntry self)
    completion

-- | Returns the auxiliary completion object currently in use by the entry.
--
-- * Available since Gtk version 2.4
--
entryGetCompletion :: EntryClass self => self
 -> IO EntryCompletion -- ^ returns The auxiliary completion object currently
                       -- in use by @entry@.
entryGetCompletion self =
  makeNewGObject mkEntryCompletion $
  {# call gtk_entry_get_completion #}
    (toEntry self)
#endif

#if GTK_MAJOR_VERSION < 3
#if GTK_CHECK_VERSION(2,20,0)
-- | Returns the 'Window' which contains the entry's icon at @iconPos@. This function is useful when
-- drawing something to the entry in an 'eventExpose' callback because it enables the callback to
-- distinguish between the text window and entry's icon windows.
--
-- See also 'entryGetTextWindow'.
-- Removed in Gtk3.
entryGetIconWindow :: EntryClass self => self
                   -> EntryIconPosition  -- ^ @iconPos@ Icon position
                   -> IO DrawWindow -- ^ returns  the entry's icon window at @iconPos@.
entryGetIconWindow entry iconPos =
    makeNewGObject mkDrawWindow $
    {#call gtk_entry_get_icon_window #}
       (toEntry entry)
       ((fromIntegral . fromEnum) iconPos)

-- | Returns the 'Window' which contains the text. This function is useful when drawing something to the
-- entry in an 'eventExpose' callback because it enables the callback to distinguish between the text
-- window and entry's icon windows.
--
-- See also 'entryGetIconWindow'.
-- Removed in Gtk3.
entryGetTextWindow :: EntryClass self => self
                   -> IO DrawWindow  -- ^ returns the entry's text window.
entryGetTextWindow entry =
    makeNewGObject mkDrawWindow $
    {#call gtk_entry_get_text_window #}
      (toEntry entry)
#endif
#endif

#if GTK_CHECK_VERSION(2,22,0)
-- | Allow the 'Entry' input method to internally handle key press and release events. If this function
-- returns 'True', then no further processing should be done for this key event. See
-- 'imContextFilterKeypress'.
--
-- Note that you are expected to call this function from your handler when overriding key event
-- handling. This is needed in the case when you need to insert your own key handling between the input
-- method and the default key event handling of the 'Entry'. See 'textViewResetImContext' for
-- an example of use.
--
-- * Available since Gtk+ version 2.22
--
entryImContextFilterKeypress :: EntryClass self => self -> EventM EKey Bool
entryImContextFilterKeypress self = do
  ptr <- ask
  liftIO $ liftM toBool $
    {# call gtk_entry_im_context_filter_keypress #}
      (toEntry self)
      (castPtr ptr)

-- | Reset the input method context of the entry if needed.
--
-- This can be necessary in the case where modifying the buffer would confuse on-going input method
-- behavior.
--
-- * Available since Gtk+ version 2.22
--
entryResetImContext :: EntryClass self => self -> IO ()
entryResetImContext self =
  {#call gtk_entry_reset_im_context #} (toEntry self)
#endif

--------------------
-- Attributes

-- | The current position of the insertion cursor in chars.
--
-- Allowed values: [0,65535]
--
-- Default value: 0
--
entryCursorPosition :: EntryClass self => ReadAttr self Int
entryCursorPosition = readAttrFromIntProperty "cursor-position"

-- | The position of the opposite end of the selection from the cursor in
-- chars.
--
-- Allowed values: [0,65535]
--
-- Default value: 0
--
entrySelectionBound :: EntryClass self => ReadAttr self Int
entrySelectionBound = readAttrFromIntProperty "selection-bound"

-- | Whether the entry contents can be edited.
--
-- Default value: @True@
--
entryEditable :: EntryClass self => Attr self Bool
entryEditable = newAttrFromBoolProperty "editable"

-- | Maximum number of characters for this entry. Zero if no maximum.
--
-- Allowed values: [0,65535]
--
-- Default value: 0
--
entryMaxLength :: EntryClass self => Attr self Int
entryMaxLength = newAttr
  entryGetMaxLength
  entrySetMaxLength

-- | @False@ displays the \"invisible char\" instead of the actual text
-- (password mode).
--
-- Default value: @True@
--
entryVisibility :: EntryClass self => Attr self Bool
entryVisibility = newAttr
  entryGetVisibility
  entrySetVisibility

-- | @False@ removes outside bevel from entry.
--
-- Default value: @True@
--
entryHasFrame :: EntryClass self => Attr self Bool
entryHasFrame = newAttr
  entryGetHasFrame
  entrySetHasFrame

-- | The character to use when masking entry contents (in \"password mode\").
--
-- Default value: \'*\'
--
entryInvisibleChar :: EntryClass self => Attr self Char
entryInvisibleChar = newAttr
  entryGetInvisibleChar
  entrySetInvisibleChar

-- | Whether to activate the default widget (such as the default button in a
-- dialog) when Enter is pressed.
--
-- Default value: @False@
--
entryActivatesDefault :: EntryClass self => Attr self Bool
entryActivatesDefault = newAttr
  entryGetActivatesDefault
  entrySetActivatesDefault

-- | Number of characters to leave space for in the entry.
--
-- Allowed values: >= -1
--
-- Default value: -1
--
entryWidthChars :: EntryClass self => Attr self Int
entryWidthChars = newAttr
  entryGetWidthChars
  entrySetWidthChars

-- | Number of pixels of the entry scrolled off the screen to the left.
--
-- Allowed values: >= 0
--
-- Default value: 0
--
entryScrollOffset :: EntryClass self => ReadAttr self Int
entryScrollOffset = readAttrFromIntProperty "scroll-offset"

-- | The contents of the entry.
--
-- Default value: \"\"
--
entryText :: (EntryClass self, GlibString string) => Attr self string
entryText = newAttr
  entryGetText
  entrySetText

#if GTK_CHECK_VERSION(3,2,0)
-- | The text that will be displayed in the `Entry` when it is empty and unfocused.
--
-- Default value: Nothing
--
entryPlaceholderText :: (EntryClass self, GlibString text) => Attr self (Maybe text)
entryPlaceholderText = newAttr
  entryGetPlaceholderText
  entrySetPlaceholderText
#endif

#if GTK_CHECK_VERSION(2,4,0)
-- | The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL
-- layouts.
--
-- Allowed values: [0,1]
--
-- Default value: 0
--
entryXalign :: EntryClass self => Attr self Float
entryXalign = newAttrFromFloatProperty "xalign"

-- | \'alignment\' property. See 'entryGetAlignment' and 'entrySetAlignment'
--
entryAlignment :: EntryClass self => Attr self Float
entryAlignment = newAttr
  entryGetAlignment
  entrySetAlignment

-- | \'completion\' property. See 'entryGetCompletion' and
-- 'entrySetCompletion'
--
entryCompletion :: EntryClass self => Attr self EntryCompletion
entryCompletion = newAttr
  entryGetCompletion
  entrySetCompletion
#endif

#if GTK_CHECK_VERSION(2,18,0)
-- | The buffer being displayed.
--
entryBuffer :: (EntryClass self, EntryBufferClass buffer) =>
  ReadWriteAttr self EntryBuffer buffer
entryBuffer = newAttr
  entryGetBuffer
  entrySetBuffer
#endif


--------------------
-- Signals

-- | A keybinding signal which gets emitted when the user activates the entry.
--
-- Applications should not connect to it, but may emit it with 'signalEmitByName' if they need to
-- control activation programmatically.
entryActivated :: EntryClass ec => Signal ec (IO ())
entryActivated = Signal (connect_NONE__NONE "activate")

-- | Deprecated. See 'entryActivated'.
entryActivate :: EntryClass ec => Signal ec (IO ())
entryActivate = entryActivated

-- | The 'entryBackspace' signal is a keybinding signal which gets emitted when the user asks for it.
--
-- The default bindings for this signal are Backspace and Shift-Backspace.
entryBackspace :: EntryClass ec => Signal ec (IO ())
entryBackspace = Signal (connect_NONE__NONE "backspace")

-- | The 'entryCopyClipboard' signal is a keybinding signal which gets emitted to copy the selection to the
-- clipboard.
--
-- The default bindings for this signal are Ctrl-c and Ctrl-Insert.
entryCopyClipboard :: EntryClass ec => Signal ec (IO ())
entryCopyClipboard = Signal (connect_NONE__NONE "copy-clipboard")

-- | The 'entryCutClipboard' signal is a keybinding signal which gets emitted to cut the selection to the
-- clipboard.
--
-- The default bindings for this signal are Ctrl-x and Shift-Delete.
entryCutClipboard :: EntryClass ec => Signal ec (IO ())
entryCutClipboard = Signal (connect_NONE__NONE "cut-clipboard")

-- | The 'entryDeleteFromCursor' signal is a keybinding signal which gets emitted when the user initiates a
-- text deletion.
--
-- If the type is 'DeleteChars', GTK+ deletes the selection if there is one, otherwise it deletes
-- the requested number of characters.
--
-- The default bindings for this signal are Delete for deleting a character and Ctrl-Delete for
-- deleting a word.
entryDeleteFromCursor :: EntryClass ec => Signal ec (DeleteType -> Int -> IO ())
entryDeleteFromCursor = Signal (connect_ENUM_INT__NONE "delete-from-cursor")

-- | The 'entryInsertAtCursor' signal is a keybinding signal which gets emitted when the user initiates the
-- insertion of a fixed string at the cursor.
entryInsertAtCursor :: (EntryClass ec, GlibString string) => Signal ec (string -> IO ())
entryInsertAtCursor = Signal (connect_GLIBSTRING__NONE "insert-at-cursor")

-- | The 'entryMoveCursor' signal is a keybinding signal which gets emitted when the user initiates a cursor
-- movement. If the cursor is not visible in entry, this signal causes the viewport to be moved
-- instead.
--
-- Applications should not connect to it, but may emit it with 'signalEmitByName' if they need to
-- control the cursor programmatically.
--
-- The default bindings for this signal come in two variants, the variant with the Shift modifier
-- extends the selection, the variant without the Shift modifier does not. There are too many key
-- combinations to list them all here.
--
--   * Arrow keys move by individual characters\/lines
--   * Ctrl-arrow key combinations move by words\/paragraphs
--   * Home\/End keys move to the ends of the buffer
entryMoveCursor :: EntryClass ec => Signal ec (MovementStep -> Int -> Bool -> IO ())
entryMoveCursor = Signal (connect_ENUM_INT_BOOL__NONE "move-cursor")

-- | The 'entryPasteClipboard' signal is a keybinding signal which gets emitted to paste the contents of the
-- clipboard into the text view.
--
-- The default bindings for this signal are Ctrl-v and Shift-Insert.
entryPasteClipboard :: EntryClass ec => Signal ec (IO ())
entryPasteClipboard = Signal (connect_NONE__NONE "paste-clipboard")

-- | The 'entryPopulatePopup' signal gets emitted before showing the context menu of the entry.
--
-- If you need to add items to the context menu, connect to this signal and append your menuitems to
-- the menu.
entryPopulatePopup :: EntryClass ec => Signal ec (Menu -> IO ())
entryPopulatePopup = Signal (connect_OBJECT__NONE "populate-popup")

#if GTK_CHECK_VERSION(2,20,0)
-- | If an input method is used, the typed text will not immediately be committed to the buffer. So if
-- you are interested in the text, connect to this signal.
entryPreeditChanged :: (EntryClass ec, GlibString string) => Signal ec (string -> IO ())
entryPreeditChanged = Signal (connect_GLIBSTRING__NONE "preedit-changed")
#endif

#if GTK_CHECK_VERSION(2,16,0)
-- | The 'iconPress' signal is emitted when an activatable icon is clicked.
--
entryIconPress :: EntryClass ec =>
                    Signal ec (EntryIconPosition -> EventM EButton ())
entryIconPress = Signal $ \after obj f ->
  connect_ENUM_PTR__NONE "icon-press" after obj (runReaderT . f)

-- | The 'iconRelease' signal is emitted on the button release from a mouse click over an activatable
-- icon.
--
entryIconRelease :: EntryClass ec =>
                      Signal ec (EntryIconPosition -> EventM EButton ())
entryIconRelease = Signal $ \after obj f ->
  connect_ENUM_PTR__NONE "icon-press" after obj (runReaderT . f)
#endif

{-# DEPRECATED entryToggleOverwirte "Use entryToggleOverwrite" #-}
entryToggleOverwirte :: EntryClass ec => Signal ec (IO ())
entryToggleOverwirte = entryToggleOverwrite

-- | The 'entryToggleOverwrite' signal is a keybinding signal which gets emitted to toggle the overwrite mode
-- of the entry.
-- The default bindings for this signal is Insert.
--
entryToggleOverwrite :: EntryClass ec => Signal ec (IO ())
entryToggleOverwrite = Signal (connect_NONE__NONE "toggle-overwrite")

#ifndef DISABLE_DEPRECATED
-- | Emitted when the user presses return within
-- the 'Entry' field.
--
onEntryActivate, afterEntryActivate :: EntryClass ec => ec -> IO () ->
                                       IO (ConnectId ec)
onEntryActivate = connect_NONE__NONE "activate" False
afterEntryActivate = connect_NONE__NONE "activate" True

-- | Emitted when the current selection has been
-- copied to the clipboard.
--
onCopyClipboard, afterCopyClipboard :: EntryClass ec => ec -> IO () ->
                                       IO (ConnectId ec)
onCopyClipboard = connect_NONE__NONE "copy_clipboard" False
afterCopyClipboard = connect_NONE__NONE "copy_clipboard" True

-- | Emitted when the current selection has been
-- cut to the clipboard.
--
onCutClipboard, afterCutClipboard :: EntryClass ec => ec -> IO () ->
                                     IO (ConnectId ec)
onCutClipboard = connect_NONE__NONE "cut_clipboard" False
afterCutClipboard = connect_NONE__NONE "cut_clipboard" True

-- | Emitted when the current selection has
-- been pasted from the clipboard.
--
onPasteClipboard, afterPasteClipboard :: EntryClass ec => ec -> IO () ->
                                         IO (ConnectId ec)
onPasteClipboard = connect_NONE__NONE "paste_clipboard" False
afterPasteClipboard = connect_NONE__NONE "paste_clipboard" True

-- | Emitted when the user changes from
-- overwriting to inserting.
--
onToggleOverwrite, afterToggleOverwrite :: EntryClass ec => ec -> IO () ->
                                           IO (ConnectId ec)
onToggleOverwrite = connect_NONE__NONE "toggle_overwrite" False
afterToggleOverwrite = connect_NONE__NONE "toggle_overwrite" True
#endif
