lib.h File Reference

Edit a string. More...

#include <stddef.h>
#include "enter.h"
#include "functions.h"
#include "state.h"
#include "wdata.h"
#include "core/lib.h"
#include "history/lib.h"

Include dependency graph for lib.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef void(*	get_field_callback_t) (const char *text, void *data)

Functions
void	editor_init_keys (struct SubMenu *sm_generic)
	Initialise the Editor Keybindings - Implements ::init_keys_api.
int	mw_get_field (const char *prompt, struct Buffer *buf, CompletionFlags complete, enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata)
	Ask the user for a string -.
int	mw_get_field_notify (const char *prompt, struct Buffer *buf, CompletionFlags complete, enum HistoryClass hclass, const struct CompleteOps *comp_api, void *cdata, get_field_callback_t callback, void *cb_data, const struct MenuDefinition *md, function_dispatcher_t fn_disp)
	Ask the user for a string and call a notify function on keypress.
void	replace_part (struct EnterState *es, size_t from, const char *buf)
	Search and replace on a buffer.

Detailed Description

Edit a string.

Authors

• Richard Russon

Copyright

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 2 of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License along with this program. If not, see http://www.gnu.org/licenses/.

Definition in file lib.h.

Typedef Documentation

get_field_callback_t

typedef void(* get_field_callback_t) (const char *text, void *data)

Definition at line 67 of file lib.h.

Function Documentation

editor_init_keys()

void editor_init_keys

(

struct SubMenu *

sm_generic

)

Initialise the Editor Keybindings - Implements ::init_keys_api.

Definition at line 131 of file functions.c.

