int dmenu_switcher_dialog ( void )
{
mode_init ( &dmenu_mode );
MenuFlags menu_flags = MENU_NORMAL;
DmenuModePrivateData *pd = (DmenuModePrivateData *) dmenu_mode.private_data;
char *input = NULL;
unsigned int cmd_list_length = pd->cmd_list_length;
char **cmd_list = pd->cmd_list;
pd->only_selected = FALSE;
if ( find_arg ( "-markup-rows" ) >= 0 ) {
pd->do_markup = TRUE;
}
if ( find_arg ( "-only-match" ) >= 0 || find_arg ( "-no-custom" ) >= 0 ) {
pd->only_selected = TRUE;
if ( cmd_list_length == 0 ) {
return TRUE;
}
}
if ( config.auto_select && cmd_list_length == 1 ) {
dmenu_output_formatted_line ( pd->format, cmd_list[0], 0, config.filter );
return TRUE;
}
if ( find_arg ( "-password" ) >= 0 ) {
menu_flags |= MENU_PASSWORD;
}
/* copy filter string */
input = g_strdup ( config.filter );
char *select = NULL;
find_arg_str ( "-select", &select );
if ( select != NULL ) {
char **tokens = tokenize ( select, config.case_sensitive );
unsigned int i = 0;
for ( i = 0; i < cmd_list_length; i++ ) {
if ( token_match ( tokens, cmd_list[i], !g_str_is_ascii ( cmd_list[i] ), config.case_sensitive ) ) {
pd->selected_line = i;
break;
}
}
g_strfreev ( tokens );
}
if ( find_arg ( "-dump" ) >= 0 ) {
char **tokens = tokenize ( config.filter ? config.filter : "", config.case_sensitive );
unsigned int i = 0;
for ( i = 0; i < cmd_list_length; i++ ) {
if ( token_match ( tokens, cmd_list[i], !g_str_is_ascii ( cmd_list[i] ), config.case_sensitive ) ) {
dmenu_output_formatted_line ( pd->format, cmd_list[i], i, config.filter );
}
}
g_strfreev ( tokens );
return TRUE;
}
// TODO remove
RofiViewState *state = rofi_view_create ( &dmenu_mode, input, pd->prompt, pd->message, menu_flags, dmenu_finalize );
rofi_view_set_selected_line ( state, pd->selected_line );
rofi_view_set_active ( state );
return FALSE;
}
static int drun_is_not_ascii ( const Mode *sw, unsigned int index )
{
DRunModePrivateData *pd = (DRunModePrivateData *) mode_get_private_data ( sw );
if ( pd->entry_list[index].generic_name ) {
return !g_str_is_ascii ( pd->entry_list[index].name ) || !g_str_is_ascii ( pd->entry_list[index].generic_name );
}
return !g_str_is_ascii ( pd->entry_list[index].name );
}
static gint
ide_language_defaults_get_current_version (const gchar *path,
GError **error)
{
GError *local_error = NULL;
g_autofree gchar *contents = NULL;
gsize length = 0;
gint64 version;
if (!g_file_get_contents (path, &contents, &length, &local_error))
{
if (g_error_matches (local_error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
{
g_clear_error (&local_error);
return 0;
}
else
{
g_propagate_error (error, local_error);
return -1;
}
}
if (!g_str_is_ascii (contents))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
_("%s contained invalid ASCII"),
path);
return -1;
}
if ((length == 0) || (contents [0] == '\0'))
return 0;
version = g_ascii_strtoll (contents, NULL, 10);
if ((version < 0) || (version >= G_MAXINT))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_INVALID_DATA,
_("Failed to parse integer from \"%s\""),
path);
return -1;
}
return version;
}
int validate_opts(void)
{
size_t i;
int ret = 0;
/* classification */
if (opt_class == NULL) {
fprintf(stderr, "Error: Classification required. See --help.\n");
return ret;
}
i = strlen(opt_class);
if ((i == 0) || (i > 120)) {
fprintf(stderr, "Error: Valid size for classification "
"is 1-120 chars\n");
return ret;
}
if (!g_str_is_ascii(opt_class)) {
fprintf(stderr, "Error: Non-ascii characters detected "
"in classification - aborting\n");
return ret;
}
if (count_chars(opt_class, '/') != 2) {
fprintf(stderr, "Error: Classification needs to be in "
"most/to/least specific format, 2 \'/\' required.\n");
return ret;
}
/* Severity */
if ((severity) < 1 || (severity > 4)) {
fprintf(stderr, "Error: Valid range for severity is 1-4\n");
return ret;
}
return 1;
}
/**
* g_str_to_ascii:
* @str: a string, in UTF-8
* @from_locale: (allow-none): the source locale, if known
*
* Transliterate @str to plain ASCII.
*
* For best results, @str should be in composed normalised form.
*
* This function performs a reasonably good set of character
* replacements. The particular set of replacements that is done may
* change by version or even by runtime environment.
*
* If the source language of @str is known, it can used to improve the
* accuracy of the translation by passing it as @from_locale. It should
* be a valid POSIX locale string (of the form
* "language[_territory][.codeset][@modifier]").
*
* If @from_locale is %NULL then the current locale is used.
*
* If you want to do translation for no specific locale, and you want it
* to be done independently of the currently locale, specify "C" for
* @from_locale.
*
* Returns: a string in plain ASCII
*
* Since: 2.40
**/
gchar *
g_str_to_ascii (const gchar *str,
const gchar *from_locale)
{
GString *result;
guint item_id;
g_return_val_if_fail (str != NULL, NULL);
if (g_str_is_ascii (str))
return g_strdup (str);
if (from_locale)
item_id = lookup_item_id_for_locale (from_locale);
else
item_id = get_default_item_id ();
result = g_string_sized_new (strlen (str));
while (*str)
{
/* We only need to transliterate non-ASCII values... */
if (*str & 0x80)
{
gunichar key[MAX_KEY_SIZE];
const gchar *r;
gint consumed;
gint r_len;
gunichar c;
G_STATIC_ASSERT(MAX_KEY_SIZE == 2);
c = g_utf8_get_char (str);
/* This is where it gets evil...
*
* We know that MAX_KEY_SIZE is 2. We also know that we
* only want to try another character if it's non-ascii.
*/
str = g_utf8_next_char (str);
key[0] = c;
if (*str & 0x80)
key[1] = g_utf8_get_char (str);
else
key[1] = 0;
r = lookup_in_item (item_id, key, &r_len, &consumed);
/* If we failed to map two characters, try again with one.
*
* gconv behaviour is a bit weird here -- it seems to
* depend in the randomness of the binary search and the
* size of the input buffer as to what result we get here.
*
* Doing it this way is more work, but should be
* more-correct.
*/
if (r == NULL && key[1])
{
key[1] = 0;
r = lookup_in_item (item_id, key, &r_len, &consumed);
}
if (r != NULL)
{
g_string_append_len (result, r, r_len);
if (consumed == 2)
/* If it took both then skip again */
str = g_utf8_next_char (str);
}
else /* no match found */
g_string_append_c (result, '?');
}
else if (*str & 0x80) /* Out-of-range non-ASCII case */
{
g_string_append_c (result, '?');
str = g_utf8_next_char (str);
}
else /* ASCII case */
g_string_append_c (result, *str++);
}
return g_string_free (result, FALSE);
}
/**
* @param sw Object handle to the SSH Mode object
* @param index The index of the entry to match
*
* Check if the selected entry contains non-ascii symbols.
*
* @returns TRUE if string contains non-ascii symbols
*/
static int ssh_is_not_ascii ( const Mode *sw, unsigned int index )
{
SSHModePrivateData *rmpd = (SSHModePrivateData *) mode_get_private_data ( sw );
return !g_str_is_ascii ( rmpd->hosts_list[index] );
}
static int dmenu_is_not_ascii ( const Mode *sw, unsigned int index )
{
DmenuModePrivateData *rmpd = (DmenuModePrivateData *) mode_get_private_data ( sw );
return !g_str_is_ascii ( rmpd->cmd_list[index] );
}
