rofi/source/textbox.c

712 lines
22 KiB
C
Raw Normal View History

2015-03-08 14:43:31 +00:00
/**
* MIT/X11 License
* Copyright (c) 2012 Sean Pringle <sean.pringle@gmail.com>
* Modified (c) 2013-2015 Qball Cow <qball@gmpclient.org>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be
* included in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
2014-03-22 20:04:19 +00:00
*/
2012-08-24 01:28:39 +00:00
#include <config.h>
#include <X11/X.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xmd.h>
#include <X11/Xutil.h>
#include <X11/Xproto.h>
#include <X11/keysym.h>
#include <X11/XKBlib.h>
#include <ctype.h>
2015-09-27 10:57:54 +00:00
#include <glib.h>
2015-09-26 18:34:34 +00:00
#include <pango/pangocairo.h>
2014-03-12 07:41:38 +00:00
#include "rofi.h"
#include "textbox.h"
#include "keyb.h"
2015-09-27 10:57:54 +00:00
#include "x11-helper.h"
2015-03-22 11:56:26 +00:00
#define SIDE_MARGIN 1
2012-08-24 01:28:39 +00:00
2014-05-26 07:00:14 +00:00
/**
* Font + font color cache.
* Avoid re-loading font on every change on every textbox.
*/
2015-04-06 15:13:26 +00:00
typedef struct _RowColor
{
2015-09-26 18:34:34 +00:00
Color fg;
Color bg;
Color bgalt;
Color hlfg;
Color hlbg;
2015-04-06 15:13:26 +00:00
} RowColor;
#define num_states 3
2015-09-19 10:57:48 +00:00
RowColor colors[num_states];
2014-08-02 18:02:37 +00:00
PangoContext *p_context = NULL;
2015-09-26 18:34:34 +00:00
textbox* textbox_create ( TextboxFlags flags, short x, short y, short w, short h,
2015-09-19 10:57:48 +00:00
TextBoxFontType tbft, const char *text )
2012-08-24 01:28:39 +00:00
{
textbox *tb = g_malloc0 ( sizeof ( textbox ) );
2012-08-24 01:28:39 +00:00
2015-09-26 18:34:34 +00:00
tb->flags = flags;
2012-08-24 01:28:39 +00:00
2014-01-10 09:35:38 +00:00
tb->x = x;
tb->y = y;
2014-03-22 20:04:19 +00:00
tb->w = MAX ( 1, w );
tb->h = MAX ( 1, h );
2012-11-07 04:16:59 +00:00
tb->changed = FALSE;
2015-09-27 10:57:54 +00:00
tb->main_surface = cairo_image_surface_create ( get_format (), tb->w, tb->h );
2015-09-26 18:34:34 +00:00
tb->main_draw = cairo_create ( tb->main_surface );
tb->layout = pango_cairo_create_layout ( tb->main_draw );
2015-04-03 16:40:07 +00:00
PangoFontDescription *pfd = pango_font_description_from_string ( config.menu_font );
pango_layout_set_font_description ( tb->layout, pfd );
pango_font_description_free ( pfd );
textbox_font ( tb, tbft );
2012-08-24 01:28:39 +00:00
2015-09-23 18:44:24 +00:00
if ( ( flags & TB_WRAP ) == TB_WRAP ) {
pango_layout_set_wrap ( tb->layout, PANGO_WRAP_WORD_CHAR );
}
2015-09-22 20:23:52 +00:00
textbox_text ( tb, text ? text : "" );
2014-03-22 20:04:19 +00:00
textbox_cursor_end ( tb );
2012-08-24 01:28:39 +00:00
2014-01-10 09:35:38 +00:00
// auto height/width modes get handled here
2014-03-22 20:04:19 +00:00
textbox_moveresize ( tb, tb->x, tb->y, tb->w, tb->h );
2012-08-24 01:28:39 +00:00
2014-01-10 09:35:38 +00:00
return tb;
2012-08-24 01:28:39 +00:00
}
void textbox_font ( textbox *tb, TextBoxFontType tbft )
2012-08-24 01:28:39 +00:00
{
2015-10-26 13:22:58 +00:00
TextBoxFontType t = tbft & STATE_MASK;
// ACTIVE has priority over URGENT if both set.
if ( t == ( URGENT | ACTIVE ) ) {
t = ACTIVE;
}
RowColor *color = &( colors[t] );
2015-04-06 15:13:26 +00:00
switch ( ( tbft & FMOD_MASK ) )
2014-03-22 20:04:19 +00:00
{
case HIGHLIGHT:
2015-04-06 15:13:26 +00:00
tb->color_bg = color->hlbg;
tb->color_fg = color->hlfg;
break;
case ALT:
2015-04-06 15:13:26 +00:00
tb->color_bg = color->bgalt;
tb->color_fg = color->fg;
break;
default:
2015-04-06 15:13:26 +00:00
tb->color_bg = color->bg;
tb->color_fg = color->fg;
break;
}
2015-09-26 18:34:34 +00:00
if ( tb->tbft != tbft ) {
tb->update = TRUE;
}
tb->tbft = tbft;
2012-08-24 01:28:39 +00:00
}
// set the default text to display
2015-02-03 07:21:59 +00:00
void textbox_text ( textbox *tb, const char *text )
2012-08-24 01:28:39 +00:00
{
2015-09-26 18:34:34 +00:00
tb->update = TRUE;
g_free ( tb->text );
const gchar *last_pointer = NULL;
2015-09-26 18:34:34 +00:00
if ( g_utf8_validate ( text, -1, &last_pointer ) ) {
tb->text = g_strdup ( text );
}
else {
if ( last_pointer != NULL ) {
// Copy string up to invalid character.
tb->text = g_strndup ( text, ( last_pointer - text ) );
}
else {
tb->text = g_strdup ( "Invalid UTF-8 string." );
}
}
2015-09-26 18:34:34 +00:00
2015-09-22 20:23:52 +00:00
if ( tb->flags & TB_MARKUP ) {
pango_layout_set_markup ( tb->layout, tb->text, strlen ( tb->text ) );
}
else {
2015-09-22 20:23:52 +00:00
pango_layout_set_text ( tb->layout, tb->text, strlen ( tb->text ) );
}
if ( tb->flags & TB_AUTOWIDTH ) {
textbox_moveresize ( tb, tb->x, tb->y, tb->w, tb->h );
}
2014-03-22 20:04:19 +00:00
tb->cursor = MAX ( 0, MIN ( ( int ) strlen ( text ), tb->cursor ) );
2012-08-24 01:28:39 +00:00
}
2014-05-22 07:33:32 +00:00
void textbox_move ( textbox *tb, int x, int y )
{
2014-06-04 19:29:23 +00:00
if ( x != tb->x || y != tb->y ) {
tb->x = x;
tb->y = y;
}
}
2015-03-05 19:26:52 +00:00
// within the parent handled auto width/height modes
2014-03-22 20:04:19 +00:00
void textbox_moveresize ( textbox *tb, int x, int y, int w, int h )
2012-08-24 01:28:39 +00:00
{
2014-06-04 19:29:23 +00:00
if ( tb->flags & TB_AUTOWIDTH ) {
pango_layout_set_width ( tb->layout, -1 );
2015-09-26 18:34:34 +00:00
w = textbox_get_width ( tb );
2014-03-22 20:04:19 +00:00
}
2014-08-02 18:02:37 +00:00
else {
// set ellipsize
if ( ( tb->flags & TB_EDITABLE ) == TB_EDITABLE ) {
pango_layout_set_ellipsize ( tb->layout, PANGO_ELLIPSIZE_MIDDLE );
}
2015-09-23 18:44:24 +00:00
else if ( ( tb->flags & TB_WRAP ) != TB_WRAP ) {
pango_layout_set_ellipsize ( tb->layout, PANGO_ELLIPSIZE_END );
}
2014-08-02 18:02:37 +00:00
}
2014-01-10 09:35:38 +00:00
if ( tb->flags & TB_AUTOHEIGHT ) {
// Width determines height!
int tw = MAX ( 1, w );
pango_layout_set_width ( tb->layout, PANGO_SCALE * ( tw - 2 * SIDE_MARGIN ) );
h = textbox_get_height ( tb );
}
2014-06-04 19:29:23 +00:00
if ( x != tb->x || y != tb->y || w != tb->w || h != tb->h ) {
2014-01-10 09:35:38 +00:00
tb->x = x;
tb->y = y;
2014-03-22 20:04:19 +00:00
tb->h = MAX ( 1, h );
tb->w = MAX ( 1, w );
2014-01-10 09:35:38 +00:00
}
2015-09-26 18:34:34 +00:00
// We always want to update this
pango_layout_set_width ( tb->layout, PANGO_SCALE * ( tb->w - 2 * SIDE_MARGIN ) );
tb->update = TRUE;
2012-08-24 01:28:39 +00:00
}
// will also unmap the window if still displayed
2014-03-22 20:04:19 +00:00
void textbox_free ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
2014-06-06 17:31:33 +00:00
if ( tb == NULL ) {
return;
}
2014-01-10 09:35:38 +00:00
g_free ( tb->text );
if ( tb->layout != NULL ) {
2014-08-02 18:02:37 +00:00
g_object_unref ( tb->layout );
}
2015-09-26 18:34:34 +00:00
if ( tb->main_draw ) {
cairo_destroy ( tb->main_draw );
tb->main_draw = NULL;
}
if ( tb->main_surface ) {
cairo_surface_destroy ( tb->main_surface );
tb->main_surface = NULL;
}
2014-01-10 09:35:38 +00:00
g_free ( tb );
2012-08-24 01:28:39 +00:00
}
2015-09-26 18:34:34 +00:00
static void texbox_update ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
2015-09-26 18:34:34 +00:00
if ( tb->update ) {
if ( tb->main_surface ) {
cairo_destroy ( tb->main_draw );
cairo_surface_destroy ( tb->main_surface );
tb->main_draw = NULL;
tb->main_surface = NULL;
}
2015-09-27 10:57:54 +00:00
tb->main_surface = cairo_image_surface_create ( get_format (), tb->w, tb->h );
2015-09-26 18:34:34 +00:00
tb->main_draw = cairo_create ( tb->main_surface );
PangoFontDescription *pfd = pango_font_description_from_string ( config.menu_font );
pango_font_description_free ( pfd );
cairo_set_operator ( tb->main_draw, CAIRO_OPERATOR_SOURCE );
pango_cairo_update_layout ( tb->main_draw, tb->layout );
char *text = tb->text ? tb->text : "";
int text_len = strlen ( text );
int font_height = textbox_get_font_height ( tb );
int cursor_x = 0;
int cursor_width = MAX ( 2, font_height / 10 );
if ( tb->changed ) {
if ( tb->flags & TB_MARKUP ) {
pango_layout_set_markup ( tb->layout, text, text_len );
}
else{
pango_layout_set_text ( tb->layout, text, text_len );
}
}
2014-08-02 18:02:37 +00:00
2015-09-26 18:34:34 +00:00
if ( tb->flags & TB_EDITABLE ) {
PangoRectangle pos;
int cursor_offset = 0;
cursor_offset = MIN ( tb->cursor, text_len );
pango_layout_get_cursor_pos ( tb->layout, cursor_offset, &pos, NULL );
// Add a small 4px offset between cursor and last glyph.
cursor_x = pos.x / PANGO_SCALE;
}
2012-08-24 01:28:39 +00:00
2015-09-26 18:34:34 +00:00
// Skip the side MARGIN on the X axis.
int x = SIDE_MARGIN;
int y = 0;
2012-08-24 01:28:39 +00:00
2015-09-26 18:34:34 +00:00
if ( tb->flags & TB_RIGHT ) {
int line_width = 0;
// Get actual width.
pango_layout_get_pixel_size ( tb->layout, &line_width, NULL );
x = ( tb->w - line_width - SIDE_MARGIN );
}
else if ( tb->flags & TB_CENTER ) {
int tw = textbox_get_font_width ( tb );
x = ( ( tb->w - tw - 2 * SIDE_MARGIN ) ) / 2;
}
short fh = textbox_get_font_height ( tb );
if ( fh > tb->h ) {
y = 0;
}
else {
y = ( ( tb->h - fh ) ) / 2;
}
2015-09-26 18:34:34 +00:00
// Set ARGB
Color col = tb->color_bg;
cairo_set_source_rgba ( tb->main_draw, col.red, col.green, col.blue, col.alpha );
cairo_paint ( tb->main_draw );
// Set ARGB
col = tb->color_fg;
cairo_set_source_rgba ( tb->main_draw, col.red, col.green, col.blue, col.alpha );
cairo_move_to ( tb->main_draw, x, y );
pango_cairo_show_layout ( tb->main_draw, tb->layout );
//cairo_fill(tb->draw);
// draw the cursor
if ( tb->flags & TB_EDITABLE ) {
cairo_rectangle ( tb->main_draw, x + cursor_x, y, cursor_width, font_height );
cairo_fill ( tb->main_draw );
}
2012-08-24 01:28:39 +00:00
2015-09-26 18:34:34 +00:00
tb->update = FALSE;
2014-03-22 20:04:19 +00:00
}
2015-09-26 18:34:34 +00:00
}
void textbox_draw ( textbox *tb, cairo_t *draw )
{
texbox_update ( tb );
2012-08-24 01:28:39 +00:00
2015-09-26 18:34:34 +00:00
/* Write buffer */
2012-08-24 01:28:39 +00:00
2015-09-26 18:34:34 +00:00
cairo_set_source_surface ( draw, tb->main_surface, tb->x, tb->y );
cairo_rectangle ( draw, tb->x, tb->y, tb->w, tb->h );
cairo_fill ( draw );
2012-08-24 01:28:39 +00:00
}
// cursor handling for edit mode
2014-03-22 20:04:19 +00:00
void textbox_cursor ( textbox *tb, int pos )
2012-08-24 01:28:39 +00:00
{
int length = ( tb->text == NULL ) ? 0 : strlen ( tb->text );
2015-02-13 14:37:55 +00:00
tb->cursor = MAX ( 0, MIN ( length, pos ) );
2015-09-26 18:34:34 +00:00
tb->update = TRUE;
2012-08-24 01:28:39 +00:00
}
// move right
2014-03-22 20:04:19 +00:00
void textbox_cursor_inc ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
int index = g_utf8_next_char ( &( tb->text[tb->cursor] ) ) - tb->text;
textbox_cursor ( tb, index );
2012-08-24 01:28:39 +00:00
}
// move left
2014-03-22 20:04:19 +00:00
void textbox_cursor_dec ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
int index = g_utf8_prev_char ( &( tb->text[tb->cursor] ) ) - tb->text;
textbox_cursor ( tb, index );
2012-08-24 01:28:39 +00:00
}
// Move word right
static void textbox_cursor_inc_word ( textbox *tb )
{
if ( tb->text == NULL ) {
2015-02-13 14:37:55 +00:00
return;
}
// Find word boundaries, with pango_Break?
gchar *c = &( tb->text[tb->cursor] );
while ( ( c = g_utf8_next_char ( c ) ) ) {
gunichar uc = g_utf8_get_char ( c );
GUnicodeBreakType bt = g_unichar_break_type ( uc );
2015-09-19 18:59:50 +00:00
if ( ( bt == G_UNICODE_BREAK_ALPHABETIC || bt == G_UNICODE_BREAK_HEBREW_LETTER ||
bt == G_UNICODE_BREAK_NUMERIC || bt == G_UNICODE_BREAK_QUOTATION ) ) {
break;
}
}
if ( c == NULL ) {
2015-02-13 14:37:55 +00:00
return;
}
while ( ( c = g_utf8_next_char ( c ) ) ) {
gunichar uc = g_utf8_get_char ( c );
GUnicodeBreakType bt = g_unichar_break_type ( uc );
2015-09-19 18:59:50 +00:00
if ( !( bt == G_UNICODE_BREAK_ALPHABETIC || bt == G_UNICODE_BREAK_HEBREW_LETTER ||
bt == G_UNICODE_BREAK_NUMERIC || bt == G_UNICODE_BREAK_QUOTATION ) ) {
break;
}
}
int index = c - tb->text;
textbox_cursor ( tb, index );
}
// move word left
static void textbox_cursor_dec_word ( textbox *tb )
{
// Find word boundaries, with pango_Break?
gchar *n;
gchar *c = &( tb->text[tb->cursor] );
while ( ( c = g_utf8_prev_char ( c ) ) && c != tb->text ) {
gunichar uc = g_utf8_get_char ( c );
GUnicodeBreakType bt = g_unichar_break_type ( uc );
2015-09-19 18:59:50 +00:00
if ( ( bt == G_UNICODE_BREAK_ALPHABETIC || bt == G_UNICODE_BREAK_HEBREW_LETTER ||
bt == G_UNICODE_BREAK_NUMERIC || bt == G_UNICODE_BREAK_QUOTATION ) ) {
break;
}
}
if ( c != tb->text ) {
while ( ( n = g_utf8_prev_char ( c ) ) ) {
gunichar uc = g_utf8_get_char ( n );
GUnicodeBreakType bt = g_unichar_break_type ( uc );
2015-09-19 18:59:50 +00:00
if ( !( bt == G_UNICODE_BREAK_ALPHABETIC || bt == G_UNICODE_BREAK_HEBREW_LETTER ||
bt == G_UNICODE_BREAK_NUMERIC || bt == G_UNICODE_BREAK_QUOTATION ) ) {
break;
}
c = n;
if ( n == tb->text ) {
break;
}
}
}
int index = c - tb->text;
textbox_cursor ( tb, index );
}
2012-08-24 01:28:39 +00:00
// end of line
2014-03-22 20:04:19 +00:00
void textbox_cursor_end ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
2014-03-22 20:04:19 +00:00
tb->cursor = ( int ) strlen ( tb->text );
2015-09-26 18:34:34 +00:00
tb->update = TRUE;
2012-08-24 01:28:39 +00:00
}
// insert text
2014-03-22 20:04:19 +00:00
void textbox_insert ( textbox *tb, int pos, char *str )
2012-08-24 01:28:39 +00:00
{
2014-03-22 20:04:19 +00:00
int len = ( int ) strlen ( tb->text ), slen = ( int ) strlen ( str );
pos = MAX ( 0, MIN ( len, pos ) );
2014-01-10 09:35:38 +00:00
// expand buffer
tb->text = g_realloc ( tb->text, len + slen + 1 );
2014-01-10 09:35:38 +00:00
// move everything after cursor upward
char *at = tb->text + pos;
2014-03-22 20:04:19 +00:00
memmove ( at + slen, at, len - pos + 1 );
2014-01-10 09:35:38 +00:00
// insert new str
2014-03-22 20:04:19 +00:00
memmove ( at, str, slen );
// Set modified, lay out need te be redrawn
tb->changed = TRUE;
2015-09-26 18:34:34 +00:00
tb->update = TRUE;
2012-08-24 01:28:39 +00:00
}
// remove text
2014-03-22 20:04:19 +00:00
void textbox_delete ( textbox *tb, int pos, int dlen )
2012-08-24 01:28:39 +00:00
{
2014-03-22 20:04:19 +00:00
int len = strlen ( tb->text );
pos = MAX ( 0, MIN ( len, pos ) );
2014-01-10 09:35:38 +00:00
// move everything after pos+dlen down
char *at = tb->text + pos;
// Move remainder + closing \0
memmove ( at, at + dlen, len - pos - dlen + 1 );
if ( tb->cursor >= pos && tb->cursor < ( pos + dlen ) ) {
tb->cursor = pos;
}
else if ( tb->cursor >= ( pos + dlen ) ) {
tb->cursor -= dlen;
}
// Set modified, lay out need te be redrawn
tb->changed = TRUE;
2015-09-26 18:34:34 +00:00
tb->update = TRUE;
2012-08-24 01:28:39 +00:00
}
// delete on character
2014-03-22 20:04:19 +00:00
void textbox_cursor_del ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
if ( tb->text == NULL ) {
2015-02-13 14:37:55 +00:00
return;
}
int index = g_utf8_next_char ( &( tb->text[tb->cursor] ) ) - tb->text;
textbox_delete ( tb, tb->cursor, index - tb->cursor );
2012-08-24 01:28:39 +00:00
}
// back up and delete one character
2014-03-22 20:04:19 +00:00
void textbox_cursor_bkspc ( textbox *tb )
2012-08-24 01:28:39 +00:00
{
2014-06-04 19:29:23 +00:00
if ( tb->cursor > 0 ) {
2014-03-22 20:04:19 +00:00
textbox_cursor_dec ( tb );
textbox_cursor_del ( tb );
2014-01-10 09:35:38 +00:00
}
2012-08-24 01:28:39 +00:00
}
static void textbox_cursor_bkspc_word ( textbox *tb )
{
if ( tb->cursor > 0 ) {
int cursor = tb->cursor;
textbox_cursor_dec_word ( tb );
if ( cursor > tb->cursor ) {
textbox_delete ( tb, tb->cursor, cursor - tb->cursor );
}
}
}
static void textbox_cursor_del_word ( textbox *tb )
{
if ( tb->cursor >= 0 ) {
int cursor = tb->cursor;
textbox_cursor_inc_word ( tb );
if ( cursor < tb->cursor ) {
textbox_delete ( tb, cursor, tb->cursor - cursor );
}
}
}
2012-08-24 01:28:39 +00:00
// handle a keypress in edit mode
2015-08-29 21:02:30 +00:00
// 2 = nav
2012-08-24 01:28:39 +00:00
// 0 = unhandled
// 1 = handled
// -1 = handled and return pressed (finished)
2015-09-26 18:34:34 +00:00
int textbox_keypress ( textbox *tb, XIC xic, XEvent *ev )
2012-08-24 01:28:39 +00:00
{
2014-01-10 09:35:38 +00:00
KeySym key;
Status stat;
2014-03-22 20:04:19 +00:00
char pad[32];
int len;
2014-01-10 09:35:38 +00:00
2014-06-04 19:29:23 +00:00
if ( !( tb->flags & TB_EDITABLE ) ) {
2014-03-22 20:04:19 +00:00
return 0;
}
2014-01-10 09:35:38 +00:00
2015-09-26 18:34:34 +00:00
len = Xutf8LookupString ( xic, &ev->xkey, pad, sizeof ( pad ), &key, &stat );
2014-01-10 09:35:38 +00:00
pad[len] = 0;
2014-08-03 19:51:31 +00:00
// Left or Ctrl-b
if ( abe_test_action ( MOVE_CHAR_BACK, ev->xkey.state, key ) ) {
textbox_cursor_dec ( tb );
2015-08-29 21:02:30 +00:00
return 2;
2014-03-22 20:04:19 +00:00
}
2014-08-03 19:51:31 +00:00
// Right or Ctrl-F
else if ( abe_test_action ( MOVE_CHAR_FORWARD, ev->xkey.state, key ) ) {
2014-03-22 20:04:19 +00:00
textbox_cursor_inc ( tb );
2015-08-29 21:02:30 +00:00
return 2;
2014-08-03 19:51:31 +00:00
}
2014-08-03 19:51:31 +00:00
// Ctrl-U: Kill from the beginning to the end of the line.
else if ( abe_test_action ( CLEAR_LINE, ev->xkey.state, key ) ) {
textbox_text ( tb, "" );
2014-08-03 19:51:31 +00:00
return 1;
}
// Ctrl-A
else if ( abe_test_action ( MOVE_FRONT, ev->xkey.state, key ) ) {
2014-08-03 19:51:31 +00:00
textbox_cursor ( tb, 0 );
2015-08-29 21:02:30 +00:00
return 2;
2014-08-03 19:51:31 +00:00
}
// Ctrl-E
else if ( abe_test_action ( MOVE_END, ev->xkey.state, key ) ) {
2014-08-03 19:51:31 +00:00
textbox_cursor_end ( tb );
2015-08-29 21:02:30 +00:00
return 2;
2014-08-03 19:51:31 +00:00
}
// Ctrl-Alt-h
else if ( abe_test_action ( REMOVE_WORD_BACK, ev->xkey.state, key ) ) {
textbox_cursor_bkspc_word ( tb );
return 1;
}
// Ctrl-Alt-d
else if ( abe_test_action ( REMOVE_WORD_FORWARD, ev->xkey.state, key ) ) {
textbox_cursor_del_word ( tb );
return 1;
} // Delete or Ctrl-D
else if ( abe_test_action ( REMOVE_CHAR_FORWARD, ev->xkey.state, key ) ) {
textbox_cursor_del ( tb );
return 1;
}
// Alt-B
2015-04-30 20:42:04 +00:00
else if ( abe_test_action ( MOVE_WORD_BACK, ev->xkey.state, key ) ) {
textbox_cursor_dec_word ( tb );
2015-08-29 21:02:30 +00:00
return 2;
}
// Alt-F
2015-04-30 20:42:04 +00:00
else if ( abe_test_action ( MOVE_WORD_FORWARD, ev->xkey.state, key ) ) {
textbox_cursor_inc_word ( tb );
2015-08-29 21:02:30 +00:00
return 2;
}
2014-08-03 19:51:31 +00:00
// BackSpace, Ctrl-h
2015-04-30 20:42:04 +00:00
else if ( abe_test_action ( REMOVE_CHAR_BACK, ev->xkey.state, key ) ) {
2014-03-22 20:04:19 +00:00
textbox_cursor_bkspc ( tb );
2014-01-10 09:35:38 +00:00
return 1;
2014-03-22 20:04:19 +00:00
}
else if ( abe_test_action ( ACCEPT_CUSTOM, ev->xkey.state, key ) ) {
return -2;
}
else if ( abe_test_action ( ACCEPT_ENTRY_CONTINUE, ev->xkey.state, key ) ) {
2015-05-01 06:16:52 +00:00
return -3;
}
else if ( abe_test_action ( ACCEPT_ENTRY, ev->xkey.state, key ) ) {
2014-01-10 09:35:38 +00:00
return -1;
2014-03-22 20:04:19 +00:00
}
2014-06-04 19:29:23 +00:00
else if ( !iscntrl ( *pad ) ) {
2014-03-22 20:04:19 +00:00
textbox_insert ( tb, tb->cursor, pad );
textbox_cursor_inc ( tb );
2014-01-10 09:35:38 +00:00
return 1;
}
return 0;
2012-08-24 01:28:39 +00:00
}
/***
* Font setup.
*/
2015-09-28 19:41:58 +00:00
static void parse_color ( Display *display, char *bg, Color *col )
{
2015-10-10 11:43:28 +00:00
unsigned int val = 0;
val = color_get ( display, bg, "white" );
col->alpha = ( ( val & 0xFF000000 ) >> 24 ) / 256.0;
col->red = ( ( val & 0x00FF0000 ) >> 16 ) / 256.0;
col->green = ( ( val & 0x0000FF00 ) >> 8 ) / 256.0;
col->blue = ( ( val & 0x000000FF ) ) / 256.0;
}
2015-09-28 19:41:58 +00:00
static void textbox_parse_string ( Display *display, const char *str, RowColor *color )
2015-04-06 15:13:26 +00:00
{
if ( str == NULL ) {
return;
}
char *cstr = g_strdup ( str );
2015-10-18 17:02:19 +00:00
char *endp = NULL;
2015-04-06 15:13:26 +00:00
char *token;
int index = 0;
2015-09-19 18:59:50 +00:00
for ( token = strtok_r ( cstr, ",", &endp ); token != NULL; token = strtok_r ( NULL, ",", &endp ) ) {
2015-04-06 15:13:26 +00:00
switch ( index )
{
case 0:
2015-09-28 19:41:58 +00:00
parse_color ( display, g_strstrip ( token ), &( color->bg ) );
2015-04-06 15:13:26 +00:00
break;
case 1:
2015-09-28 19:41:58 +00:00
parse_color ( display, g_strstrip ( token ), &( color->fg ) );
2015-04-06 15:13:26 +00:00
break;
case 2:
2015-09-28 19:41:58 +00:00
parse_color ( display, g_strstrip ( token ), &( color->bgalt ) );
2015-04-06 15:13:26 +00:00
break;
case 3:
2015-09-28 19:41:58 +00:00
parse_color ( display, g_strstrip ( token ), &( color->hlbg ) );
2015-04-06 15:13:26 +00:00
break;
case 4:
2015-09-28 19:41:58 +00:00
parse_color ( display, g_strstrip ( token ), &( color->hlfg ) );
2015-04-06 15:13:26 +00:00
break;
}
index++;
}
g_free ( cstr );
}
2015-09-28 19:41:58 +00:00
void textbox_setup ( Display *display )
{
if ( config.color_enabled ) {
2015-09-28 19:41:58 +00:00
textbox_parse_string ( display, config.color_normal, &( colors[NORMAL] ) );
textbox_parse_string ( display, config.color_urgent, &( colors[URGENT] ) );
textbox_parse_string ( display, config.color_active, &( colors[ACTIVE] ) );
}
else {
2015-09-28 19:41:58 +00:00
parse_color ( display, config.menu_bg, &( colors[NORMAL].bg ) );
parse_color ( display, config.menu_fg, &( colors[NORMAL].fg ) );
parse_color ( display, config.menu_bg_alt, &( colors[NORMAL].bgalt ) );
parse_color ( display, config.menu_hlfg, &( colors[NORMAL].hlfg ) );
parse_color ( display, config.menu_hlbg, &( colors[NORMAL].hlbg ) );
parse_color ( display, config.menu_bg_urgent, &( colors[URGENT].bg ) );
parse_color ( display, config.menu_fg_urgent, &( colors[URGENT].fg ) );
parse_color ( display, config.menu_bg_alt, &( colors[URGENT].bgalt ) );
parse_color ( display, config.menu_hlfg_urgent, &( colors[URGENT].hlfg ) );
parse_color ( display, config.menu_hlbg_urgent, &( colors[URGENT].hlbg ) );
parse_color ( display, config.menu_bg_active, &( colors[ACTIVE].bg ) );
parse_color ( display, config.menu_fg_active, &( colors[ACTIVE].fg ) );
parse_color ( display, config.menu_bg_alt, &( colors[ACTIVE].bgalt ) );
parse_color ( display, config.menu_hlfg_active, &( colors[ACTIVE].hlfg ) );
parse_color ( display, config.menu_hlbg_active, &( colors[ACTIVE].hlbg ) );
2015-09-26 18:34:34 +00:00
}
PangoFontMap *font_map = pango_cairo_font_map_new ();
2014-08-02 18:02:37 +00:00
p_context = pango_font_map_create_context ( font_map );
2015-09-26 18:34:34 +00:00
g_object_unref ( font_map );
2015-04-06 15:13:26 +00:00
}
void textbox_cleanup ( void )
{
2014-08-02 18:02:37 +00:00
if ( p_context ) {
g_object_unref ( p_context );
2015-09-26 18:34:34 +00:00
p_context = NULL;
}
}
2014-08-02 18:02:37 +00:00
int textbox_get_width ( textbox *tb )
{
return textbox_get_font_width ( tb ) + 2 * SIDE_MARGIN;
}
int textbox_get_height ( textbox *tb )
{
return textbox_get_font_height ( tb ) + 2 * SIDE_MARGIN;
2014-08-02 18:02:37 +00:00
}
int textbox_get_font_height ( textbox *tb )
{
int height;
pango_layout_get_pixel_size ( tb->layout, NULL, &height );
return height;
}
int textbox_get_font_width ( textbox *tb )
{
int width;
pango_layout_get_pixel_size ( tb->layout, &width, NULL );
return width;
}
double textbox_get_estimated_char_width ( void )
{
PangoFontDescription *pfd = pango_font_description_from_string ( config.menu_font );
// Get width
PangoFontMetrics *metric = pango_context_get_metrics ( p_context, pfd, NULL );
int width = pango_font_metrics_get_approximate_char_width ( metric );
pango_font_metrics_unref ( metric );
2015-09-30 06:58:39 +00:00
pango_font_description_free ( pfd );
return ( width ) / (double) PANGO_SCALE;
}
int textbox_get_estimated_char_height ( void )
{
// Set font.
PangoFontDescription *pfd = pango_font_description_from_string ( config.menu_font );
// Get width
PangoFontMetrics *metric = pango_context_get_metrics ( p_context, pfd, NULL );
2015-09-19 18:59:50 +00:00
int height = pango_font_metrics_get_ascent ( metric ) + pango_font_metrics_get_descent ( metric );
pango_font_metrics_unref ( metric );
pango_font_description_free ( pfd );
return ( height ) / PANGO_SCALE + 2 * SIDE_MARGIN;
}