{
  struct MenuDefinition *md = NULL;
  struct SubMenu *sm = NULL;
 
  sm = km_register_submenu(OpEditor);
  md = km_register_menu(MENU_EDITOR, "editor");
  km_menu_add_submenu(md, sm);
  km_menu_add_bindings(md, EditorDefaultBindings);
 
  MdEditor = md;
  SmEditor = sm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mw_get_field_notify()

int mw_get_field_notify	(	const char *	prompt,
		struct Buffer *	buf,
		CompletionFlags	complete,
		enum HistoryClass	hclass,
		const struct CompleteOps *	comp_api,
		void *	cdata,
		get_field_callback_t	callback,
		void *	cb_data,
		const struct MenuDefinition *	md,
		function_dispatcher_t	fn_disp )

Ask the user for a string and call a notify function on keypress.

Parameters

[in]	prompt	Prompt
[in]	buf	Buffer for the result
[in]	hclass	History class to use
[in]	complete	Flags, see CompletionFlags
[in]	comp_api	Auto-completion API
[in]	cdata	Auto-completion private data
[in]	callback	Callback function used for notification
[in]	cb_data	Data to pass to callback function
[in]	md	Menu Definition
[in]	fn_disp	Function dispatcher

Return values

0	Selection made
-1	Aborted

Definition at line 265 of file window.c.

{
  struct MuttWindow *win = mutt_window_new(WT_CUSTOM, MUTT_WIN_ORIENT_VERTICAL, MUTT_WIN_SIZE_FIXED,
                                           MUTT_WIN_SIZE_UNLIMITED, 1);
 
  GetChFlags flags = GETCH_NO_FLAGS;
  if (complete & MUTT_COMP_UNBUFFERED)
    flags = GETCH_IGNORE_MACRO;
 
  struct Buffer *cbuf = NULL;
  if (callback)
    cbuf = buf_pool_get();
 
  if (!md)
    md = MdEditor;
 
  int rc = 0;
 
  struct EnterState *es = enter_state_new();
 
  win->help_data = EditorHelp;
  win->help_md = MdEditor;
 
  msgcont_push_window(win);
  struct MuttWindow *old_focus = window_set_focus(win);
 
  mbstate_t mbstate = { 0 };
  // clang-format off
  struct EnterWindowData wdata = { buf, complete, es, hclass, comp_api, cdata, prompt, ENTER_REDRAW_NONE, (complete & MUTT_COMP_PASS), true, NULL, 0, &mbstate, 0, false, NULL, 0, 0 };
  // clang-format on
 
  win->wdata = &wdata;
  win->wdata_free = NULL; // No need, we hold the data
  win->recalc = enter_recalc;
  win->repaint = enter_repaint;
  win->recursor = enter_recursor;
 
  window_redraw(win);
 
  if (es->wbuf[0] == L'\0')
  {
    /* Initialise wbuf from buf */
    wdata.state->wbuflen = 0;
    wdata.state->lastchar = mutt_mb_mbstowcs(&wdata.state->wbuf, &wdata.state->wbuflen,
                                             0, buf_string(wdata.buffer));
    wdata.redraw = ENTER_REDRAW_INIT;
  }
  else
  {
    wdata.redraw = ENTER_REDRAW_LINE;
    wdata.first = false;
  }
 
  do
  {
    memset(&mbstate, 0, sizeof(mbstate));
 
    do
    {
      if (wdata.redraw != ENTER_REDRAW_NONE)
        win->actions |= WA_REPAINT;
 
      mutt_curses_set_cursor(MUTT_CURSOR_INVISIBLE);
      window_redraw(NULL);
      mutt_curses_set_cursor(MUTT_CURSOR_VISIBLE);
      struct KeyEvent event = km_dokey(md, flags);
      if ((event.op == OP_TIMEOUT) || (event.op == OP_REPAINT))
      {
        continue;
      }
 
      if (event.op == OP_ABORT)
      {
        rc = -1;
        goto bye;
      }
 
      if (event.op == OP_NULL)
      {
        if (complete & MUTT_COMP_PASS)
          mutt_debug(LL_DEBUG5, "Got char *\n");
        else
          mutt_debug(LL_DEBUG5, "Got char %c (0x%02x)\n", event.ch, event.ch);
 
        if (self_insert(&wdata, event.ch))
        {
          rc = 0;
          goto bye;
        }
        win->actions |= WA_REPAINT;
        goto notify;
      }
      else
      {
        mutt_debug(LL_DEBUG1, "Got op %s (%d)\n", opcodes_get_name(event.op),
                   event.op);
      }
 
      wdata.first = false;
      if ((event.op != OP_EDITOR_COMPLETE) && (event.op != OP_EDITOR_COMPLETE_QUERY))
        wdata.tabs = 0;
 
      wdata.redraw = ENTER_REDRAW_LINE;
 
      int rc_disp = FR_UNKNOWN;
      if (fn_disp)
      {
        rc_disp = fn_disp(cb_data, &event);
        if (rc_disp == FR_SUCCESS)
          rc_disp = FR_CONTINUE;
      }
 
      if (rc_disp == FR_UNKNOWN)
        rc_disp = enter_function_dispatcher(win, &event);
 
      switch (rc_disp)
      {
        case FR_NO_ACTION:
        {
          if (self_insert(&wdata, event.ch))
          {
            rc = 0;
            goto bye;
          }
          break;
        }
        case FR_CONTINUE: // repaint
          rc = 1;
          goto bye;
 
        case FR_DONE:
          wdata.done = true;
          rc = 0;
          break;
 
        case FR_SUCCESS:
          rc = 0;
          break;
 
        case FR_UNKNOWN:
        case FR_ERROR:
        default:
          mutt_beep(false);
      }
 
    notify:
      if (callback)
      {
        buf_mb_wcstombs(cbuf, wdata.state->wbuf, wdata.state->lastchar);
        callback(buf_string(cbuf), cb_data);
      }
 
    } while (!wdata.done);
 
  bye:
    mutt_hist_reset_state(wdata.hclass);
    FREE(&wdata.tempbuf);
  } while (rc == 1);
 
  completion_data_free(&wdata.cd);
  msgcont_pop_window();
  window_set_focus(old_focus);
  mutt_window_free(&win);
 
  if (rc == 0)
    buf_fix_dptr(buf);
  else
    buf_reset(buf);
 
  buf_pool_release(&cbuf);
 
  enter_state_free(&es);
 
  return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

replace_part()

void replace_part	(	struct EnterState *	es,
		size_t	from,
		const char *	buf )

Search and replace on a buffer.

Parameters

es	Current state of the input buffer
from	Starting point for the replacement
buf	Replacement string

Definition at line 151 of file functions.c.

{
  /* Save the suffix */
  size_t savelen = es->lastchar - es->curpos;
  wchar_t *savebuf = NULL;
 
  if (savelen)
  {
    savebuf = MUTT_MEM_CALLOC(savelen, wchar_t);
    wmemcpy(savebuf, es->wbuf + es->curpos, savelen);
  }
 
  /* Convert to wide characters */
  es->curpos = mutt_mb_mbstowcs(&es->wbuf, &es->wbuflen, from, buf);
 
  if (savelen)
  {
    /* Make space for suffix */
    if (es->curpos + savelen > es->wbuflen)
    {
      es->wbuflen = es->curpos + savelen;
      MUTT_MEM_REALLOC(&es->wbuf, es->wbuflen, wchar_t);
    }
 
    /* Restore suffix */
    wmemcpy(es->wbuf + es->curpos, savebuf, savelen);
    FREE(&savebuf);
  }
 
  es->lastchar = es->curpos + savelen;
}

Here is the call graph for this function:

Here is the caller graph for this function: