static gboolean
mcview_nroff_get_char (mcview_nroff_t * nroff, int *ret_val, off_t nroff_index)
{
int c = 0;
#ifdef HAVE_CHARSET
if (nroff->view->utf8)
{
if (!mcview_get_utf (nroff->view, nroff_index, &c, &nroff->char_length))
{
/* we need got symbol in any case */
nroff->char_length = 1;
if (!mcview_get_byte (nroff->view, nroff_index, &c) || !g_ascii_isprint (c))
return FALSE;
}
}
else
#endif
{
nroff->char_length = 1;
if (!mcview_get_byte (nroff->view, nroff_index, &c))
return FALSE;
}
*ret_val = c;
return g_unichar_isprint (c);
}
static void
print_unicode (const gchar *ptr)
{
gunichar wc;
wc = g_utf8_get_char_validated (ptr, -1);
g_print ("%s <=> %" G_GUINT32_FORMAT ", IS_print: %d\n", ptr, wc, g_unichar_isprint (wc));
}
static int
str_utf8_isprint (const char *ch)
{
gunichar uni;
uni = g_utf8_get_char_validated (ch, -1);
return g_unichar_isprint (uni);
}
/* utiliti function, that make string valid in utf8 and all characters printable
* return width of string too*/
static const struct term_form *
str_utf8_make_make_term_form (const char *text, size_t length)
{
static struct term_form result;
gunichar uni;
size_t left;
char *actual;
result.text[0] = '\0';
result.width = 0;
result.compose = 0;
actual = result.text;
/* check if text start with combining character,
* add space at begin in this case */
if (length != 0 && text[0] != '\0')
{
uni = g_utf8_get_char_validated (text, -1);
if ((uni != (gunichar) (-1)) && (uni != (gunichar) (-2)))
{
if (str_unichar_iscombiningmark (uni))
{
actual[0] = ' ';
actual++;
result.width++;
result.compose = 1;
}
}
}
while (length != 0 && text[0] != '\0') {
uni = g_utf8_get_char_validated (text, -1);
if ((uni != (gunichar)(-1)) && (uni != (gunichar)(-2))) {
if (g_unichar_isprint(uni)) {
left = g_unichar_to_utf8 (uni, actual);
actual+= left;
if (!str_unichar_iscombiningmark (uni)) {
result.width++;
if (g_unichar_iswide(uni)) result.width++;
} else result.compose = 1;
} else {
actual[0] = '.';
actual++;
result.width++;
}
text = g_utf8_next_char (text);
} else {
text++;
/*actual[0] = '?';*/
memcpy (actual, replch, strlen (replch));
actual+= strlen (replch);
result.width++;
}
if (length != (size_t) (-1)) length--; }
actual[0] = '\0';
return &result;
}
static int
_inp_printable(const wint_t ch)
{
char bytes[MB_CUR_MAX+1];
size_t utf_len = wcrtomb(bytes, ch, NULL);
bytes[utf_len] = '\0';
gunichar unichar = g_utf8_get_char(bytes);
return g_unichar_isprint(unichar) && (ch != KEY_MOUSE);
}
/**
* gsc_utils_char_is_separator:
* @ch: The character to check
*
* A separator is a character like (, an space etc. An _ is not a separator
*
* Returns TRUE if the ch is a separator
*/
gboolean
gsc_utils_is_separator(const gunichar ch)
{
if (g_unichar_isprint(ch) &&
(g_unichar_isalnum(ch) || ch == g_utf8_get_char("_")))
{
return FALSE;
}
return TRUE;
}
/**
* Reads a line of data from the reader.
*/
Glib::ustring BasicReader::readWord()
{
Glib::ustring str;
while (available() > 0)
{
gunichar ch = get();
if (!g_unichar_isprint(ch))
break;
str.push_back(ch);
}
return str;
}
static gboolean
mcview_isprint (const WView * view, int c)
{
#ifdef HAVE_CHARSET
if (!view->utf8)
c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
return g_unichar_isprint (c);
#else
(void) view;
/* TODO this is very-very buggy by design: ticket 3257 comments 0-1 */
return is_printable (c);
#endif /* HAVE_CHARSET */
}
/**
* gimp_tag_string_make_valid:
* @tag_string: a text string.
*
* Tries to create a valid tag string from given @tag_string.
*
* Return value: a newly allocated tag string in case given @tag_string was
* valid or could be fixed, otherwise NULL. Allocated value should be freed
* using g_free().
**/
gchar *
gimp_tag_string_make_valid (const gchar *tag_string)
{
gchar *tag;
GString *buffer;
gchar *tag_cursor;
gunichar c;
g_return_val_if_fail (tag_string, NULL);
tag = g_utf8_normalize (tag_string, -1, G_NORMALIZE_ALL);
if (! tag)
return NULL;
tag = g_strstrip (tag);
if (! *tag)
{
g_free (tag);
return NULL;
}
buffer = g_string_new ("");
tag_cursor = tag;
if (g_str_has_prefix (tag_cursor, GIMP_TAG_INTERNAL_PREFIX))
{
tag_cursor += strlen (GIMP_TAG_INTERNAL_PREFIX);
}
do
{
c = g_utf8_get_char (tag_cursor);
tag_cursor = g_utf8_next_char (tag_cursor);
if (g_unichar_isprint (c)
&& ! gimp_tag_is_tag_separator (c))
{
g_string_append_unichar (buffer, c);
}
} while (c);
g_free (tag);
tag = g_string_free (buffer, FALSE);
tag = g_strstrip (tag);
if (! *tag)
{
g_free (tag);
return NULL;
}
return tag;
}
/* Check if an entire UTF-8 string is printable. */
gboolean
isprint_utf8_string(const gchar *str, guint length)
{
const char *c;
if (!g_utf8_validate (str, length, NULL)) {
return FALSE;
}
for (c = str; *c; c = g_utf8_next_char(c)) {
if (!g_unichar_isprint(g_utf8_get_char(c))) {
return FALSE;
}
}
return TRUE;
}
/**
* clean_name code from mail-to-task plugin (gpl)
**/
static gchar *
clean_name(const guchar *s) {
GString *out = g_string_new("");
guint32 c;
gchar *r;
while ((c = camel_utf8_getc((const guchar **) & s))) {
if (!g_unichar_isprint(c) || (c < 0x7f && strchr(" /'\"`&();|<>$%{}!", c)))
c = '_';
g_string_append_u(out, c);
}
r = g_strdup(out->str);
g_string_free(out, TRUE);
return r;
}
static int
str_utf8_column_to_pos (const char *text, size_t pos)
{
static int result;
gunichar uni;
int width;
width = 0;
result = 0;
while (text[0] != '\0')
{
uni = g_utf8_get_char_validated (text, 6);
if ((uni != (gunichar) (-1)) && (uni != (gunichar) (-2)))
{
if (g_unichar_isprint (uni))
{
if (!str_unichar_iscombiningmark (uni))
{
width++;
if (g_unichar_iswide (uni))
width++;
}
}
else
{
width++;
}
text = g_utf8_next_char (text);
}
else
{
text++;
width++;
}
if ((gsize)width > pos)
return result;
result++;
}
return result;
}
// Hostnames are zero to 40 codepoints, and must only contain
// graphical codepoints.
gboolean hostname_validate (gchar *str)
{
glong len;
gchar *p;
if (str == NULL)
return FALSE;
if (!g_utf8_validate (str, -1, NULL))
return FALSE;
len = g_utf8_strlen (str, -1);
if (len > JZ_MSG_MAX_HOSTNAME_LENGTH)
return FALSE;
p = str;
for (glong i = 0; i < len; i ++)
{
if (!g_unichar_isprint (g_utf8_get_char (p)))
return FALSE;
p = g_utf8_next_char (p);
}
return TRUE;
}
static int
mcview_char_display (const WView * view, int c, char *s)
{
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!view->utf8)
c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
if (!g_unichar_isprint (c))
c = '.';
return g_unichar_to_utf8 (c, s);
}
if (view->utf8)
{
if (g_unichar_iswide (c))
{
s[0] = s[1] = '.';
return 2;
}
if (g_unichar_iszerowidth (c))
return 0;
/* TODO the is_printable check below will be broken for this */
c = convert_from_utf_to_current_c (c, view->converter);
}
else
{
/* TODO the is_printable check below will be broken for this */
c = convert_to_display_c (c);
}
#else
(void) view;
#endif /* HAVE_CHARSET */
/* TODO this is very-very buggy by design: ticket 3257 comments 0-1 */
if (!is_printable (c))
c = '.';
*s = c;
return 1;
}
// Addresses are 1 to 16 codepoints, and must start and end
// with a non-space codepoint
gboolean address_validate (gchar *str)
{
glong len;
gchar *p;
if (str == NULL)
return FALSE;
if (!g_utf8_validate (str, -1, NULL))
return FALSE;
len = g_utf8_strlen (str, -1);
if (len == 0 || len > JZ_MSG_MAX_ADDRESS_LENGTH)
return FALSE;
p = str;
for (glong i = 0; i < len; i ++)
{
if ((i == 0 || i == len - 1) && (!g_unichar_isgraph (g_utf8_get_char (p))))
return FALSE;
else if (!g_unichar_isprint (g_utf8_get_char (p)))
return FALSE;
p = g_utf8_next_char (p);
}
return TRUE;
}
bool WebPopupMenuProxyGtk::typeAheadFind(GdkEventKey* event)
{
// If we were given a non-printable character just skip it.
gunichar unicodeCharacter = gdk_keyval_to_unicode(event->keyval);
if (!g_unichar_isprint(unicodeCharacter)) {
resetTypeAheadFindState();
return false;
}
glong charactersWritten;
GUniquePtr<gunichar2> utf16String(g_ucs4_to_utf16(&unicodeCharacter, 1, nullptr, &charactersWritten, nullptr));
if (!utf16String) {
resetTypeAheadFindState();
return false;
}
// If the character is the same as the last character, the user is probably trying to
// cycle through the menulist entries. This matches the WebCore behavior for collapsed menulists.
static const uint32_t searchTimeoutMs = 1000;
bool repeatingCharacter = unicodeCharacter != m_previousKeyEventCharacter;
if (event->time - m_previousKeyEventTimestamp > searchTimeoutMs)
m_currentSearchString = String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten);
else if (repeatingCharacter)
m_currentSearchString.append(String(reinterpret_cast<UChar*>(utf16String.get()), charactersWritten));
m_previousKeyEventTimestamp = event->time;
m_previousKeyEventCharacter = unicodeCharacter;
GUniquePtr<GList> children(gtk_container_get_children(GTK_CONTAINER(m_popup)));
if (!children)
return true;
// We case fold before searching, because strncmp does not handle non-ASCII characters.
GUniquePtr<gchar> searchStringWithCaseFolded(g_utf8_casefold(m_currentSearchString.utf8().data(), -1));
size_t prefixLength = strlen(searchStringWithCaseFolded.get());
// If a menu item has already been selected, start searching from the current
// item down the list. This will make multiple key presses of the same character
// advance the selection.
GList* currentChild = children.get();
if (m_currentlySelectedMenuItem) {
currentChild = g_list_find(children.get(), m_currentlySelectedMenuItem);
if (!currentChild) {
m_currentlySelectedMenuItem = nullptr;
currentChild = children.get();
}
// Repeating characters should iterate.
if (repeatingCharacter) {
if (GList* nextChild = g_list_next(currentChild))
currentChild = nextChild;
}
}
GList* firstChild = currentChild;
do {
currentChild = g_list_next(currentChild);
if (!currentChild)
currentChild = children.get();
GUniquePtr<gchar> itemText(g_utf8_casefold(gtk_menu_item_get_label(GTK_MENU_ITEM(currentChild->data)), -1));
if (!strncmp(searchStringWithCaseFolded.get(), itemText.get(), prefixLength)) {
gtk_menu_shell_select_item(GTK_MENU_SHELL(m_popup), GTK_WIDGET(currentChild->data));
break;
}
} while (currentChild != firstChild);
return true;
}
int dt_control_key_pressed_override(guint key, guint state)
{
dt_control_accels_t *accels = &darktable.control->accels;
// TODO: if darkroom mode
// did a : vim-style command start?
static GList *autocomplete = NULL;
static char vimkey_input[256];
if(darktable.control->vimkey_cnt)
{
guchar unichar = gdk_keyval_to_unicode(key);
if(key == GDK_KEY_Return)
{
if(!strcmp(darktable.control->vimkey, ":q"))
{
dt_control_quit();
}
else
{
dt_bauhaus_vimkey_exec(darktable.control->vimkey);
}
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Escape)
{
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_BackSpace)
{
darktable.control->vimkey_cnt
-= (darktable.control->vimkey + darktable.control->vimkey_cnt)
- g_utf8_prev_char(darktable.control->vimkey + darktable.control->vimkey_cnt);
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
if(darktable.control->vimkey_cnt == 0)
dt_control_log_ack_all();
else
dt_control_log("%s", darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Tab)
{
// TODO: also support :preset and :get?
// auto complete:
if(darktable.control->vimkey_cnt < 5)
{
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set ");
darktable.control->vimkey_cnt = 5;
}
else if(!autocomplete)
{
// TODO: handle '.'-separated things separately
// this is a static list, and tab cycles through the list
g_strlcpy(vimkey_input, darktable.control->vimkey + 5, sizeof(vimkey_input));
autocomplete = dt_bauhaus_vimkey_complete(darktable.control->vimkey + 5);
autocomplete = g_list_append(autocomplete, vimkey_input); // remember input to cycle back
}
if(autocomplete)
{
// pop first.
// the paths themselves are owned by bauhaus,
// no free required.
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set %s",
(char *)autocomplete->data);
autocomplete = g_list_remove(autocomplete, autocomplete->data);
darktable.control->vimkey_cnt = strlen(darktable.control->vimkey);
}
dt_control_log("%s", darktable.control->vimkey);
}
else if(g_unichar_isprint(unichar)) // printable unicode character
{
gchar utf8[6];
gint char_width = g_unichar_to_utf8(unichar, utf8);
if(darktable.control->vimkey_cnt + 1 + char_width < 256)
{
g_utf8_strncpy(darktable.control->vimkey + darktable.control->vimkey_cnt, utf8, 1);
darktable.control->vimkey_cnt += char_width;
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
dt_control_log("%s", darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
}
else if(key == GDK_KEY_Up)
{
// TODO: step history up and copy to vimkey
}
else if(key == GDK_KEY_Down)
{
// TODO: step history down and copy to vimkey
}
return 1;
}
else if(key == ':' && darktable.control->key_accelerators_on)
{
darktable.control->vimkey[0] = ':';
darktable.control->vimkey[1] = 0;
darktable.control->vimkey_cnt = 1;
dt_control_log("%s", darktable.control->vimkey);
return 1;
}
/* check if key accelerators are enabled*/
if(darktable.control->key_accelerators_on != 1) return 0;
if(key == accels->global_sideborders.accel_key && state == accels->global_sideborders.accel_mods)
{
/* toggle panel viewstate */
dt_ui_toggle_panels_visibility(darktable.gui->ui);
/* trigger invalidation of centerview to reprocess pipe */
dt_dev_invalidate(darktable.develop);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
else if(key == accels->global_header.accel_key && state == accels->global_header.accel_mods)
{
char key[512];
const dt_view_t *cv = dt_view_manager_get_current_view(darktable.view_manager);
/* do nothing if in collapse panel state
TODO: reconsider adding this check to ui api */
g_snprintf(key, sizeof(key), "%s/ui/panel_collaps_state", cv->module_name);
if(dt_conf_get_int(key)) return 0;
/* toggle the header visibility state */
g_snprintf(key, sizeof(key), "%s/ui/show_header", cv->module_name);
gboolean header = !dt_conf_get_bool(key);
dt_conf_set_bool(key, header);
/* show/hide the actual header panel */
dt_ui_panel_show(darktable.gui->ui, DT_UI_PANEL_TOP, header, TRUE);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
return 0;
}
void ImGui_ImplGtk3Cogl_HandleEvent(GdkEvent *event)
{
ImGuiIO& io = ImGui::GetIO();
GdkEventType type = gdk_event_get_event_type(event);
switch (type)
{
case GDK_MOTION_NOTIFY:
{
gdouble x = 0.0f, y = 0.0f;
if (gdk_event_get_coords(event, &x, &y))
g_MousePosition = ImVec2(x, y);
break;
}
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
{
guint button = 0;
if (gdk_event_get_button(event, &button) && button > 0 && button <= 5)
{
if (type == GDK_BUTTON_PRESS)
g_MousePressed[button - 1] = true;
}
break;
}
case GDK_SCROLL:
{
gdouble x, y;
if (gdk_event_get_scroll_deltas(event, &x, &y))
g_MouseWheel = -y;
break;
}
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
{
GdkEventKey *e = (GdkEventKey *) event;
static const struct
{
enum ImGuiKey_ imgui;
guint gdk;
} gdk_key_to_imgui_key[] =
{
{ ImGuiKey_Tab, GDK_KEY_Tab },
{ ImGuiKey_Tab, GDK_KEY_ISO_Left_Tab },
{ ImGuiKey_LeftArrow, GDK_KEY_Left },
{ ImGuiKey_RightArrow, GDK_KEY_Right },
{ ImGuiKey_UpArrow, GDK_KEY_Up },
{ ImGuiKey_DownArrow, GDK_KEY_Down },
{ ImGuiKey_PageUp, GDK_KEY_Page_Up },
{ ImGuiKey_PageDown, GDK_KEY_Page_Down },
{ ImGuiKey_Home, GDK_KEY_Home },
{ ImGuiKey_End, GDK_KEY_End },
{ ImGuiKey_Delete, GDK_KEY_Delete },
{ ImGuiKey_Backspace, GDK_KEY_BackSpace },
{ ImGuiKey_Space, GDK_KEY_space },
{ ImGuiKey_Enter, GDK_KEY_Return },
{ ImGuiKey_Escape, GDK_KEY_Escape },
{ ImGuiKey_A, GDK_KEY_a },
{ ImGuiKey_C, GDK_KEY_c },
{ ImGuiKey_V, GDK_KEY_v },
{ ImGuiKey_X, GDK_KEY_x },
{ ImGuiKey_Y, GDK_KEY_y },
{ ImGuiKey_Z, GDK_KEY_z },
};
for (unsigned i = 0; i < ARRAY_SIZE(gdk_key_to_imgui_key); i++)
{
if (e->keyval == gdk_key_to_imgui_key[i].gdk)
io.KeysDown[gdk_key_to_imgui_key[i].imgui] = type == GDK_KEY_PRESS;
}
gunichar c = gdk_keyval_to_unicode(e->keyval);
if (g_unichar_isprint(c) && ImGuiKey_COUNT + c < ARRAY_SIZE(io.KeysDown))
io.KeysDown[ImGuiKey_COUNT + c] = type == GDK_KEY_PRESS;
if (type == GDK_KEY_PRESS && e->string)
io.AddInputCharactersUTF8(e->string);
struct {
bool *var;
GdkModifierType modifier;
guint keyvals[3];
} mods[] = {
{ &io.KeyCtrl, GDK_CONTROL_MASK,
{ GDK_KEY_Control_L, GDK_KEY_Control_R, 0 }, },
{ &io.KeyShift, GDK_SHIFT_MASK,
{ GDK_KEY_Shift_L, GDK_KEY_Shift_R, 0 }, },
{ &io.KeyAlt, GDK_MOD1_MASK,
{ GDK_KEY_Alt_L, GDK_KEY_Alt_R, 0 }, },
{ &io.KeySuper, GDK_SUPER_MASK,
{ GDK_KEY_Super_L, GDK_KEY_Super_R, 0 }, }
};
for (unsigned i = 0; i < ARRAY_SIZE(mods); i++)
{
*mods[i].var = (mods[i].modifier & e->state);
bool match = false;
for (int j = 0; mods[i].keyvals[j] != 0; j++)
if (e->keyval == mods[i].keyvals[j])
match = true;
if (match)
*mods[i].var = type == GDK_KEY_PRESS;
}
break;
}
default:
break;
}
// We trigger 2 subsequent redraws for each event because of the
// way some ImGui widgets work. For example a Popup menu will only
// appear a frame after a click happened.
g_NumRedraws = 2;
GdkFrameClock *clock = gdk_window_get_frame_clock(g_GdkWindow);
gdk_frame_clock_request_phase(clock, GDK_FRAME_CLOCK_PHASE_PAINT);
}
static gboolean
edit_translate_key (WEdit * edit, long x_key, int *cmd, int *ch)
{
long command = CK_InsertChar;
int char_for_insertion = -1;
/* an ordinary insertable character */
if (!edit->extmod && x_key < 256)
{
#ifndef HAVE_CHARSET
if (is_printable (x_key))
{
char_for_insertion = x_key;
goto fin;
}
#else
int c;
if (edit->charpoint >= 4)
{
edit->charpoint = 0;
edit->charbuf[edit->charpoint] = '\0';
}
if (edit->charpoint < 4)
{
edit->charbuf[edit->charpoint++] = x_key;
edit->charbuf[edit->charpoint] = '\0';
}
/* input from 8-bit locale */
if (!mc_global.utf8_display)
{
/* source in 8-bit codeset */
c = convert_from_input_c (x_key);
if (is_printable (c))
{
if (!edit->utf8)
char_for_insertion = c;
else
char_for_insertion = convert_from_8bit_to_utf_c2 ((char) x_key);
goto fin;
}
}
else
{
/* UTF-8 locale */
int res;
res = str_is_valid_char (edit->charbuf, edit->charpoint);
if (res < 0 && res != -2)
{
edit->charpoint = 0; /* broken multibyte char, skip */
goto fin;
}
if (edit->utf8)
{
/* source in UTF-8 codeset */
if (res < 0)
{
char_for_insertion = x_key;
goto fin;
}
edit->charbuf[edit->charpoint] = '\0';
edit->charpoint = 0;
if (g_unichar_isprint (g_utf8_get_char (edit->charbuf)))
{
char_for_insertion = x_key;
goto fin;
}
}
else
{
/* 8-bit source */
if (res < 0)
{
/* not finised multibyte input (in meddle multibyte utf-8 char) */
goto fin;
}
if (g_unichar_isprint (g_utf8_get_char (edit->charbuf)))
{
c = convert_from_utf_to_current (edit->charbuf);
edit->charbuf[0] = '\0';
edit->charpoint = 0;
char_for_insertion = c;
goto fin;
}
/* unprinteble utf input, skip it */
edit->charbuf[0] = '\0';
edit->charpoint = 0;
}
}
#endif /* HAVE_CHARSET */
}
/* Commands specific to the key emulation */
if (edit->extmod)
{
edit->extmod = FALSE;
command = keybind_lookup_keymap_command (editor_x_map, x_key);
}
else
command = keybind_lookup_keymap_command (editor_map, x_key);
if (command == CK_IgnoreKey)
command = CK_InsertChar;
fin:
*cmd = (int) command; /* FIXME */
*ch = char_for_insertion;
return !(command == CK_InsertChar && char_for_insertion == -1);
}
static gboolean
csv_tsv_probe (GOFileOpener const *fo, GsfInput *input, GOFileProbeLevel pl)
{
/* Rough and ready heuristic. If the first N bytes have no
* unprintable characters this may be text */
const gsf_off_t N = 512;
if (pl == GO_FILE_PROBE_CONTENT) {
guint8 const *header;
gsf_off_t i;
char const *enc = NULL;
GString *header_utf8;
char const *p;
gboolean ok = TRUE;
if (gsf_input_seek (input, 0, G_SEEK_SET))
return FALSE;
i = gsf_input_remaining (input);
/* If someone ships us an empty file, accept it only if
it has a proper name. */
if (i == 0)
return csv_tsv_probe (fo, input, GO_FILE_PROBE_FILE_NAME);
if (i > N) i = N;
if (NULL == (header = gsf_input_read (input, i, NULL)))
return FALSE;
enc = go_guess_encoding (header, i, NULL, &header_utf8, NULL);
if (!enc)
return FALSE;
for (p = header_utf8->str; *p; p = g_utf8_next_char (p)) {
gunichar uc = g_utf8_get_char (p);
/* isprint might not be true for these: */
if (uc == '\n' || uc == '\t' || uc == '\r')
continue;
/* Also, ignore a byte-order mark which may be used to
* indicate UTF-8; see
* http://en.wikipedia.org/wiki/Byte_Order_Mark for
* background.
*/
if (p == header_utf8->str && uc == 0x0000FEFF) {
continue;
}
if (!g_unichar_isprint (uc)) {
ok = FALSE;
break;
}
}
g_string_free (header_utf8, TRUE);
return ok;
} else {
char const *name = gsf_input_name (input);
if (name == NULL)
return FALSE;
name = gsf_extension_pointer (name);
return (name != NULL &&
(g_ascii_strcasecmp (name, "csv") == 0 ||
g_ascii_strcasecmp (name, "tsv") == 0 ||
g_ascii_strcasecmp (name, "txt") == 0));
}
}
static void
edit_draw_this_line (WEdit * edit, long b, long row, long start_col, long end_col)
{
struct line_s line[MAX_LINE_LEN];
struct line_s *p = line;
long m1 = 0, m2 = 0, q, c1, c2;
int col, start_col_real;
unsigned int c;
int color;
int abn_style;
int i;
int utf8lag = 0;
unsigned int cur_line = 0;
int book_mark = 0;
char line_stat[LINE_STATE_WIDTH + 1] = "\0";
if (row > edit->widget.lines - 1 - EDIT_TEXT_VERTICAL_OFFSET)
return;
if (book_mark_query_color (edit, edit->start_line + row, BOOK_MARK_COLOR))
book_mark = BOOK_MARK_COLOR;
else if (book_mark_query_color (edit, edit->start_line + row, BOOK_MARK_FOUND_COLOR))
book_mark = BOOK_MARK_FOUND_COLOR;
if (book_mark)
abn_style = book_mark << 16;
else
abn_style = MOD_ABNORMAL;
end_col -= EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width;
edit_get_syntax_color (edit, b - 1, &color);
q = edit_move_forward3 (edit, b, start_col - edit->start_col, 0);
start_col_real = (col = (int) edit_move_forward3 (edit, b, 0, q)) + edit->start_col;
if (option_line_state)
{
cur_line = edit->start_line + row;
if (cur_line <= (unsigned int) edit->total_lines)
{
g_snprintf (line_stat, LINE_STATE_WIDTH + 1, "%7i ", cur_line + 1);
}
else
{
memset (line_stat, ' ', LINE_STATE_WIDTH);
line_stat[LINE_STATE_WIDTH] = '\0';
}
if (book_mark_query_color (edit, cur_line, BOOK_MARK_COLOR))
{
g_snprintf (line_stat, 2, "*");
}
}
if (col + 16 > -edit->start_col)
{
eval_marks (edit, &m1, &m2);
if (row <= edit->total_lines - edit->start_line)
{
long tws = 0;
if (tty_use_colors () && visible_tws)
{
tws = edit_eol (edit, b);
while (tws > b && ((c = edit_get_byte (edit, tws - 1)) == ' ' || c == '\t'))
tws--;
}
while (col <= end_col - edit->start_col)
{
int cw = 1;
p->ch = 0;
p->style = 0;
if (q == edit->curs1)
p->style |= MOD_CURSOR;
if (q >= m1 && q < m2)
{
if (edit->column_highlight)
{
int x;
x = edit_move_forward3 (edit, b, 0, q);
c1 = min (edit->column1, edit->column2);
c2 = max (edit->column1, edit->column2);
if (x >= c1 && x < c2)
p->style |= MOD_MARKED;
}
else
p->style |= MOD_MARKED;
}
if (q == edit->bracket)
p->style |= MOD_BOLD;
if (q >= edit->found_start && q < edit->found_start + edit->found_len)
p->style |= MOD_BOLD;
if (!edit->utf8)
{
c = edit_get_byte (edit, q);
}
else
{
c = edit_get_utf (edit, q, &cw);
}
/* we don't use bg for mc - fg contains both */
if (book_mark)
{
p->style |= book_mark << 16;
}
else
{
edit_get_syntax_color (edit, q, &color);
p->style |= color << 16;
}
switch (c)
{
case '\n':
col = (end_col + utf8lag) - edit->start_col + 1; /* quit */
break;
case '\t':
i = TAB_SIZE - ((int) col % TAB_SIZE);
col += i;
if (tty_use_colors () &&
((visible_tabs || (visible_tws && q >= tws)) && enable_show_tabs_tws))
{
if (p->style & MOD_MARKED)
c = p->style;
else if (book_mark)
c |= book_mark << 16;
else
c = p->style | MOD_WHITESPACE;
if (i > 2)
{
p->ch = '<';
p->style = c;
p++;
while (--i > 1)
{
p->ch = '-';
p->style = c;
p++;
}
p->ch = '>';
p->style = c;
p++;
}
else if (i > 1)
{
p->ch = '<';
p->style = c;
p++;
p->ch = '>';
p->style = c;
p++;
}
else
{
p->ch = '>';
p->style = c;
p++;
}
}
else if (tty_use_colors () && visible_tws && q >= tws && enable_show_tabs_tws)
{
p->ch = '.';
p->style |= MOD_WHITESPACE;
c = p->style & ~MOD_CURSOR;
p++;
while (--i)
{
p->ch = ' ';
p->style = c;
p++;
}
}
else
{
p->ch |= ' ';
c = p->style & ~MOD_CURSOR;
p++;
while (--i)
{
p->ch = ' ';
p->style = c;
p++;
}
}
break;
case ' ':
if (tty_use_colors () && visible_tws && q >= tws && enable_show_tabs_tws)
{
p->ch = '.';
p->style |= MOD_WHITESPACE;
p++;
col++;
break;
}
/* fallthrough */
default:
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!edit->utf8)
{
c = convert_from_8bit_to_utf_c ((unsigned char) c, edit->converter);
}
}
else if (edit->utf8)
c = convert_from_utf_to_current_c (c, edit->converter);
else
#endif
c = convert_to_display_c (c);
/* Caret notation for control characters */
if (c < 32)
{
p->ch = '^';
p->style = abn_style;
p++;
p->ch = c + 0x40;
p->style = abn_style;
p++;
col += 2;
break;
}
if (c == 127)
{
p->ch = '^';
p->style = abn_style;
p++;
p->ch = '?';
p->style = abn_style;
p++;
col += 2;
break;
}
if (!edit->utf8)
{
if ((mc_global.utf8_display && g_unichar_isprint (c)) ||
(!mc_global.utf8_display && is_printable (c)))
{
p->ch = c;
p++;
}
else
{
p->ch = '.';
p->style = abn_style;
p++;
}
}
else
{
if (g_unichar_isprint (c))
{
p->ch = c;
p++;
}
else
{
p->ch = '.';
p->style = abn_style;
p++;
}
}
col++;
break;
} /* case */
q++;
if (cw > 1)
{
q += cw - 1;
}
}
}
}
else
{
start_col_real = start_col = 0;
}
p->ch = '\0';
print_to_widget (edit, row, start_col, start_col_real, end_col, line, line_stat, book_mark);
}
static void
edit_draw_this_line (WEdit * edit, off_t b, long row, long start_col, long end_col)
{
Widget *w = WIDGET (edit);
struct line_s line[MAX_LINE_LEN];
struct line_s *p = line;
off_t m1 = 0, m2 = 0, q;
int col, start_col_real;
int color;
int abn_style;
int book_mark = 0;
char line_stat[LINE_STATE_WIDTH + 1] = "\0";
if (row > w->lines - 1 - EDIT_TEXT_VERTICAL_OFFSET - 2 * (edit->fullscreen ? 0 : 1))
return;
if (book_mark_query_color (edit, edit->start_line + row, BOOK_MARK_COLOR))
book_mark = BOOK_MARK_COLOR;
else if (book_mark_query_color (edit, edit->start_line + row, BOOK_MARK_FOUND_COLOR))
book_mark = BOOK_MARK_FOUND_COLOR;
if (book_mark)
abn_style = book_mark << 16;
else
abn_style = MOD_ABNORMAL;
end_col -= EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width;
if (!edit->fullscreen)
{
end_col--;
if (w->x + w->cols <= WIDGET (w->owner)->cols)
end_col--;
}
color = edit_get_syntax_color (edit, b - 1);
q = edit_move_forward3 (edit, b, start_col - edit->start_col, 0);
start_col_real = (col = (int) edit_move_forward3 (edit, b, 0, q)) + edit->start_col;
if (option_line_state)
{
unsigned int cur_line;
cur_line = edit->start_line + row;
if (cur_line <= (unsigned int) edit->buffer.lines)
{
g_snprintf (line_stat, LINE_STATE_WIDTH + 1, "%7i ", cur_line + 1);
}
else
{
memset (line_stat, ' ', LINE_STATE_WIDTH);
line_stat[LINE_STATE_WIDTH] = '\0';
}
if (book_mark_query_color (edit, cur_line, BOOK_MARK_COLOR))
{
g_snprintf (line_stat, 2, "*");
}
}
if (col + 16 > -edit->start_col)
{
eval_marks (edit, &m1, &m2);
if (row <= edit->buffer.lines - edit->start_line)
{
off_t tws = 0;
if (tty_use_colors () && visible_tws)
{
unsigned int c;
tws = edit_buffer_get_eol (&edit->buffer, b);
while (tws > b
&& ((c = edit_buffer_get_byte (&edit->buffer, tws - 1)) == ' ' || c == '\t'))
tws--;
}
while (col <= end_col - edit->start_col)
{
int char_length = 1;
unsigned int c;
gboolean wide_width_char = FALSE;
gboolean control_char = FALSE;
p->ch = 0;
p->style = 0;
if (q == edit->buffer.curs1)
p->style |= MOD_CURSOR;
if (q >= m1 && q < m2)
{
if (edit->column_highlight)
{
long x;
long c1, c2;
x = (long) edit_move_forward3 (edit, b, 0, q);
c1 = min (edit->column1, edit->column2);
c2 = max (edit->column1, edit->column2);
if (x >= c1 && x < c2)
p->style |= MOD_MARKED;
}
else
p->style |= MOD_MARKED;
}
if (q == edit->bracket)
p->style |= MOD_BOLD;
if (q >= edit->found_start && q < (off_t) (edit->found_start + edit->found_len))
p->style |= MOD_BOLD;
#ifdef HAVE_CHARSET
if (edit->utf8)
c = edit_buffer_get_utf (&edit->buffer, q, &char_length);
else
#endif
c = edit_buffer_get_byte (&edit->buffer, q);
/* we don't use bg for mc - fg contains both */
if (book_mark)
{
p->style |= book_mark << 16;
}
else
{
color = edit_get_syntax_color (edit, q);
p->style |= color << 16;
}
switch (c)
{
case '\n':
col = end_col - edit->start_col + 1; /* quit */
break;
case '\t':
{
int tab_over;
int i;
i = TAB_SIZE - ((int) col % TAB_SIZE);
tab_over = (end_col - edit->start_col) - (col + i - 1);
if (tab_over < 0)
i += tab_over;
col += i;
if (tty_use_colors () &&
((visible_tabs || (visible_tws && q >= tws)) && enable_show_tabs_tws))
{
if (p->style & MOD_MARKED)
c = p->style;
else if (book_mark)
c |= book_mark << 16;
else
c = p->style | MOD_WHITESPACE;
if (i > 2)
{
p->ch = '<';
p->style = c;
p++;
while (--i > 1)
{
p->ch = '-';
p->style = c;
p++;
}
p->ch = '>';
p->style = c;
p++;
}
else if (i > 1)
{
p->ch = '<';
p->style = c;
p++;
p->ch = '>';
p->style = c;
p++;
}
else
{
p->ch = '>';
p->style = c;
p++;
}
}
else if (tty_use_colors () && visible_tws && q >= tws
&& enable_show_tabs_tws)
{
p->ch = '.';
p->style |= MOD_WHITESPACE;
c = p->style & ~MOD_CURSOR;
p++;
while (--i)
{
p->ch = ' ';
p->style = c;
p++;
}
}
else
{
p->ch |= ' ';
c = p->style & ~MOD_CURSOR;
p++;
while (--i)
{
p->ch = ' ';
p->style = c;
p++;
}
}
}
break;
case ' ':
if (tty_use_colors () && visible_tws && q >= tws && enable_show_tabs_tws)
{
p->ch = '.';
p->style |= MOD_WHITESPACE;
p++;
col++;
break;
}
/* fallthrough */
default:
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!edit->utf8)
{
c = convert_from_8bit_to_utf_c ((unsigned char) c, edit->converter);
}
else
{
if (g_unichar_iswide (c))
{
wide_width_char = TRUE;
col++;
}
}
}
else if (edit->utf8)
c = convert_from_utf_to_current_c (c, edit->converter);
else
c = convert_to_display_c (c);
#endif
/* Caret notation for control characters */
if (c < 32)
{
p->ch = '^';
p->style = abn_style;
p++;
p->ch = c + 0x40;
p->style = abn_style;
p++;
col += 2;
control_char = TRUE;
break;
}
if (c == 127)
{
p->ch = '^';
p->style = abn_style;
p++;
p->ch = '?';
p->style = abn_style;
p++;
col += 2;
control_char = TRUE;
break;
}
#ifdef HAVE_CHARSET
if (edit->utf8)
{
if (g_unichar_isprint (c))
p->ch = c;
else
{
p->ch = '.';
p->style = abn_style;
}
p++;
}
else
#endif
{
if ((mc_global.utf8_display && g_unichar_isprint (c)) ||
(!mc_global.utf8_display && is_printable (c)))
{
p->ch = c;
p++;
}
else
{
p->ch = '.';
p->style = abn_style;
p++;
}
}
col++;
break;
} /* case */
q++;
if (char_length > 1)
q += char_length - 1;
if (col > (end_col - edit->start_col + 1))
{
if (wide_width_char)
{
p--;
break;
}
if (control_char)
{
p -= 2;
break;
}
}
}
}
}
else
{
start_col_real = start_col = 0;
}
p->ch = 0;
print_to_widget (edit, row, start_col, start_col_real, end_col, line, line_stat, book_mark);
}
void
mcview_display_hex (WView * view)
{
const screen_dimen top = view->data_area.top;
const screen_dimen left = view->data_area.left;
const screen_dimen height = view->data_area.height;
const screen_dimen width = view->data_area.width;
const int ngroups = view->bytes_per_line / 4;
/* 8 characters are used for the file offset, and every hex group
* takes 13 characters. Starting at width of 80 columns, the groups
* are separated by an extra vertical line. Starting at width of 81,
* there is an extra space before the text column. There is always a
* mostly empty column on the right, to allow overflowing CJKs.
*/
const screen_dimen text_start = 8 + 13 * ngroups +
((width < 80) ? 0 : (width == 80) ? (ngroups - 1) : (ngroups - 1 + 1));
int row;
off_t from;
mark_t boldflag_byte = MARK_NORMAL;
mark_t boldflag_char = MARK_NORMAL;
struct hexedit_change_node *curr = view->change_list;
#ifdef HAVE_CHARSET
int cont_bytes = 0; /* number of continuation bytes remanining from current UTF-8 */
gboolean cjk_right = FALSE; /* whether the second byte of a CJK is to be processed */
#endif /* HAVE_CHARSET */
gboolean utf8_changed = FALSE; /* whether any of the bytes in the UTF-8 were changed */
char hex_buff[10]; /* A temporary buffer for sprintf and mvwaddstr */
mcview_display_clean (view);
/* Find the first displayable changed byte */
/* In UTF-8 mode, go back by 1 or maybe 2 lines to handle continuation bytes properly. */
from = view->dpy_start;
row = 0;
#ifdef HAVE_CHARSET
if (view->utf8)
{
if (from >= view->bytes_per_line)
{
row--;
from -= view->bytes_per_line;
}
if (view->bytes_per_line == 4 && from >= view->bytes_per_line)
{
row--;
from -= view->bytes_per_line;
}
}
#endif /* HAVE_CHARSET */
while (curr && (curr->offset < from))
{
curr = curr->next;
}
for (; mcview_get_byte (view, from, NULL) && row < (int) height; row++)
{
screen_dimen col = 0;
size_t i;
int bytes; /* Number of bytes already printed on the line */
/* Print the hex offset */
if (row >= 0)
{
g_snprintf (hex_buff, sizeof (hex_buff), "%08" PRIXMAX " ", (uintmax_t) from);
widget_move (view, top + row, left);
tty_setcolor (VIEW_BOLD_COLOR);
for (i = 0; col < width && hex_buff[i] != '\0'; col++, i++)
tty_print_char (hex_buff[i]);
tty_setcolor (VIEW_NORMAL_COLOR);
}
for (bytes = 0; bytes < view->bytes_per_line; bytes++, from++)
{
int c;
#ifdef HAVE_CHARSET
int ch = 0;
if (view->utf8)
{
struct hexedit_change_node *corr = curr;
if (cont_bytes != 0)
{
/* UTF-8 continuation bytes, print a space (with proper attributes)... */
cont_bytes--;
ch = ' ';
if (cjk_right)
{
/* ... except when it'd wipe out the right half of a CJK, then print nothing */
cjk_right = FALSE;
ch = -1;
}
}
else
{
int j;
gchar utf8buf[UTF8_CHAR_LEN + 1];
int res;
int first_changed = -1;
for (j = 0; j < UTF8_CHAR_LEN; j++)
{
if (mcview_get_byte (view, from + j, &res))
utf8buf[j] = res;
else
{
utf8buf[j] = '\0';
break;
}
if (curr != NULL && from + j == curr->offset)
{
utf8buf[j] = curr->value;
if (first_changed == -1)
first_changed = j;
}
if (curr != NULL && from + j >= curr->offset)
curr = curr->next;
}
utf8buf[UTF8_CHAR_LEN] = '\0';
/* Determine the state of the current multibyte char */
ch = g_utf8_get_char_validated (utf8buf, -1);
if (ch == -1 || ch == -2)
{
ch = '.';
}
else
{
gchar *next_ch;
next_ch = g_utf8_next_char (utf8buf);
cont_bytes = next_ch - utf8buf - 1;
if (g_unichar_iswide (ch))
cjk_right = TRUE;
}
utf8_changed = (first_changed >= 0 && first_changed <= cont_bytes);
curr = corr;
}
}
#endif /* HAVE_CHARSET */
/* For negative rows, the only thing we care about is overflowing
* UTF-8 continuation bytes which were handled above. */
if (row < 0)
{
if (curr != NULL && from == curr->offset)
curr = curr->next;
continue;
}
if (!mcview_get_byte (view, from, &c))
break;
/* Save the cursor position for mcview_place_cursor() */
if (from == view->hex_cursor && !view->hexview_in_text)
{
view->cursor_row = row;
view->cursor_col = col;
}
/* Determine the state of the current byte */
boldflag_byte = mcview_hex_calculate_boldflag (view, from, curr, FALSE);
boldflag_char = mcview_hex_calculate_boldflag (view, from, curr, utf8_changed);
/* Determine the value of the current byte */
if (curr != NULL && from == curr->offset)
{
c = curr->value;
curr = curr->next;
}
/* Select the color for the hex number */
tty_setcolor (boldflag_byte == MARK_NORMAL ? VIEW_NORMAL_COLOR :
boldflag_byte == MARK_SELECTED ? VIEW_BOLD_COLOR :
boldflag_byte == MARK_CHANGED ? VIEW_UNDERLINED_COLOR :
/* boldflag_byte == MARK_CURSOR */
view->hexview_in_text ? VIEW_SELECTED_COLOR : VIEW_UNDERLINED_COLOR);
/* Print the hex number */
widget_move (view, top + row, left + col);
if (col < width)
{
tty_print_char (hex_char[c / 16]);
col += 1;
}
if (col < width)
{
tty_print_char (hex_char[c % 16]);
col += 1;
}
/* Print the separator */
tty_setcolor (VIEW_NORMAL_COLOR);
if (bytes != view->bytes_per_line - 1)
{
if (col < width)
{
tty_print_char (' ');
col += 1;
}
/* After every four bytes, print a group separator */
if (bytes % 4 == 3)
{
if (view->data_area.width >= 80 && col < width)
{
tty_print_one_vline (TRUE);
col += 1;
}
if (col < width)
{
tty_print_char (' ');
col += 1;
}
}
}
/* Select the color for the character; this differs from the
* hex color when boldflag == MARK_CURSOR */
tty_setcolor (boldflag_char == MARK_NORMAL ? VIEW_NORMAL_COLOR :
boldflag_char == MARK_SELECTED ? VIEW_BOLD_COLOR :
boldflag_char == MARK_CHANGED ? VIEW_UNDERLINED_COLOR :
/* boldflag_char == MARK_CURSOR */
view->hexview_in_text ? VIEW_SELECTED_COLOR : MARKED_SELECTED_COLOR);
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!view->utf8)
{
c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
}
if (!g_unichar_isprint (c))
c = '.';
}
else if (view->utf8)
ch = convert_from_utf_to_current_c (ch, view->converter);
else
#endif
{
#ifdef HAVE_CHARSET
c = convert_to_display_c (c);
#endif
if (!is_printable (c))
c = '.';
}
/* Print corresponding character on the text side */
if (text_start + bytes < width)
{
widget_move (view, top + row, left + text_start + bytes);
#ifdef HAVE_CHARSET
if (view->utf8)
tty_print_anychar (ch);
else
#endif
tty_print_char (c);
}
/* Save the cursor position for mcview_place_cursor() */
if (from == view->hex_cursor && view->hexview_in_text)
{
view->cursor_row = row;
view->cursor_col = text_start + bytes;
}
}
}
/* Be polite to the other functions */
tty_setcolor (VIEW_NORMAL_COLOR);
mcview_place_cursor (view);
view->dpy_end = from;
}
static gboolean
is_word_char (gunichar ch)
{
return g_unichar_isprint (ch) && (g_unichar_isalnum (ch) || ch == '_' || ch == ':' || ch == '.');
}
void
mcview_display_text (mcview_t * view)
{
const screen_dimen left = view->data_area.left;
const screen_dimen top = view->data_area.top;
const screen_dimen width = view->data_area.width;
const screen_dimen height = view->data_area.height;
screen_dimen row = 0, col = 0;
off_t from;
int cw = 1;
int c, prev_ch = 0;
gboolean last_row = TRUE;
struct hexedit_change_node *curr = view->change_list;
mcview_display_clean (view);
mcview_display_ruler (view);
/* Find the first displayable changed byte */
from = view->dpy_start;
while ((curr != NULL) && (curr->offset < from))
curr = curr->next;
while (TRUE)
{
tty_setcolor (NORMAL_COLOR);
if (row >= height)
break;
#ifdef HAVE_CHARSET
if (view->utf8)
{
gboolean read_res = TRUE;
c = mcview_get_utf (view, from, &cw, &read_res);
if (!read_res)
break;
}
else
#endif
if (!mcview_get_byte (view, from, &c))
break;
last_row = FALSE;
from++;
if (cw > 1)
from += cw - 1;
if (c != '\n' && prev_ch == '\r')
{
if (++row >= height)
break;
col = 0;
/* tty_print_anychar ('\n'); */
}
prev_ch = c;
if (c == '\r')
continue;
if (c == '\n')
{
col = 0;
row++;
continue;
}
if (col >= width && view->text_wrap_mode)
{
col = 0;
if (++row >= height)
break;
}
if (c == '\t')
{
col += (option_tab_spacing - col % option_tab_spacing);
if (view->text_wrap_mode && col >= width && width != 0)
{
row += col / width;
col %= width;
}
continue;
}
if (view->search_start <= from && from < view->search_end)
tty_setcolor (SELECTED_COLOR);
if (((off_t) col >= view->dpy_text_column)
&& ((off_t) col - view->dpy_text_column < (off_t) width))
{
widget_move (view, top + row, left + ((off_t) col - view->dpy_text_column));
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!view->utf8)
c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
if (!g_unichar_isprint (c))
c = '.';
}
else if (view->utf8)
c = convert_from_utf_to_current_c (c, view->converter);
else
#endif
{
#ifdef HAVE_CHARSET
c = convert_to_display_c (c);
#endif
if (!is_printable (c))
c = '.';
}
tty_print_anychar (c);
}
col++;
#ifdef HAVE_CHARSET
if (view->utf8)
{
if (g_unichar_iswide (c))
col++;
else if (g_unichar_iszerowidth (c))
col--;
}
#endif
}
view->dpy_end = from;
if (mcview_show_eof != NULL && mcview_show_eof[0] != '\0')
{
if (last_row && mcview_get_byte (view, from - 1, &c))
if (c != '\n')
row--;
while (++row < height)
{
widget_move (view, top + row, left);
tty_print_string (mcview_show_eof);
}
}
}
void
mcview_display_nroff (mcview_t * view)
{
const screen_dimen left = view->data_area.left;
const screen_dimen top = view->data_area.top;
const screen_dimen width = view->data_area.width;
const screen_dimen height = view->data_area.height;
screen_dimen row, col;
off_t from;
int cw = 1;
int c;
int c_prev = 0;
int c_next = 0;
struct hexedit_change_node *curr = view->change_list;
mcview_display_clean (view);
mcview_display_ruler (view);
/* Find the first displayable changed byte */
from = view->dpy_start;
while (curr && (curr->offset < from))
{
curr = curr->next;
}
tty_setcolor (NORMAL_COLOR);
for (row = 0, col = 0; row < height;)
{
#ifdef HAVE_CHARSET
if (view->utf8)
{
gboolean read_res = TRUE;
c = mcview_get_utf (view, from, &cw, &read_res);
if (!read_res)
break;
}
else
#endif
{
if (!mcview_get_byte (view, from, &c))
break;
}
from++;
if (cw > 1)
from += cw - 1;
if (c == '\b')
{
if (from > 1)
{
#ifdef HAVE_CHARSET
if (view->utf8)
{
gboolean read_res;
c_next = mcview_get_utf (view, from, &cw, &read_res);
}
else
#endif
mcview_get_byte (view, from, &c_next);
}
if (g_unichar_isprint (c_prev) && g_unichar_isprint (c_next)
&& (c_prev == c_next || c_prev == '_' || (c_prev == '+' && c_next == 'o')))
{
if (col == 0)
{
if (row == 0)
{
/* We're inside an nroff character sequence at the
* beginning of the screen -- just skip the
* backspace and continue with the next character. */
continue;
}
row--;
col = width;
}
col--;
if (c_prev == '_'
&& (c_next != '_' || mcview_count_backspaces (view, from + 1) == 1))
tty_setcolor (VIEW_UNDERLINED_COLOR);
else
tty_setcolor (VIEW_BOLD_COLOR);
continue;
}
}
if ((c == '\n') || (col >= width && view->text_wrap_mode))
{
col = 0;
row++;
if (c == '\n' || row >= height)
continue;
}
if (c == '\r')
{
mcview_get_byte_indexed (view, from, 1, &c);
if (c == '\r' || c == '\n')
continue;
col = 0;
row++;
continue;
}
if (c == '\t')
{
off_t line, column;
mcview_offset_to_coord (view, &line, &column, from);
col += (option_tab_spacing - col % option_tab_spacing);
if (view->text_wrap_mode && col >= width && width != 0)
{
row += col / width;
col %= width;
}
continue;
}
if (view->search_start <= from && from < view->search_end)
{
tty_setcolor (SELECTED_COLOR);
}
c_prev = c;
if ((off_t) col >= view->dpy_text_column
&& (off_t) col - view->dpy_text_column < (off_t) width)
{
widget_move (view, top + row, left + ((off_t) col - view->dpy_text_column));
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!view->utf8)
{
c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
}
if (!g_unichar_isprint (c))
c = '.';
}
else if (view->utf8)
c = convert_from_utf_to_current_c (c, view->converter);
else
c = convert_to_display_c (c);
#endif
tty_print_anychar (c);
}
col++;
#ifdef HAVE_CHARSET
if (view->utf8)
{
if (g_unichar_iswide (c))
col++;
else if (g_unichar_iszerowidth (c))
col--;
}
#endif
tty_setcolor (NORMAL_COLOR);
}
view->dpy_end = from;
}
void
mcview_display_hex (mcview_t * view)
{
const screen_dimen top = view->data_area.top;
const screen_dimen left = view->data_area.left;
const screen_dimen height = view->data_area.height;
const screen_dimen width = view->data_area.width;
const int ngroups = view->bytes_per_line / 4;
const screen_dimen text_start = 8 + 13 * ngroups + ((width < 80) ? 0 : (ngroups - 1 + 1));
/* 8 characters are used for the file offset, and every hex group
* takes 13 characters. On "big" screens, the groups are separated
* by an extra vertical line, and there is an extra space before the
* text column.
*/
screen_dimen row;
off_t from;
int c;
mark_t boldflag = MARK_NORMAL;
struct hexedit_change_node *curr = view->change_list;
#ifdef HAVE_CHARSET
int ch = 0;
#endif /* HAVE_CHARSET */
char hex_buff[10]; /* A temporary buffer for sprintf and mvwaddstr */
int bytes; /* Number of bytes already printed on the line */
mcview_display_clean (view);
/* Find the first displayable changed byte */
from = view->dpy_start;
while (curr && (curr->offset < from))
{
curr = curr->next;
}
for (row = 0; mcview_get_byte (view, from, NULL) == TRUE && row < height; row++)
{
screen_dimen col = 0;
size_t i;
col = 0;
/* Print the hex offset */
g_snprintf (hex_buff, sizeof (hex_buff), "%08" PRIXMAX " ", (uintmax_t) from);
widget_move (view, top + row, left);
tty_setcolor (VIEW_BOLD_COLOR);
for (i = 0; col < width && hex_buff[i] != '\0'; i++)
{
tty_print_char (hex_buff[i]);
/* tty_print_char(hex_buff[i]); */
col += 1;
}
tty_setcolor (VIEW_NORMAL_COLOR);
for (bytes = 0; bytes < view->bytes_per_line; bytes++, from++)
{
#ifdef HAVE_CHARSET
if (view->utf8)
{
int cw = 1;
gboolean read_res = TRUE;
ch = mcview_get_utf (view, from, &cw, &read_res);
if (!read_res)
break;
/* char width is greater 0 bytes */
if (cw != 0)
{
int cnt;
char corr_buf[UTF8_CHAR_LEN + 1];
struct hexedit_change_node *corr = curr;
int res;
res = g_unichar_to_utf8 (ch, (char *) corr_buf);
for (cnt = 0; cnt < cw; cnt++)
{
if (curr != NULL && from + cnt == curr->offset)
{
/* replace only changed bytes in array of multibyte char */
corr_buf[cnt] = curr->value;
curr = curr->next;
}
}
corr_buf[res] = '\0';
/* Determine the state of the current multibyte char */
ch = utf8_to_int ((char *) corr_buf, &cw, &read_res);
curr = corr;
}
}
#endif /* HAVE_CHARSET */
if (!mcview_get_byte (view, from, &c))
break;
/* Save the cursor position for mcview_place_cursor() */
if (from == view->hex_cursor && !view->hexview_in_text)
{
view->cursor_row = row;
view->cursor_col = col;
}
/* Determine the state of the current byte */
boldflag = mcview_hex_calculate_boldflag (view, from, curr);
/* Determine the value of the current byte */
if (curr != NULL && from == curr->offset)
{
c = curr->value;
curr = curr->next;
}
/* Select the color for the hex number */
tty_setcolor (boldflag == MARK_NORMAL ? VIEW_NORMAL_COLOR :
boldflag == MARK_SELECTED ? VIEW_BOLD_COLOR :
boldflag == MARK_CHANGED ? VIEW_UNDERLINED_COLOR :
/* boldflag == MARK_CURSOR */
view->hexview_in_text ? VIEW_SELECTED_COLOR : VIEW_UNDERLINED_COLOR);
/* Print the hex number */
widget_move (view, top + row, left + col);
if (col < width)
{
tty_print_char (hex_char[c / 16]);
col += 1;
}
if (col < width)
{
tty_print_char (hex_char[c % 16]);
col += 1;
}
/* Print the separator */
tty_setcolor (VIEW_NORMAL_COLOR);
if (bytes != view->bytes_per_line - 1)
{
if (col < width)
{
tty_print_char (' ');
col += 1;
}
/* After every four bytes, print a group separator */
if (bytes % 4 == 3)
{
if (view->data_area.width >= 80 && col < width)
{
tty_print_one_vline (TRUE);
col += 1;
}
if (col < width)
{
tty_print_char (' ');
col += 1;
}
}
}
/* Select the color for the character; this differs from the
* hex color when boldflag == MARK_CURSOR */
tty_setcolor (boldflag == MARK_NORMAL ? VIEW_NORMAL_COLOR :
boldflag == MARK_SELECTED ? VIEW_BOLD_COLOR :
boldflag == MARK_CHANGED ? VIEW_UNDERLINED_COLOR :
/* boldflag == MARK_CURSOR */
view->hexview_in_text ? VIEW_SELECTED_COLOR : MARKED_SELECTED_COLOR);
#ifdef HAVE_CHARSET
if (mc_global.utf8_display)
{
if (!view->utf8)
{
c = convert_from_8bit_to_utf_c ((unsigned char) c, view->converter);
}
if (!g_unichar_isprint (c))
c = '.';
}
else if (view->utf8)
ch = convert_from_utf_to_current_c (ch, view->converter);
else
#endif
{
#ifdef HAVE_CHARSET
c = convert_to_display_c (c);
#endif
if (!is_printable (c))
c = '.';
}
/* Print corresponding character on the text side */
if (text_start + bytes < width)
{
widget_move (view, top + row, left + text_start + bytes);
#ifdef HAVE_CHARSET
if (view->utf8)
tty_print_anychar (ch);
else
#endif
tty_print_char (c);
}
/* Save the cursor position for mcview_place_cursor() */
if (from == view->hex_cursor && view->hexview_in_text)
{
view->cursor_row = row;
view->cursor_col = text_start + bytes;
}
}
}
/* Be polite to the other functions */
tty_setcolor (VIEW_NORMAL_COLOR);
mcview_place_cursor (view);
view->dpy_end = from;
}
void TextRenderer::OnKeyPressEvent(GdkEventKey* event)
{
if( curPos<0 )
return;
// :TODO: "key_binding" - осталось полностью перевести на CallHotKey()
if( CanShiftOnly(event->state) )
{
switch( event->keyval )
{
case GDK_Left: case GDK_KP_Left:
if( curPos>0 )
MoveCursor(curPos - 1);
break;
case GDK_Right: case GDK_KP_Right:
{
int len = utf8::trans(GetText()).length();
if( curPos<len )
MoveCursor(curPos + 1);
}
break;
case GDK_Up: case GDK_KP_Up:
MoveCursorToLine(true);
break;
case GDK_Down: case GDK_KP_Down:
MoveCursorToLine(false);
break;
case GDK_Home: case GDK_KP_Home:
MoveCursor(0);
break;
case GDK_End: case GDK_KP_End:
MoveCursor( utf8::trans(GetText()).length() );
break;
case GDK_Delete: case GDK_KP_Delete:
{
std::string old_str = GetText();
utf8::trans tr(old_str.c_str());
if( curPos<tr.length() )
{
std::string new_str(old_str, 0, tr.from_offset(curPos));
int after_idx = tr.from_offset(curPos+1);
new_str.append(old_str, after_idx, old_str.length() - after_idx);
ChangeText(new_str, curPos);
}
}
break;
case GDK_BackSpace:
{
std::string old_str = GetText();
if( curPos > 0 )
{
utf8::trans tr(old_str.c_str());
std::string new_str(old_str, 0, tr.from_offset(curPos-1));
int idx = tr.from_offset(curPos);
new_str.append(old_str, idx, old_str.length() - idx);
ChangeText(new_str, curPos-1);
}
}
break;
default:
{
int u_c = gdk_keyval_to_unicode(event->keyval);
// вставка символов
if( u_c )
{
if( !g_unichar_isprint(u_c) )
u_c = 0;
}
else
{
if( event->keyval == GDK_Return )
u_c = '\n';
else if( event->keyval == GDK_Tab )
u_c = '\t';
}
if( u_c )
{
char utf8_c[7];
utf8_c[ g_unichar_to_utf8(u_c, utf8_c) ] = 0;
//std::string old_str = GetText();
//int idx = utf8::trans(old_str.c_str()).from_offset(curPos);
//
//std::string new_str(old_str, 0, idx);
//new_str.append(utf8_c);
//new_str.append(old_str, idx, old_str.length() - idx);
//
//ChangeText(new_str, curPos+1);
InsertText(utf8_c);
}
break;
}
}
}
// классические горячие клавишы
CallHotKey(*this, event);
curStt->OnInput(*this);
}
