static void
inf_text_default_delete_operation_apply(InfAdoptedOperation* operation,
                                        InfAdoptedUser* by,
                                        InfBuffer* buffer)
{
  InfTextDefaultDeleteOperationPrivate* priv;

  g_assert(INF_TEXT_IS_DEFAULT_DELETE_OPERATION(operation));
  g_assert(INF_TEXT_IS_BUFFER(buffer));

  priv = INF_TEXT_DEFAULT_DELETE_OPERATION_PRIVATE(operation);

#ifdef DELETE_OPERATION_CHECK_TEXT_MATCH
  g_assert(
    inf_text_default_delete_operation_text_match(
      INF_TEXT_DEFAULT_DELETE_OPERATION(operation),
      INF_TEXT_BUFFER(buffer)
    )
  );
#endif /* DELETE_OPERATION_CHECK_TEXT_MATCH */

  inf_text_buffer_erase_text(
    INF_TEXT_BUFFER(buffer),
    priv->position,
    inf_text_chunk_get_length(priv->chunk),
    INF_USER(by)
  );
}
Esempio n. 2
0
void TextBuffer::eraseText( unsigned int pos,
    unsigned int len,
    User *user )
{
    qDebug() << "erasing text:" << slice(pos, len)->text() << pos << len;
    inf_text_buffer_text_erased( INF_TEXT_BUFFER(gobject()),
        pos, slice(pos, len)->infChunk(), INF_USER(user->gobject()) );
    inf_text_buffer_erase_text( INF_TEXT_BUFFER(gobject()),
        pos, len, INF_USER(user->gobject()) );
}
static void
inf_text_remote_delete_operation_apply(InfAdoptedOperation* operation,
                                       InfAdoptedUser* by,
                                       InfBuffer* buffer)
{
  InfTextRemoteDeleteOperationPrivate* priv;

  g_assert(INF_TEXT_IS_REMOTE_DELETE_OPERATION(operation));
  g_assert(INF_TEXT_IS_BUFFER(buffer));

  priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);

  inf_text_buffer_erase_text(
    INF_TEXT_BUFFER(buffer),
    priv->position,
    priv->length,
    INF_USER(by)
  );
}
static gboolean
inf_text_remote_delete_operation_apply(InfAdoptedOperation* operation,
                                       InfAdoptedUser* by,
                                       InfBuffer* buffer,
                                       GError** error)
{
  InfTextRemoteDeleteOperationPrivate* priv;

  g_assert(INF_TEXT_IS_REMOTE_DELETE_OPERATION(operation));
  g_assert(INF_TEXT_IS_BUFFER(buffer));

  priv = INF_TEXT_REMOTE_DELETE_OPERATION_PRIVATE(operation);

  if(priv->position + priv->length >
     inf_text_buffer_get_length(INF_TEXT_BUFFER(buffer)))
  {
    g_set_error(
      error,
      g_quark_from_static_string("INF_TEXT_OPERATION_ERROR"),
      INF_TEXT_OPERATION_ERROR_INVALID_DELETE,
      "%s",
      _("Attempt to remove text from after the end of the document")
    );

    return FALSE;
  }
  else
  {
    inf_text_buffer_erase_text(
      INF_TEXT_BUFFER(buffer),
      priv->position,
      priv->length,
      INF_USER(by)
    );
    
    return TRUE;
  }
}
static void
infinoted_plugin_linekeeper_run(InfinotedPluginLinekeeperSessionInfo* info)
{
  guint cur_lines;
  guint n;
  gchar* text;

  cur_lines = infinoted_plugin_linekeeper_count_lines(info->buffer);

  if(cur_lines > info->plugin->n_lines)
  {
    n = cur_lines - info->plugin->n_lines;

    inf_text_buffer_erase_text(
      info->buffer,
      inf_text_buffer_get_length(info->buffer) - n,
      n,
      info->user
    );
  }
  else if(cur_lines < info->plugin->n_lines)
  {
    n = info->plugin->n_lines - cur_lines;
    text = g_malloc(n * sizeof(gchar));
    memset(text, '\n', n);

    inf_text_buffer_insert_text(
      info->buffer,
      inf_text_buffer_get_length(info->buffer),
      text,
      n,
      n,
      info->user
    );
  }
}
Esempio n. 6
0
static gboolean
test_fixline(const gchar* initial_buffer_content,
             const gchar* initial_base_content,
             guint n_lines,
             InfTestTextFixlineOperation operation,
             InfTestTextFixlineTarget target,
             guint pos,
             gchar* text,
             const gchar* final_buffer_content,
             const gchar* final_base_content)
{
  InfStandaloneIo* io;
  InfTextBuffer* base;
  InfTextBuffer* buffer;

  /* Create the initial state */
  io = inf_standalone_io_new();
  base = INF_TEXT_BUFFER(inf_text_default_buffer_new("UTF-8"));

  inf_text_buffer_insert_text(
    base,
    0,
    initial_buffer_content,
    strlen(initial_buffer_content),
    strlen(initial_buffer_content),
    0
  );

  buffer = INF_TEXT_BUFFER(
    inf_text_fixline_buffer_new(INF_IO(io), base, n_lines)
  );

  /* Check the initial state */
  if(!check_buffer(base, initial_base_content, "Initial base"))
  {
    g_object_unref(io);
    g_object_unref(base);
    g_object_unref(buffer);
    return FALSE;
  }

  if(!check_buffer(buffer, initial_buffer_content, "Initial buf"))
  {
    g_object_unref(io);
    g_object_unref(base);
    g_object_unref(buffer);
    return FALSE;
  }

  /* Apply the operation */
  switch(operation)
  {
  case OP_NONE:
    break;
  case OP_INS:
    if(target == TG_BASE)
    {
      inf_text_buffer_insert_text(
        base,
        pos,
        text,
        strlen(text),
        strlen(text),
        0
      );
    }
    else if(target == TG_BUF)
    {
      inf_text_buffer_insert_text(
        buffer,
        pos,
        text,
        strlen(text),
        strlen(text),
        0
      );
    }
    break;
  case OP_DEL:
    if(target == TG_BASE)
      inf_text_buffer_erase_text(base, pos, GPOINTER_TO_UINT(text), 0);
    else if(target == TG_BUF)
      inf_text_buffer_erase_text(buffer, pos, GPOINTER_TO_UINT(text), 0);
    break;
  default:
    g_assert_not_reached();
    break;
  }

  /* Run any delayed action */
  inf_standalone_io_iteration_timeout(io, 0);

  /* Check the final state */
  if(!check_buffer(base, final_base_content, "Final base"))
  {
    g_object_unref(io);
    g_object_unref(base);
    g_object_unref(buffer);
    return FALSE;
  }

  if(!check_buffer(buffer, final_buffer_content, "Final buf"))
  {
    g_object_unref(io);
    g_object_unref(base);
    g_object_unref(buffer);
    return FALSE;
  }

  g_object_unref(io);
  g_object_unref(base);
  g_object_unref(buffer);

  return TRUE;
}