void convert_babylonfile(const char *filename, print_info_t print_info, bool strip_html)
{
struct stat stats;
if (g_stat (filename, &stats) == -1)
{
print_info("File not exist!\n");
return;
}
gchar *basefilename = g_path_get_basename(filename);
gchar *ch = strrchr(basefilename, '.');
if (ch)
*ch = '\0';
gchar *dirname = g_path_get_dirname(filename);
FILE *tabfile;
tabfile = g_fopen(filename,"r");
gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
size_t readsize = fread (buffer, 1, stats.st_size, tabfile);
fclose (tabfile);
buffer[readsize] = '\0';
GArray *array = g_array_sized_new(FALSE,FALSE, sizeof(struct _worditem),20000);
GArray *array2 = g_array_sized_new(FALSE,FALSE, sizeof(struct _synworditem),20000);
gchar *p, *p1, *p2, *p3, *p4, *p5;
p = buffer;
if ((guchar)*p==0xEF && (guchar)*(p+1)==0xBB && (guchar)*(p+2)==0xBF) // UTF-8 order characters.
p+=3;
struct _worditem worditem;
struct _synworditem synworditem;
gint linenum=1;
int stripmethod;
if (strip_html)
stripmethod = 0;
else
stripmethod = 1;
std::string sametypesequence = "m";
std::string bookname;
std::string author;
std::string email;
std::string website;
std::string description;
std::string date;
bool print_sameword;
if (*p == '\n') {
print_sameword = false;
p++;
linenum++;
while (1) {
if (*p == '\n') {
p++;
linenum++;
break;
}
p++;
p1 = strchr(p, '\n');
if (!p1) {
return;
}
*p1 = '\0';
p1++;
linenum++;
if (g_str_has_prefix(p, "stripmethod=")) {
p += sizeof("stripmethod=") -1;
if (strcmp(p, "striphtml")==0)
stripmethod = 0;
else if (strcmp(p, "stripnewline")==0)
stripmethod = 1;
else if (strcmp(p, "keep")==0)
stripmethod = 2;
} else if (g_str_has_prefix(p, "sametypesequence=")) {
p += sizeof("sametypesequence=") -1;
sametypesequence = p;
} else if (g_str_has_prefix(p, "bookname=")) {
p += sizeof("bookname=") -1;
bookname = p;
} else if (g_str_has_prefix(p, "author=")) {
p += sizeof("author=") -1;
author = p;
} else if (g_str_has_prefix(p, "email=")) {
p += sizeof("email=") -1;
email = p;
} else if (g_str_has_prefix(p, "website=")) {
p += sizeof("website=") -1;
website = p;
} else if (g_str_has_prefix(p, "date=")) {
p += sizeof("date=") -1;
date = p;
} else if (g_str_has_prefix(p, "description=")) {
p += sizeof("description=") -1;
description = p;
}
p = p1;
}
} else {
print_sameword = true;
}
while (1) {
if (*p == '\0') {
print_info("Over\n");
break;
}
p1 = strchr(p,'\n');
if (!p1) {
gchar *str = g_strdup_printf("Error, no end line 1: %d\n", linenum);
print_info(str);
g_free(str);
return;
}
*p1 = '\0';
p1++;
linenum++;
p2 = strchr(p1,'\n');
if (!p2) {
gchar *str = g_strdup_printf("Error, no end line 2: %d\n", linenum);
print_info(str);
g_free(str);
return;
}
*p2 = '\0';
p2++;
linenum++;
p3=p2;
if (*p3 != '\n') {
gchar *str = g_strdup_printf("Error, not null line %d", linenum);
print_info(str);
g_free(str);
return;
}
*p3='\0';
p3++;
linenum++;
if (stripmethod == 0) {
html_strstrip(p1, linenum-2, print_info);
} else if (stripmethod == 1) {
newline_strstrip(p1, linenum-2, print_info);
} else if (stripmethod == 2) {
}
g_strstrip(p1);
if (!(*p1)) {
gchar *str = g_strdup_printf("%s-%d, bad definition!!!\n", basefilename, linenum-1);
print_info(str);
g_free(str);
p= p3;
continue;
}
p4 = strchr(p, '|');
if (p4) {
*p4 = '\0';
worditem.word = p;
g_strstrip(worditem.word);
if (!worditem.word[0]) {
gchar *str = g_strdup_printf("%s-%d, bad word!!!\n", basefilename, linenum-2);
print_info(str);
g_free(str);
p=p3;
continue;
}
worditem.definition = p1;
g_array_append_val(array, worditem);
std::list <std::string> WordList;
WordList.push_back(worditem.word);
p4++;
while (true) {
p5 = strchr(p4, '|');
if (p5) {
*p5 = '\0';
synworditem.synword = p4;
g_strstrip(synworditem.synword);
if (!synworditem.synword[0]) {
gchar *str = g_strdup_printf("%s-%d, bad word!!!\n", basefilename, linenum-2);
print_info(str);
g_free(str);
p4 = p5+1;
continue;
}
bool find = false;
for (std::list<std::string>::const_iterator it=WordList.begin(); it!=WordList.end(); ++it) {
if (*it == synworditem.synword) {
find= true;
break;
}
}
if (find) {
if (print_sameword) {
gchar *str = g_strdup_printf("Same word: %s\n", synworditem.synword);
print_info(str);
g_free(str);
}
p4 = p5+1;
continue;
} else {
WordList.push_back(synworditem.synword);
}
synworditem.origword = worditem.word;
synworditem.definition = worditem.definition;
g_array_append_val(array2, synworditem);
p4 = p5+1;
} else {
synworditem.synword = p4;
g_strstrip(synworditem.synword);
if (!synworditem.synword[0]) {
gchar *str = g_strdup_printf("%s-%d, bad word!!!\n", basefilename, linenum-2);
print_info(str);
g_free(str);
break;
}
bool find = false;
for (std::list<std::string>::const_iterator it=WordList.begin(); it!=WordList.end(); ++it) {
if (*it == synworditem.synword) {
find= true;
break;
}
}
if (find) {
if (print_sameword) {
gchar *str = g_strdup_printf("Same word: %s\n", synworditem.synword);
print_info(str);
g_free(str);
}
break;
}
synworditem.origword = worditem.word;
synworditem.definition = worditem.definition;
g_array_append_val(array2, synworditem);
break;
}
}
} else {
worditem.word = p;
g_strstrip(worditem.word);
if (!worditem.word[0]) {
gchar *str = g_strdup_printf("%s-%d, bad word!!!\n", basefilename, linenum-2);
print_info(str);
g_free(str);
p=p3;
continue;
}
worditem.definition = p1;
g_array_append_val(array, worditem);
}
p= p3;
}
g_array_sort(array,comparefunc);
g_array_sort(array2,comparefunc2);
gchar ifofilename[256];
gchar idxfilename[256];
gchar dicfilename[256];
sprintf(ifofilename, "%s" G_DIR_SEPARATOR_S "%s.ifo", dirname, basefilename);
sprintf(idxfilename, "%s" G_DIR_SEPARATOR_S "%s.idx", dirname, basefilename);
sprintf(dicfilename, "%s" G_DIR_SEPARATOR_S "%s.dict", dirname, basefilename);
FILE *ifofile = g_fopen(ifofilename,"wb");
FILE *idxfile = g_fopen(idxfilename,"wb");
FILE *dicfile = g_fopen(dicfilename,"wb");
guint32 offset_old;
guint32 tmpglong;
struct _worditem *pworditem;
gint definition_len;
gulong i;
for (i=0; i< array->len; i++) {
offset_old = ftell(dicfile);
pworditem = &g_array_index(array, struct _worditem, i);
definition_len = strlen(pworditem->definition);
fwrite(pworditem->definition, 1 ,definition_len,dicfile);
fwrite(pworditem->word,sizeof(gchar),strlen(pworditem->word)+1,idxfile);
tmpglong = g_htonl(offset_old);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
tmpglong = g_htonl(definition_len);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
}
fclose(idxfile);
fclose(dicfile);
gchar *str = g_strdup_printf("%s wordcount: %d\n", basefilename, array->len);
print_info(str);
g_free(str);
if (array2->len) {
gchar synfilename[256];
sprintf(synfilename, "%s" G_DIR_SEPARATOR_S "%s.syn", dirname, basefilename);
FILE *synfile = g_fopen(synfilename,"wb");
struct _synworditem *psynworditem;
gint iFrom, iTo, iThisIndex, cmpint;
bool bFound;
for (i=0; i< array2->len; i++) {
psynworditem = &g_array_index(array2, struct _synworditem, i);
fwrite(psynworditem->synword, 1, strlen(psynworditem->synword)+1, synfile);
bFound=false;
iFrom=0;
iTo=array->len-1;
while (iFrom<=iTo) {
iThisIndex=(iFrom+iTo)/2;
pworditem = &g_array_index(array, struct _worditem, iThisIndex);
cmpint = stardict_strcmp(psynworditem->origword, pworditem->word);
if (cmpint>0)
iFrom=iThisIndex+1;
else if (cmpint<0)
iTo=iThisIndex-1;
else {
bFound=true;
break;
}
}
if (!bFound) {
gchar *str = g_strdup_printf("Error, %s not find.\n", psynworditem->origword);
print_info(str);
g_free(str);
return;
}
do {
if (iThisIndex==0)
break;
pworditem = &g_array_index(array, struct _worditem, iThisIndex-1);
if (strcmp(psynworditem->origword, pworditem->word)==0)
iThisIndex--;
else
break;
} while (true);
bFound=false;
do {
pworditem = &g_array_index(array, struct _worditem, iThisIndex);
if (strcmp(psynworditem->origword, pworditem->word)==0) {
if (psynworditem->definition == pworditem->definition) {
bFound=true;
break;
} else
iThisIndex++;
} else
break;
} while (true);
if (!bFound) {
gchar *str = g_strdup_printf("Error, %s definition not find.\n", psynworditem->origword);
print_info(str);
g_free(str);
return;
}
tmpglong = g_htonl(iThisIndex);
fwrite(&(tmpglong),sizeof(guint32),1, synfile);
}
fclose(synfile);
gchar *str = g_strdup_printf("%s synwordcount: %d\n", basefilename, array2->len);
print_info(str);
g_free(str);
}
static gboolean
ui_to_setting (CEPageIP4 *page)
{
const gchar *method;
gboolean ignore_auto_dns;
gboolean ignore_auto_routes;
gboolean never_default;
GPtrArray *addresses = NULL;
GArray *dns_servers = NULL;
GPtrArray *routes = NULL;
GList *children, *l;
gboolean ret = TRUE;
if (!gtk_switch_get_active (page->enabled)) {
method = NM_SETTING_IP4_CONFIG_METHOD_DISABLED;
} else {
switch (gtk_combo_box_get_active (page->method)) {
case IP4_METHOD_MANUAL:
method = NM_SETTING_IP4_CONFIG_METHOD_MANUAL;
break;
case IP4_METHOD_LINK_LOCAL:
method = NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL;
break;
default:
case IP4_METHOD_AUTO:
method = NM_SETTING_IP4_CONFIG_METHOD_AUTO;
break;
}
}
addresses = g_ptr_array_new_with_free_func (free_addr);
children = gtk_container_get_children (GTK_CONTAINER (page->address_list));
for (l = children; l; l = l->next) {
GtkWidget *row = l->data;
GtkEntry *entry;
const gchar *text_address;
const gchar *text_netmask;
const gchar *text_gateway;
struct in_addr tmp_addr;
struct in_addr tmp_gateway = { 0 };
guint32 prefix;
guint32 empty_val = 0;
GArray *addr;
entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address"));
if (!entry)
continue;
text_address = gtk_entry_get_text (entry);
text_netmask = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "network")));
text_gateway = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "gateway")));
if (!*text_address && !*text_netmask && !*text_gateway) {
/* ignore empty rows */
widget_unset_error (GTK_WIDGET (entry));
widget_unset_error (g_object_get_data (G_OBJECT (row), "network"));
widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway"));
continue;
}
if (inet_pton (AF_INET, text_address, &tmp_addr) <= 0) {
widget_set_error (GTK_WIDGET (entry));
ret = FALSE;
} else {
widget_unset_error (GTK_WIDGET (entry));
}
if (!parse_netmask (text_netmask, &prefix)) {
widget_set_error (g_object_get_data (G_OBJECT (row), "network"));
ret = FALSE;
} else {
widget_unset_error (g_object_get_data (G_OBJECT (row), "network"));
}
if (text_gateway && *text_gateway && inet_pton (AF_INET, text_gateway, &tmp_gateway) <= 0) {
widget_set_error (g_object_get_data (G_OBJECT (row), "gateway"));
ret = FALSE;
} else {
widget_unset_error (g_object_get_data (G_OBJECT (row), "gateway"));
}
if (!ret)
continue;
addr = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
g_array_append_val (addr, tmp_addr.s_addr);
g_array_append_val (addr, prefix);
if (tmp_gateway.s_addr)
g_array_append_val (addr, tmp_gateway.s_addr);
else
g_array_append_val (addr, empty_val);
g_ptr_array_add (addresses, addr);
}
g_list_free (children);
if (addresses->len == 0) {
g_ptr_array_free (addresses, TRUE);
addresses = NULL;
}
dns_servers = g_array_new (FALSE, FALSE, sizeof (guint));
children = gtk_container_get_children (GTK_CONTAINER (page->dns_list));
for (l = children; l; l = l->next) {
GtkWidget *row = l->data;
GtkEntry *entry;
const gchar *text;
struct in_addr tmp_addr;
entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address"));
if (!entry)
continue;
text = gtk_entry_get_text (entry);
if (!*text) {
/* ignore empty rows */
widget_unset_error (GTK_WIDGET (entry));
continue;
}
if (inet_pton (AF_INET, text, &tmp_addr) <= 0) {
widget_set_error (GTK_WIDGET (entry));
ret = FALSE;
} else {
widget_unset_error (GTK_WIDGET (entry));
g_array_append_val (dns_servers, tmp_addr.s_addr);
}
}
g_list_free (children);
routes = g_ptr_array_new_with_free_func (free_addr);
children = gtk_container_get_children (GTK_CONTAINER (page->routes_list));
for (l = children; l; l = l->next) {
GtkWidget *row = l->data;
GtkEntry *entry;
const gchar *text_address;
const gchar *text_netmask;
const gchar *text_gateway;
const gchar *text_metric;
struct in_addr tmp_addr = { 0 };
guint32 address, netmask, gateway, metric;
GArray *route;
entry = GTK_ENTRY (g_object_get_data (G_OBJECT (row), "address"));
if (!entry)
continue;
text_address = gtk_entry_get_text (entry);
text_netmask = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "netmask")));
text_gateway = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "gateway")));
text_metric = gtk_entry_get_text (GTK_ENTRY (g_object_get_data (G_OBJECT (row), "metric")));
if (!*text_address && !*text_netmask && !*text_gateway && !*text_metric) {
/* ignore empty rows */
continue;
}
if (inet_pton (AF_INET, text_address, &tmp_addr) <= 0) {
widget_set_error (GTK_WIDGET (entry));
ret = FALSE;
} else {
widget_unset_error (GTK_WIDGET (entry));
address = tmp_addr.s_addr;
}
if (!parse_netmask (text_netmask, &netmask)) {
widget_set_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "netmask")));
ret = FALSE;
} else {
widget_unset_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "netmask")));
}
if (inet_pton (AF_INET, text_gateway, &tmp_addr) <= 0) {
widget_set_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "gateway")));
ret = FALSE;
} else {
widget_unset_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "gateway")));
gateway = tmp_addr.s_addr;
}
metric = 0;
if (*text_metric) {
errno = 0;
metric = strtoul (text_metric, NULL, 10);
if (errno) {
widget_set_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "metric")));
ret = FALSE;
} else {
widget_unset_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "metric")));
}
} else {
widget_unset_error (GTK_WIDGET (g_object_get_data (G_OBJECT (row), "metric")));
}
if (!ret)
continue;
route = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 4);
g_array_append_val (route, address);
g_array_append_val (route, netmask);
g_array_append_val (route, gateway);
g_array_append_val (route, metric);
g_ptr_array_add (routes, route);
}
g_list_free (children);
if (routes->len == 0) {
g_ptr_array_free (routes, TRUE);
routes = NULL;
}
if (!ret)
goto out;
ignore_auto_dns = !gtk_switch_get_active (page->auto_dns);
ignore_auto_routes = !gtk_switch_get_active (page->auto_routes);
never_default = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (page->never_default));
g_object_set (page->setting,
NM_SETTING_IP4_CONFIG_METHOD, method,
NM_SETTING_IP4_CONFIG_ADDRESSES, addresses,
NM_SETTING_IP4_CONFIG_DNS, dns_servers,
NM_SETTING_IP4_CONFIG_ROUTES, routes,
NM_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns,
NM_SETTING_IP4_CONFIG_IGNORE_AUTO_ROUTES, ignore_auto_routes,
NM_SETTING_IP4_CONFIG_NEVER_DEFAULT, never_default,
NULL);
out:
if (addresses)
g_ptr_array_free (addresses, TRUE);
if (dns_servers)
g_array_free (dns_servers, TRUE);
if (routes)
g_ptr_array_free (routes, TRUE);
return ret;
}
GArray *
mm_huawei_parse_prefmode_test (const gchar *response,
GError **error)
{
gchar **split;
guint i;
MMModemMode all = MM_MODEM_MODE_NONE;
GArray *out;
response = mm_strip_tag (response, "^PREFMODE:");
split = g_strsplit_set (response, " (,)\r\n", -1);
if (!split) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Unexpected ^PREFMODE format output");
return NULL;
}
out = g_array_sized_new (FALSE,
FALSE,
sizeof (MMHuaweiPrefmodeCombination),
3);
for (i = 0; split[i]; i++) {
guint val;
MMModemMode preferred = MM_MODEM_MODE_NONE;
GError *inner_error = NULL;
MMHuaweiPrefmodeCombination combination;
if (split[i][0] == '\0')
continue;
if (!mm_get_uint_from_str (split[i], &val)) {
mm_dbg ("Error parsing ^PREFMODE value: %s", split[i]);
continue;
}
if (!mode_from_prefmode (val, &preferred, &inner_error)) {
mm_dbg ("Unhandled ^PREFMODE: %s", inner_error->message);
g_error_free (inner_error);
continue;
}
combination.prefmode = val;
combination.allowed = MM_MODEM_MODE_NONE; /* reset it later */
combination.preferred = preferred;
all |= preferred;
g_array_append_val (out, combination);
}
g_strfreev (split);
/* No value */
if (out->len == 0) {
g_array_unref (out);
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"^PREFMODE response contains no valid values");
return NULL;
}
/* Single value listed; PREFERRED=NONE... */
if (out->len == 1) {
MMHuaweiPrefmodeCombination *combination;
combination = &g_array_index (out, MMHuaweiPrefmodeCombination, 0);
combination->allowed = all;
combination->preferred = MM_MODEM_MODE_NONE;
} else {
/* Multiple values, reset ALLOWED */
for (i = 0; i < out->len; i++) {
MMHuaweiPrefmodeCombination *combination;
combination = &g_array_index (out, MMHuaweiPrefmodeCombination, i);
combination->allowed = all;
if (combination->preferred == all)
combination->preferred = MM_MODEM_MODE_NONE;
}
}
return out;
}
/**
* gimp_scan_convert_stroke:
* @sc: a #GimpScanConvert context
* @width: line width in pixels
* @join: how lines should be joined
* @cap: how to render the end of lines
* @miter: convert a mitered join to a bevelled join if the miter would
* extend to a distance of more than @miter times @width from
* the actual join point
* @dash_offset: offset to apply on the dash pattern
* @dash_info: dash pattern or %NULL for a solid line
*
* Stroke the content of a GimpScanConvert. The next
* gimp_scan_convert_render() will result in the outline of the
* polygon defined with the commands above.
*
* You cannot add additional polygons after this command.
*
* Note that if you have nonstandard resolution, "width" gives the
* width (in pixels) for a vertical stroke, i.e. use the X resolution
* to calculate the width of a stroke when operating with real world
* units.
*/
void
gimp_scan_convert_stroke (GimpScanConvert *sc,
gdouble width,
GimpJoinStyle join,
GimpCapStyle cap,
gdouble miter,
gdouble dash_offset,
GArray *dash_info)
{
sc->do_stroke = TRUE;
sc->width = width;
sc->join = join;
sc->cap = cap;
sc->miter = miter;
if (sc->dash_info)
{
g_array_free (sc->dash_info, TRUE);
sc->dash_info = NULL;
}
if (dash_info && dash_info->len >= 2)
{
gint n_dashes;
gdouble *dashes;
gint i;
dash_offset = dash_offset * MAX (width, 1.0);
n_dashes = dash_info->len;
dashes = g_new (gdouble, dash_info->len);
for (i = 0; i < dash_info->len ; i++)
dashes[i] = MAX (width, 1.0) * g_array_index (dash_info, gdouble, i);
/* correct 0.0 in the first element (starts with a gap) */
if (dashes[0] == 0.0)
{
gdouble first;
first = dashes[1];
/* shift the pattern to really starts with a dash and
* use the offset to skip into it.
*/
for (i = 0; i < dash_info->len - 2; i++)
{
dashes[i] = dashes[i+2];
dash_offset += dashes[i];
}
if (dash_info->len % 2 == 1)
{
dashes[dash_info->len - 2] = first;
n_dashes --;
}
else if (dash_info->len > 2)
{
dashes [dash_info->len - 3] += first;
n_dashes -= 2;
}
}
/* correct odd number of dash specifiers */
if (n_dashes % 2 == 1)
{
gdouble last;
last = dashes[n_dashes - 1];
dashes[0] += last;
dash_offset += last;
n_dashes --;
}
if (n_dashes >= 2)
{
sc->dash_info = g_array_sized_new (FALSE, FALSE,
sizeof (gdouble), n_dashes);
sc->dash_info = g_array_append_vals (sc->dash_info, dashes, n_dashes);
sc->dash_offset = dash_offset;
}
g_free (dashes);
}
}
void convert(char *filename)
{
struct stat stats;
if (stat (filename, &stats) == -1)
{
printf("file not exist!\n");
return;
}
gchar *basefilename = g_path_get_basename(filename);
FILE *tabfile;
tabfile = fopen(filename,"r");
gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
fread (buffer, 1, stats.st_size, tabfile);
fclose (tabfile);
buffer[stats.st_size] = '\0';
GArray *array = g_array_sized_new(FALSE,FALSE, sizeof(struct _worditem),20000);
gchar *p, *p1, *p2, *p3;
p = buffer;
if ((guchar)*p==0xEF && (guchar)*(p+1)==0xBB && (guchar)*(p+2)==0xBF) // UTF-8 order characters.
p+=3;
struct _worditem worditem;
glong linenum=1;
while (1) {
if (*p == '\0') {
g_print("over\n");
break;
}
p1 = strchr(p,'\n');
if (!p1) {
g_print("error, no end line\n");
return;
}
*p1 = '\0';
p1++;
p2 = strchr(p,'[');
if (!p2) {
g_print("error, no [, %ld\n", linenum);
return;
}
*p2 = '\0';
p2++;
p3 = strchr(p2, ']');
if (!p3) {
g_print("error, no ], %ld\n", linenum);
return;
}
*p3 = '\0';
p3++;
worditem.word = p;
to_pinyin(p2);
worditem.pinyin = p2;
to_definition(p3);
worditem.definition = p3;
g_strstrip(worditem.word);
g_strstrip(worditem.pinyin);
g_strstrip(worditem.definition);
if (!worditem.word[0]) {
g_print("%s-%ld, bad word!!!\n", basefilename, linenum);
p= p1;
linenum++;
continue;
}
if (!worditem.pinyin[0]) {
g_print("%s-%ld, bad pinyin!!!\n", basefilename, linenum);
}
if (!worditem.definition[0]) {
g_print("%s-%ld, bad definition!!!\n", basefilename, linenum);
}
if (!worditem.pinyin[0] && !worditem.definition[0]) {
g_print("%s-%ld, bad pinyin and definition!!!\n", basefilename, linenum);
p= p1;
linenum++;
continue;
}
g_array_append_val(array, worditem);
p= p1;
linenum++;
}
g_array_sort(array,comparefunc);
gchar idxfilename[256];
gchar dicfilename[256];
sprintf(idxfilename, "%s.idx", basefilename);
sprintf(dicfilename, "%s.dict", basefilename);
FILE *idxfile = fopen(idxfilename,"w");
FILE *dicfile = fopen(dicfilename,"w");
guint32 offset_old;
guint32 tmpglong;
struct _worditem *pworditem;
gint pinyin_len;
gint definition_len;
gulong i;
for (i=0; i< array->len; i++) {
offset_old = ftell(dicfile);
pworditem = &g_array_index(array, struct _worditem, i);
pinyin_len = strlen(pworditem->pinyin);
fwrite(pworditem->pinyin, 1 , pinyin_len+1,dicfile);
definition_len = strlen(pworditem->definition);
fwrite(pworditem->definition, 1 ,definition_len,dicfile);
fwrite(pworditem->word,sizeof(gchar),strlen(pworditem->word)+1,idxfile);
tmpglong = g_htonl(offset_old);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
tmpglong = g_htonl(pinyin_len+1+ definition_len);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
}
fclose(idxfile);
fclose(dicfile);
g_print("%s wordcount: %d\n", basefilename, array->len);
g_free(buffer);
g_array_free(array,TRUE);
gchar command[256];
sprintf(command, "dictzip %s.dict", basefilename);
system(command);
g_free(basefilename);
}
int
test_line_1(void * data)
{
mfp_procinfo * proctype = g_hash_table_lookup(mfp_proc_registry, "line~");
mfp_processor * line = mfp_proc_create(proctype, 0, 1, (mfp_context *)data);
mfp_sample * outp;
int snum;
float tval[] = { 0.0, 1.0, 1.0,
0.0, 0.0, 0.0,
1.0, 1.0, 1.0 };
GArray * env_1 = g_array_sized_new(TRUE, TRUE, sizeof(float), 6);
printf(" test_line_1 \n ");
for (snum=0; snum < 9; snum++) {
g_array_append_val(env_1, tval[snum]);
}
if(!proctype || !line) {
printf("FAIL: proctype=%p, proc=%p\n", proctype, line);
return 0;
}
setparam_gpointer(line, "segments", env_1);
line->needs_config = 1;
mfp_proc_process(line);
outp = line->outlet_buf[0]->data;
if (outp[0] != 0) {
printf("FAIL: outp[0] was %f not 0\n", outp[0]);
return 0;
}
if (outp[22] != 0.5) {
printf("FAIL: outp[22] was %f not 0.5\n", outp[22]);
return 0;
}
if (outp[44] != 1.0) {
printf("FAIL: outp[44] was %f not 1.0\n", outp[44]);
return 0;
}
if (outp[45] != 0.0) {
printf("FAIL: outp[45] was %f not 0.0\n", outp[45]);
return 0;
}
if (outp[46] != 0.0) {
printf("FAIL: outp[46] was %f not 0.0\n", outp[46]);
return 0;
}
if (outp[88] != 0.0) {
printf("FAIL: outp[88] was %f not 0.0\n", outp[89]);
return 0;
}
if (outp[99] != 0.25) {
printf("FAIL: outp[100] was %f not 0.25\n", outp[100]);
return 0;
}
if (outp[134] != 1.0) {
printf("FAIL: outp[134] was %f not 1.0\n", outp[134]);
return 0;
}
printf("ok\n");
return 1;
}
static gboolean
ui_to_setting (CEPageIP4 *self)
{
CEPageIP4Private *priv = CE_PAGE_IP4_GET_PRIVATE (self);
GtkTreeModel *model;
GtkTreeIter tree_iter;
int int_method = IP4_METHOD_AUTO;
const char *method;
GArray *dns_servers = NULL;
GSList *search_domains = NULL;
GPtrArray *addresses = NULL;
gboolean valid = FALSE, iter_valid;
const char *text;
gboolean ignore_auto_dns = FALSE;
const char *dhcp_client_id = NULL;
char **items = NULL, **iter;
/* Method */
if (gtk_combo_box_get_active_iter (priv->method, &tree_iter)) {
gtk_tree_model_get (GTK_TREE_MODEL (priv->method_store), &tree_iter,
METHOD_COL_NUM, &int_method, -1);
}
switch (int_method) {
case IP4_METHOD_LINK_LOCAL:
method = NM_SETTING_IP4_CONFIG_METHOD_LINK_LOCAL;
break;
case IP4_METHOD_MANUAL:
method = NM_SETTING_IP4_CONFIG_METHOD_MANUAL;
break;
case IP4_METHOD_SHARED:
method = NM_SETTING_IP4_CONFIG_METHOD_SHARED;
break;
case IP4_METHOD_AUTO_ADDRESSES:
ignore_auto_dns = TRUE;
/* fall through */
default:
method = NM_SETTING_IP4_CONFIG_METHOD_AUTO;
break;
}
/* IP addresses */
model = gtk_tree_view_get_model (priv->addr_list);
iter_valid = gtk_tree_model_get_iter_first (model, &tree_iter);
addresses = g_ptr_array_sized_new (1);
while (iter_valid) {
char *item = NULL;
struct in_addr tmp_addr, tmp_gateway = { 0 };
GArray *addr;
guint32 empty_val = 0, prefix;
gtk_tree_model_get (model, &tree_iter, COL_ADDRESS, &item, -1);
if (!item || !inet_aton (item, &tmp_addr)) {
g_warning ("%s: IPv4 address '%s' missing or invalid!",
__func__, item ? item : "<none>");
g_free (item);
goto out;
}
g_free (item);
gtk_tree_model_get (model, &tree_iter, COL_PREFIX, &item, -1);
if (!item) {
g_warning ("%s: IPv4 prefix '%s' missing!",
__func__, item ? item : "<none>");
goto out;
}
if (!parse_netmask (item, &prefix)) {
g_warning ("%s: IPv4 prefix '%s' invalid!",
__func__, item ? item : "<none>");
g_free (item);
goto out;
}
g_free (item);
/* Gateway is optional... */
gtk_tree_model_get (model, &tree_iter, COL_GATEWAY, &item, -1);
if (item && !inet_aton (item, &tmp_gateway)) {
g_warning ("%s: IPv4 gateway '%s' invalid!",
__func__, item ? item : "<none>");
g_free (item);
goto out;
}
g_free (item);
addr = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
g_array_append_val (addr, tmp_addr.s_addr);
g_array_append_val (addr, prefix);
if (tmp_gateway.s_addr)
g_array_append_val (addr, tmp_gateway.s_addr);
else
g_array_append_val (addr, empty_val);
g_ptr_array_add (addresses, addr);
iter_valid = gtk_tree_model_iter_next (model, &tree_iter);
}
/* Don't pass empty array to the setting */
if (!addresses->len) {
g_ptr_array_free (addresses, TRUE);
addresses = NULL;
}
/* DNS servers */
dns_servers = g_array_new (FALSE, FALSE, sizeof (guint));
text = gtk_entry_get_text (GTK_ENTRY (priv->dns_servers));
if (text && strlen (text)) {
items = g_strsplit_set (text, ", ;:", 0);
for (iter = items; *iter; iter++) {
struct in_addr tmp_addr;
char *stripped = g_strstrip (*iter);
if (!strlen (stripped))
continue;
if (inet_pton (AF_INET, stripped, &tmp_addr))
g_array_append_val (dns_servers, tmp_addr.s_addr);
else {
g_strfreev (items);
goto out;
}
}
g_strfreev (items);
}
/* Search domains */
text = gtk_entry_get_text (GTK_ENTRY (priv->dns_searches));
if (text && strlen (text)) {
items = g_strsplit_set (text, ", ;:", 0);
for (iter = items; *iter; iter++) {
char *stripped = g_strstrip (*iter);
if (strlen (stripped))
search_domains = g_slist_prepend (search_domains, g_strdup (stripped));
}
if (items)
g_strfreev (items);
}
search_domains = g_slist_reverse (search_domains);
/* DHCP client ID */
if (!strcmp (method, NM_SETTING_IP4_CONFIG_METHOD_AUTO)) {
dhcp_client_id = gtk_entry_get_text (priv->dhcp_client_id);
if (dhcp_client_id && !strlen (dhcp_client_id))
dhcp_client_id = NULL;
}
/* Update setting */
g_object_set (priv->setting,
NM_SETTING_IP4_CONFIG_METHOD, method,
NM_SETTING_IP4_CONFIG_ADDRESSES, addresses,
NM_SETTING_IP4_CONFIG_DNS, dns_servers,
NM_SETTING_IP4_CONFIG_DNS_SEARCH, search_domains,
NM_SETTING_IP4_CONFIG_IGNORE_AUTO_DNS, ignore_auto_dns,
NM_SETTING_IP4_CONFIG_DHCP_CLIENT_ID, dhcp_client_id,
NULL);
valid = TRUE;
out:
if (addresses) {
g_ptr_array_foreach (addresses, (GFunc) free_one_addr, NULL);
g_ptr_array_free (addresses, TRUE);
}
if (dns_servers)
g_array_free (dns_servers, TRUE);
g_slist_foreach (search_domains, (GFunc) g_free, NULL);
g_slist_free (search_domains);
return valid;
}
static void ibus_handwrite_recog_init(IbusHandwriteRecog*obj)
{
obj->matched =g_array_new(TRUE,TRUE,sizeof(MatchedChar));
obj->strokes = g_array_sized_new(TRUE,TRUE,sizeof(LineStroke),0);
}
static gboolean
panel_multiscreen_get_randr_monitors_for_screen (GdkScreen *screen,
int *monitors_ret,
GdkRectangle **geometries_ret)
{
#ifdef HAVE_RANDR
Display *xdisplay;
Window xroot;
XRRScreenResources *resources;
RROutput primary;
GArray *geometries;
int i;
gboolean driver_is_pre_randr_1_2;
if (!have_randr)
return FALSE;
/* GTK+ 2.14.x uses the Xinerama API, instead of RANDR, to get the
* monitor geometries. It does this to avoid calling
* XRRGetScreenResources(), which is slow as it re-detects all the
* monitors --- note that XRRGetScreenResourcesCurrent() had not been
* introduced yet. Using Xinerama in GTK+ has the bad side effect that
* gdk_screen_get_monitor_plug_name() will return NULL, as Xinerama
* does not provide that information, unlike RANDR.
*
* Here we need to identify the output names, so that we can put the
* built-in LCD in a laptop *before* all other outputs. This is so
* that gnome-panel will normally prefer to appear on the "native"
* display rather than on an external monitor.
*
* To get the output names and geometries, we will not use
* gdk_screen_get_n_monitors() and friends, but rather we will call
* XRR*() directly.
*
* See https://bugzilla.novell.com/show_bug.cgi?id=479684 for this
* particular bug, and and
* http://bugzilla.gnome.org/show_bug.cgi?id=562944 for a more
* long-term solution.
*/
xdisplay = GDK_SCREEN_XDISPLAY (screen);
xroot = GDK_WINDOW_XID (gdk_screen_get_root_window (screen));
#if (RANDR_MAJOR > 1 || (RANDR_MAJOR == 1 && RANDR_MINOR >= 3))
if (have_randr_1_3) {
resources = XRRGetScreenResourcesCurrent (xdisplay, xroot);
if (resources->noutput == 0) {
/* This might happen if nothing tried to get randr
* resources from the server before, so we need an
* active probe. See comment #27 in
* https://bugzilla.gnome.org/show_bug.cgi?id=597101 */
XRRFreeScreenResources (resources);
resources = XRRGetScreenResources (xdisplay, xroot);
}
} else
resources = XRRGetScreenResources (xdisplay, xroot);
#else
resources = XRRGetScreenResources (xdisplay, xroot);
#endif
if (!resources)
return FALSE;
primary = None;
#if (RANDR_MAJOR > 1 || (RANDR_MAJOR == 1 && RANDR_MINOR >= 3))
if (have_randr_1_3)
primary = XRRGetOutputPrimary (xdisplay, xroot);
#endif
geometries = g_array_sized_new (FALSE, FALSE,
sizeof (GdkRectangle),
resources->noutput);
driver_is_pre_randr_1_2 = FALSE;
for (i = 0; i < resources->noutput; i++) {
XRROutputInfo *output;
output = XRRGetOutputInfo (xdisplay, resources,
resources->outputs[i]);
/* Drivers before RANDR 1.2 return "default" for the output
* name */
if (g_strcmp0 (output->name, "default") == 0)
driver_is_pre_randr_1_2 = TRUE;
if (output->connection != RR_Disconnected &&
output->crtc != 0) {
XRRCrtcInfo *crtc;
GdkRectangle rect;
crtc = XRRGetCrtcInfo (xdisplay, resources,
output->crtc);
rect.x = crtc->x;
rect.y = crtc->y;
rect.width = crtc->width;
rect.height = crtc->height;
XRRFreeCrtcInfo (crtc);
if (_panel_multiscreen_output_should_be_first (xdisplay,
resources->outputs[i],
output, primary))
g_array_prepend_vals (geometries, &rect, 1);
else
g_array_append_vals (geometries, &rect, 1);
}
XRRFreeOutputInfo (output);
}
XRRFreeScreenResources (resources);
if (driver_is_pre_randr_1_2) {
/* Drivers before RANDR 1.2 don't provide useful info about
* outputs */
g_array_free (geometries, TRUE);
return FALSE;
}
if (geometries->len == 0) {
/* This can happen in at least one case:
* https://bugzilla.novell.com/show_bug.cgi?id=543876 where all
* monitors appear disconnected (possibly because the screen
* is behing a KVM switch) -- see comment #8.
* There might be other cases too, so we stay on the safe side.
*/
g_array_free (geometries, TRUE);
return FALSE;
}
*monitors_ret = geometries->len;
*geometries_ret = (GdkRectangle *) g_array_free (geometries, FALSE);
return TRUE;
#else
return FALSE;
#endif
}
static const GValue *
gda_data_access_wrapper_get_value_at (GdaDataModel *model, gint col, gint row, GError **error)
{
GdaDataAccessWrapper *imodel;
g_return_val_if_fail (GDA_IS_DATA_ACCESS_WRAPPER (model), NULL);
imodel = (GdaDataAccessWrapper*) model;
g_return_val_if_fail (imodel->priv, NULL);
g_return_val_if_fail (imodel->priv->model, NULL);
g_return_val_if_fail (row >= 0, NULL);
if (col >= imodel->priv->nb_cols) {
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_COLUMN_OUT_OF_RANGE_ERROR,
_("Column %d out of range (0-%d)"), col, imodel->priv->nb_cols - 1);
return NULL;
}
if (!imodel->priv->rows) {
/* imodel->priv->model is a random access model, use it */
if (imodel->priv->rows_mapping)
return gda_data_model_get_value_at (imodel->priv->model, imodel->priv->rows_mapping [col],
row, error);
else
return gda_data_model_get_value_at (imodel->priv->model, col, row, error);
}
else {
GdaRow *gda_row;
gint tmp;
tmp = row;
gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp);
if (gda_row) {
GValue *val = gda_row_get_value (gda_row, col);
if (gda_row_value_is_valid (gda_row, val))
return val;
else
return NULL;
}
else {
g_assert (imodel->priv->iter);
if (imodel->priv->iter_row < 0) {
if (gda_data_model_iter_move_next (imodel->priv->iter)) {
tmp = row;
gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp);
if (row == imodel->priv->iter_row) {
GValue *val = gda_row_get_value (gda_row, col);
if (gda_row_value_is_valid (gda_row, val))
return val;
else
return NULL;
}
}
else {
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", _("Can't set iterator's position"));
return NULL;
}
}
gda_row = NULL;
if (row != imodel->priv->iter_row) {
if (row > imodel->priv->iter_row) {
/* need to move forward */
while ((imodel->priv->iter_row < row) &&
gda_data_model_iter_move_next (imodel->priv->iter));
}
else {
/* need to move backwards */
g_assert (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD);
while ((imodel->priv->iter_row > row) &&
gda_data_model_iter_move_prev (imodel->priv->iter)) ;
}
}
if (! (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD) ||
! (imodel->priv->model_access_flags & GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD)) {
tmp = row;
gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp);
if (gda_row) {
GValue *val = gda_row_get_value (gda_row, col);
if (gda_row_value_is_valid (gda_row, val))
return val;
else
return NULL;
}
}
else {
/* in this case iter can be moved forward and backward at will => we only
* need to keep a pool of GdaRow for performances reasons */
tmp = row;
gda_row = g_hash_table_lookup (imodel->priv->rows, &tmp);
if (!gda_row) {
if (! imodel->priv->rows_buffer_array) {
imodel->priv->rows_buffer_array = g_array_sized_new (FALSE, FALSE,
sizeof (GdaRow*),
ROWS_POOL_SIZE);
imodel->priv->rows_buffer_index = g_array_sized_new (FALSE, FALSE,
sizeof (gint),
ROWS_POOL_SIZE);
}
else if (imodel->priv->rows_buffer_array->len == ROWS_POOL_SIZE) {
/* get rid of the oldest row (was model's index_row row)*/
gint index_row;
index_row = g_array_index (imodel->priv->rows_buffer_index, gint,
ROWS_POOL_SIZE - 1);
g_array_remove_index (imodel->priv->rows_buffer_array,
ROWS_POOL_SIZE - 1);
g_array_remove_index (imodel->priv->rows_buffer_index,
ROWS_POOL_SIZE - 1);
g_hash_table_remove (imodel->priv->rows, &index_row);
}
if (gda_data_model_iter_move_to_row (imodel->priv->iter, row)) {
gda_row = create_new_row (imodel);
g_array_prepend_val (imodel->priv->rows_buffer_array, gda_row);
g_array_prepend_val (imodel->priv->rows_buffer_index, imodel->priv->iter_row);
}
}
GValue *val;
val = gda_row ? gda_row_get_value (gda_row, col) : NULL;
if (gda_row && gda_row_value_is_valid (gda_row, val))
return val;
else
return NULL;
}
}
}
g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR,
"%s", _("Can't access data"));
return NULL;
}
rwsched_instance_t *
rwsched_instance_new(void)
{
struct rwsched_instance_s *instance;
// Allocate memory for the new instance
// Register the rwsched instance types
RW_CF_TYPE_REGISTER(rwsched_instance_ptr_t);
RW_CF_TYPE_REGISTER(rwsched_tasklet_ptr_t);
rwsched_CFRunLoopInit();
rwsched_CFSocketInit();
// Allocate the Master Resource-Tracking Handle
g_rwresource_track_handle = RW_RESOURCE_TRACK_CREATE_CONTEXT("The Master Context");
// Allocate a rwsched instance type and track it
instance = RW_CF_TYPE_MALLOC0(sizeof(*instance), rwsched_instance_ptr_t);
RW_CF_TYPE_VALIDATE(instance, rwsched_instance_ptr_t);
// Set the instance configuration
instance->config.single_thread = TRUE;
// For now use libdispatch only
instance->use_libdispatch_only = TRUE;
// libdispatch_init();
// Fake up a rwqueue placeholder object to use as the (NULL) DISPATCH_TARGET_QUEUE_DEFAULT
RW_ASSERT(instance->use_libdispatch_only);
instance->default_rwqueue = (rwsched_dispatch_queue_t) RW_MALLOC0_TYPE(sizeof(*instance->default_rwqueue), rwsched_dispatch_queue_t);
RW_ASSERT_TYPE(instance->default_rwqueue, rwsched_dispatch_queue_t);
instance->default_rwqueue->header.libdispatch_object._dq = DISPATCH_TARGET_QUEUE_DEFAULT;
// Fake up a rwqueue placeholder object to use as DISPATCH_TARGET_QUEUE_MAIN
RW_ASSERT(instance->use_libdispatch_only);
instance->main_rwqueue = (rwsched_dispatch_queue_t) RW_MALLOC0_TYPE(sizeof(*instance->main_rwqueue), rwsched_dispatch_queue_t);
RW_ASSERT_TYPE(instance->main_rwqueue, rwsched_dispatch_queue_t);
instance->main_rwqueue->header.libdispatch_object._dq = dispatch_get_main_queue();
// Fake up rwqueue placeholder objects for the usual four global
// queues. The pri values are not 0,1,2,3 or similar, they are
// -MAX, -2, 0, 2. We do not support arbitrary pri values, although
// I think the dispatch API is intended to.
RW_ASSERT(instance->use_libdispatch_only);
RW_STATIC_ASSERT(RWSCHED_DISPATCH_QUEUE_GLOBAL_CT == 4);
static long pris[RWSCHED_DISPATCH_QUEUE_GLOBAL_CT] = {
DISPATCH_QUEUE_PRIORITY_HIGH,
DISPATCH_QUEUE_PRIORITY_DEFAULT,
DISPATCH_QUEUE_PRIORITY_LOW,
DISPATCH_QUEUE_PRIORITY_BACKGROUND
};
int i; for (i=0; i<RWSCHED_DISPATCH_QUEUE_GLOBAL_CT; i++) {
instance->global_rwqueue[i].pri = pris[i];
instance->global_rwqueue[i].rwq = (rwsched_dispatch_queue_t) RW_MALLOC0_TYPE(sizeof(*instance->global_rwqueue[i].rwq), rwsched_dispatch_queue_t);
RW_ASSERT_TYPE(instance->global_rwqueue[i].rwq, rwsched_dispatch_queue_t);
instance->global_rwqueue[i].rwq->header.libdispatch_object._dq = dispatch_get_global_queue(pris[i], 0);
RW_ASSERT(instance->global_rwqueue[i].rwq->header.libdispatch_object._dq);
}
instance->main_cfrunloop_mode = kCFRunLoopDefaultMode;
//instance->main_cfrunloop_mode = CFSTR("TimerMode");
//instance->deferred_cfrunloop_mode = CFSTR("Deferred Mode");
// Allocate an array of tasklet pointers and track it
rwsched_tasklet_t *tasklet = NULL;
instance->tasklet_array = g_array_sized_new(TRUE, TRUE, sizeof(void *), 256);
g_array_append_val(instance->tasklet_array, tasklet);
rwsched_instance_ref(instance);
ck_pr_inc_32(&g_rwsched_instance_count);
//RW_ASSERT(g_rwsched_instance_count <= 2);
g_rwsched_instance = instance;
instance->rwlog_instance = rwlog_init("RW.Sched");
// Return the instance pointer
return instance;
}
static GPtrArray *
read_ip4_addresses (GKeyFile *file,
const char *setting_name,
const char *key)
{
GPtrArray *addresses;
int i = 0;
addresses = g_ptr_array_sized_new (3);
/* Look for individual addresses */
while (i++ < 1000) {
gchar **tmp, **iter;
char *key_name;
gsize length = 0;
int ret;
GArray *address;
guint32 empty = 0;
int j;
key_name = g_strdup_printf ("%s%d", key, i);
tmp = g_key_file_get_string_list (file, setting_name, key_name, &length, NULL);
g_free (key_name);
if (!tmp || !length)
break; /* all done */
if ((length < 2) || (length > 3)) {
g_warning ("%s: ignoring invalid IPv4 address item '%s'", __func__, key_name);
goto next;
}
/* convert the string array into IP addresses */
address = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 3);
for (iter = tmp, j = 0; *iter; iter++, j++) {
struct in_addr addr;
if (j == 1) {
guint32 prefix = 0;
/* prefix */
if (!get_one_int (*iter, 32, key_name, &prefix)) {
g_array_free (address, TRUE);
goto next;
}
g_array_append_val (address, prefix);
} else {
/* address and gateway */
ret = inet_pton (AF_INET, *iter, &addr);
if (ret <= 0) {
g_warning ("%s: ignoring invalid IPv4 %s element '%s'", __func__, key_name, *iter);
g_array_free (address, TRUE);
goto next;
}
g_array_append_val (address, addr.s_addr);
}
}
/* fill in blank gateway if not specified */
if (address->len == 2)
g_array_append_val (address, empty);
g_ptr_array_add (addresses, address);
next:
g_strfreev (tmp);
}
if (addresses->len < 1) {
g_ptr_array_free (addresses, TRUE);
addresses = NULL;
}
return addresses;
}
static GPtrArray *
read_ip4_routes (GKeyFile *file,
const char *setting_name,
const char *key)
{
GPtrArray *routes;
int i = 0;
routes = g_ptr_array_sized_new (3);
/* Look for individual routes */
while (i++ < 1000) {
gchar **tmp, **iter;
char *key_name;
gsize length = 0;
int ret;
GArray *route;
int j;
key_name = g_strdup_printf ("%s%d", key, i);
tmp = g_key_file_get_string_list (file, setting_name, key_name, &length, NULL);
g_free (key_name);
if (!tmp || !length)
break; /* all done */
if (length != 4) {
g_warning ("%s: ignoring invalid IPv4 route item '%s'", __func__, key_name);
goto next;
}
/* convert the string array into IP addresses */
route = g_array_sized_new (FALSE, TRUE, sizeof (guint32), 4);
for (iter = tmp, j = 0; *iter; iter++, j++) {
struct in_addr addr;
if (j == 1) {
guint32 prefix = 0;
/* prefix */
if (!get_one_int (*iter, 32, key_name, &prefix)) {
g_array_free (route, TRUE);
goto next;
}
g_array_append_val (route, prefix);
} else if (j == 3) {
guint32 metric = 0;
/* metric */
if (!get_one_int (*iter, G_MAXUINT32, key_name, &metric)) {
g_array_free (route, TRUE);
goto next;
}
g_array_append_val (route, metric);
} else {
/* address and next hop */
ret = inet_pton (AF_INET, *iter, &addr);
if (ret <= 0) {
g_warning ("%s: ignoring invalid IPv4 %s element '%s'", __func__, key_name, *iter);
g_array_free (route, TRUE);
goto next;
}
g_array_append_val (route, addr.s_addr);
}
}
g_ptr_array_add (routes, route);
next:
g_strfreev (tmp);
}
if (routes->len < 1) {
g_ptr_array_free (routes, TRUE);
routes = NULL;
}
return routes;
}
static void
hanja_key_list_init(HanjaKeyList* list)
{
list->all_modifiers = 0;
list->keys = g_array_sized_new(FALSE, TRUE, sizeof(struct KeyEvent), 4);
}
static void
pgd_annots_update_selected_text (PgdAnnotsDemo *demo)
{
PopplerRectangle doc_area, *rects = NULL, *r = NULL;
gdouble width, height;
GArray *quads_array = NULL;
guint n_rects;
gint i, lines = 0;
GList *l_rects = NULL, *list;
poppler_page_get_size (demo->page, &width, &height);
doc_area.x1 = demo->start.x;
doc_area.y1 = demo->start.y;
doc_area.x2 = demo->stop.x;
doc_area.y2 = demo->stop.y;
if (! poppler_page_get_text_layout_for_area (demo->page, &doc_area,
&rects, &n_rects))
return;
r = g_slice_new (PopplerRectangle);
r->x1 = G_MAXDOUBLE; r->y1 = G_MAXDOUBLE;
r->x2 = G_MINDOUBLE; r->y2 = G_MINDOUBLE;
for (i = 0; i < n_rects; i++) {
/* Check if the rectangle belongs to the same line.
On a new line, start a new target rectangle.
On the same line, make an union of rectangles at
the same line */
if (ABS(r->y2 - rects[i].y2) > 0.0001) {
if (i > 0)
l_rects = g_list_append (l_rects, r);
r = g_slice_new (PopplerRectangle);
r->x1 = rects[i].x1;
r->y1 = rects[i].y1;
r->x2 = rects[i].x2;
r->y2 = rects[i].y2;
lines++;
} else {
r->x1 = MIN(r->x1, rects[i].x1);
r->y1 = MIN(r->y1, rects[i].y1);
r->x2 = MAX(r->x2, rects[i].x2);
r->y2 = MAX(r->y2, rects[i].y2);
}
}
l_rects = g_list_append (l_rects, r);
l_rects = g_list_reverse (l_rects);
quads_array = g_array_sized_new (TRUE, TRUE,
sizeof (PopplerQuadrilateral),
lines);
g_array_set_size (quads_array, lines);
for (list = l_rects, i = 0; list; list = list->next, i++) {
PopplerQuadrilateral *quad;
quad = &g_array_index (quads_array, PopplerQuadrilateral, i);
r = (PopplerRectangle *)list->data;
quad->p1.x = r->x1;
quad->p1.y = height - r->y1;
quad->p2.x = r->x2;
quad->p2.y = height - r->y1;
quad->p3.x = r->x1;
quad->p3.y = height - r->y2;
quad->p4.x = r->x2;
quad->p4.y = height - r->y2;
g_slice_free (PopplerRectangle, r);
}
poppler_annot_text_markup_set_quadrilaterals (POPPLER_ANNOT_TEXT_MARKUP (demo->active_annot), quads_array);
g_array_free (quads_array, TRUE);
g_free (rects);
g_list_free (l_rects);
}
PyObject *
pygi_get_property_value_real (PyGObject *instance,
const gchar *attr_name)
{
GType g_type;
GIPropertyInfo *property_info = NULL;
char *property_name = g_strdup (attr_name);
GParamSpec *pspec = NULL;
GValue value = { 0, };
GIArgument arg = { 0, };
PyObject *py_value = NULL;
GITypeInfo *type_info = NULL;
GITransfer transfer;
canonicalize_key (property_name);
g_type = pyg_type_from_object ((PyObject *)instance);
property_info = _pygi_lookup_property_from_g_type (g_type, property_name);
if (property_info == NULL)
goto out;
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (instance->obj),
attr_name);
if (pspec == NULL)
goto out;
g_value_init (&value, G_PARAM_SPEC_VALUE_TYPE (pspec));
g_object_get_property (instance->obj, attr_name, &value);
type_info = g_property_info_get_type (property_info);
transfer = g_property_info_get_ownership_transfer (property_info);
GITypeTag type_tag = g_type_info_get_tag (type_info);
switch (type_tag) {
case GI_TYPE_TAG_BOOLEAN:
arg.v_boolean = g_value_get_boolean (&value);
break;
case GI_TYPE_TAG_INT8:
arg.v_int8 = g_value_get_schar (&value);
break;
case GI_TYPE_TAG_INT16:
case GI_TYPE_TAG_INT32:
if (G_VALUE_HOLDS_LONG (&value))
arg.v_long = g_value_get_long (&value);
else
arg.v_int = g_value_get_int (&value);
break;
case GI_TYPE_TAG_INT64:
if (G_VALUE_HOLDS_LONG (&value))
arg.v_long = g_value_get_long (&value);
else
arg.v_int64 = g_value_get_int64 (&value);
break;
case GI_TYPE_TAG_UINT8:
arg.v_uint8 = g_value_get_uchar (&value);
break;
case GI_TYPE_TAG_UINT16:
case GI_TYPE_TAG_UINT32:
if (G_VALUE_HOLDS_ULONG (&value))
arg.v_ulong = g_value_get_ulong (&value);
else
arg.v_uint = g_value_get_uint (&value);
break;
case GI_TYPE_TAG_UINT64:
if (G_VALUE_HOLDS_ULONG (&value))
arg.v_ulong = g_value_get_ulong (&value);
else
arg.v_uint64 = g_value_get_uint64 (&value);
break;
case GI_TYPE_TAG_FLOAT:
arg.v_float = g_value_get_float (&value);
break;
case GI_TYPE_TAG_DOUBLE:
arg.v_double = g_value_get_double (&value);
break;
case GI_TYPE_TAG_GTYPE:
arg.v_size = g_value_get_gtype (&value);
break;
case GI_TYPE_TAG_UTF8:
case GI_TYPE_TAG_FILENAME:
arg.v_string = g_value_dup_string (&value);
break;
case GI_TYPE_TAG_INTERFACE:
{
GIBaseInfo *info;
GIInfoType info_type;
GType type;
info = g_type_info_get_interface (type_info);
type = g_registered_type_info_get_g_type (info);
info_type = g_base_info_get_type (info);
g_base_info_unref (info);
switch (info_type) {
case GI_INFO_TYPE_ENUM:
arg.v_int32 = g_value_get_enum (&value);
break;
case GI_INFO_TYPE_INTERFACE:
case GI_INFO_TYPE_OBJECT:
arg.v_pointer = g_value_get_object (&value);
break;
case GI_INFO_TYPE_BOXED:
case GI_INFO_TYPE_STRUCT:
case GI_INFO_TYPE_UNION:
if (g_type_is_a (type, G_TYPE_BOXED)) {
arg.v_pointer = g_value_get_boxed (&value);
} else if (g_type_is_a (type, G_TYPE_POINTER)) {
arg.v_pointer = g_value_get_pointer (&value);
} else {
PyErr_Format (PyExc_NotImplementedError,
"Retrieving properties of type '%s' is not implemented",
g_type_name (type));
}
break;
default:
PyErr_Format (PyExc_NotImplementedError,
"Retrieving properties of type '%s' is not implemented",
g_type_name (type));
goto out;
}
break;
}
case GI_TYPE_TAG_GHASH:
arg.v_pointer = g_value_get_boxed (&value);
break;
case GI_TYPE_TAG_GLIST:
arg.v_pointer = g_value_get_pointer (&value);
break;
case GI_TYPE_TAG_ARRAY:
{
gchar** strings;
GArray *arg_items;
int i;
strings = g_value_get_boxed (&value);
if (strings == NULL)
arg.v_pointer = NULL;
else {
arg_items = g_array_sized_new (TRUE, TRUE, sizeof (GIArgument), g_strv_length (strings));
g_array_set_size (arg_items, g_strv_length (strings));
for (i = 0; strings[i] != NULL; ++i) {
g_array_index (arg_items, GIArgument, i).v_string = strings[i];
}
arg.v_pointer = arg_items;
}
break;
}
default:
PyErr_Format (PyExc_NotImplementedError,
"Retrieving properties of type %s is not implemented",
g_type_tag_to_string (g_type_info_get_tag (type_info)));
goto out;
}
py_value = _pygi_argument_to_object (&arg, type_info, transfer);
out:
g_free (property_name);
if (property_info != NULL)
g_base_info_unref (property_info);
if (type_info != NULL)
g_base_info_unref (type_info);
return py_value;
}
/**
* world_new:
*
**/
World*
world_new(
RMeshGroup* groups
)
{
World* world;
WorldNode node;
gchar* group_name;
RMesh* group;
GHashTableIter iter;
gchar** tokens;
guint id, id1, id2;
world = g_slice_new0(World);
world->nodes = g_array_sized_new(
FALSE,
TRUE,
sizeof(WorldNode),
g_hash_table_size(groups->groups));
world->groups = groups;
id = 0;
g_hash_table_iter_init(&iter, world->groups->groups);
while(g_hash_table_iter_next(&iter, (gpointer)&group_name, (gpointer)&group))
{
if(!g_str_has_prefix(group_name, "R"))
{
continue;
}
tokens = g_strsplit(group_name, "_", 0);
id1 = g_ascii_strtoll(tokens[1], NULL, 10);
g_strfreev(tokens);
node.room.id = id1;
node.room.type = WORLD_ROOM;
node.room.mesh = group;
r_mesh_compute_bbox(node.room.mesh, 0, node.room.bbox);
node.room.portals = NULL;
node.room.scultures = NULL;
g_array_append_val(world->nodes, node);
id++;
}
g_array_sort(world->nodes, _world_node_compare);
g_hash_table_iter_init(&iter, world->groups->groups);
while(g_hash_table_iter_next(&iter, (gpointer)&group_name, (gpointer)&group))
{
if(!g_str_has_prefix(group_name, "P"))
{
continue;
}
tokens = g_strsplit(group_name, "_", 0);
id1 = g_ascii_strtoll(tokens[1], NULL, 10);
id2 = g_ascii_strtoll(tokens[2], NULL, 10);
g_strfreev(tokens);
node.portal.id = id;
node.portal.type = WORLD_PORTAL;
node.portal.mesh = group;
r_mesh_compute_bbox(node.portal.mesh, 0, node.portal.bbox);
node.portal.front = &g_array_index(world->nodes, WorldNode, id1);
node.portal.back = &g_array_index(world->nodes, WorldNode, id2);
g_array_append_val(world->nodes, node);
node.portal.front->room.portals = g_list_prepend(
node.portal.front->room.portals,
&g_array_index(world->nodes, WorldNode, id)
);
node.portal.back->room.portals = g_list_prepend(
node.portal.back->room.portals,
&g_array_index(world->nodes, WorldNode, id)
);
id++;
}
g_hash_table_iter_init(&iter, world->groups->groups);
while (g_hash_table_iter_next(&iter, (gpointer)&group_name, (gpointer)&group))
{
if(!g_str_has_prefix(group_name, "S"))
{
continue;
}
tokens = g_strsplit(group_name, "_", 0);
id1 = g_ascii_strtoll(tokens[1], NULL, 10);
g_strfreev(tokens);
node.sculture.id = id;
node.sculture.type = WORLD_SCULTURE;
node.sculture.mesh = group;
r_mesh_compute_bbox(node.sculture.mesh, 0, node.sculture.bbox);
node.sculture.owner = &g_array_index(world->nodes, WorldNode, id1);
g_array_append_val(world->nodes, node);
node.sculture.owner->room.scultures = g_list_prepend(
node.sculture.owner->room.scultures,
&g_array_index(world->nodes, WorldNode, id)
);
id++;
}
return world;
}
void builddata(gchar *datafilename, glong &wordcount, glong &idxfilesize, glong &synwordcount, std::list<std::string> *TagList, std::list<std::string> *ElementList)
{
struct stat stats;
if (stat (datafilename, &stats) == -1) {
printf("File %s not exist!\n", datafilename);
return;
}
FILE *datafile;
datafile = fopen(datafilename,"r");
gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
size_t fread_size;
fread_size = fread (buffer, 1, stats.st_size, datafile);
if (fread_size != (size_t)stats.st_size) {
g_print("fread error!\n");
}
fclose (datafile);
buffer[stats.st_size] = '\0';
GArray *array = g_array_sized_new(FALSE,FALSE, sizeof(struct _worditem),20000);
GArray *array2 = g_array_sized_new(FALSE,FALSE, sizeof(struct _synworditem),20000);
gchar *p, *p1, *p2, *p3, *p4, *p5;
p = buffer;
struct _worditem worditem;
while (1) {
//p1 = strstr(p, "<单词块>"); //Powerword 2007
p1 = strstr(p, "<CK>"); //Powerword 2012
if (!p1) {
g_print("over\n");
break;
}
//p1 += strlen("<单词块>");
p1 += strlen("<CK>");
//p2 = strstr(p1, "</单词块>");
p2 = strstr(p1, "</CK>");
if (!p2) {
//g_print("Error, no </单词块>\n");
g_print("Error, no </CK>\n");
return;
}
*p2='\0';
//p2 += strlen("</单词块>");
p2 += strlen("</CK>");
//p3 = strstr(p1, "<单词>");
p3 = strstr(p1, "<DC>");
p5 = p1;
while (g_ascii_isspace(*p5))
p5++;
if (p5!=p3) {
//g_print("Warning, not begin with <单词>.\n");
g_print("Warning, not begin with <DC>.\n");
}
if (!p3) {
//g_print("Error, no <单词>\n");
g_print("Error, no <DC>\n");
return;
}
//p3 += strlen("<单词>");
p3 += strlen("<DC>");
//p4 = strstr(p3, "</单词>");
p4 = strstr(p3, "</DC>");
if (!p4) {
//g_print("Error, no </单词>\n");
g_print("Error, no </DC>\n");
return;
}
*p4='\0';
//p4 += strlen("</单词>");
p4 += strlen("</DC>");
worditem.word = get_cdata(p3);
if (!worditem.word) {
return;
}
if (!worditem.word[0]) {
g_print("Bad word!\n");
p = p2;
continue;
}
while (g_ascii_isspace(*p4)) {
p4++;
}
worditem.definition = p4;
g_strstrip(worditem.definition);
if (!worditem.definition[0]) {
g_print("Bad definition!\n");
return;
}
ParseUserData Data;
Data.word = worditem.word;
Data.definition = worditem.definition;
std::list<std::string> WordList;
Data.WordList = &WordList;
Data.array = array2;
Data.TagList = TagList;
Data.ElementList = ElementList;
parse_definition(worditem.definition, &Data);
g_array_append_val(array, worditem);
p = p2;
}
g_array_sort(array,comparefunc);
g_array_sort(array2,comparefunc2);
gchar *basefilename = g_strdup(datafilename);
p = strchr(basefilename, '.');
if (p)
*p='\0';
gchar idxfilename[256];
gchar dicfilename[256];
sprintf(idxfilename, "powerword2012_%s.idx", basefilename);
sprintf(dicfilename, "powerword2012_%s.dict", basefilename);
FILE *idxfile = fopen(idxfilename,"w");
FILE *dicfile = fopen(dicfilename,"w");
guint32 offset_old;
guint32 tmpglong;
struct _worditem *pworditem; gint definition_len;
gulong i;
for (i=0; i< array->len; i++) {
offset_old = ftell(dicfile);
pworditem = &g_array_index(array, struct _worditem, i);
definition_len = strlen(pworditem->definition);
fwrite(pworditem->definition, 1 ,definition_len,dicfile);
fwrite(pworditem->word,sizeof(gchar),strlen(pworditem->word)+1,idxfile);
tmpglong = g_htonl(offset_old);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
tmpglong = g_htonl(definition_len);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
}
idxfilesize = ftell(idxfile);
fclose(idxfile);
fclose(dicfile);
g_print("%s wordcount: %d\n", datafilename, array->len);
wordcount = array->len;
synwordcount = array2->len;
if (array2->len) {
gchar synfilename[256];
sprintf(synfilename, "powerword2012_%s.syn", basefilename);
FILE *synfile = fopen(synfilename,"w");
struct _synworditem *psynworditem;
gint iFrom, iTo, iThisIndex, cmpint;
bool bFound;
for (i=0; i< array2->len; i++) {
psynworditem = &g_array_index(array2, struct _synworditem, i);
fwrite(psynworditem->synword, 1, strlen(psynworditem->synword)+1, synfile);
g_free(psynworditem->synword);
bFound=false;
iFrom=0;
iTo=array->len-1;
while (iFrom<=iTo) {
iThisIndex=(iFrom+iTo)/2;
pworditem = &g_array_index(array, struct _worditem, iThisIndex);
cmpint = stardict_strcmp(psynworditem->origword, pworditem->word);
if (cmpint>0)
iFrom=iThisIndex+1;
else if (cmpint<0)
iTo=iThisIndex-1;
else {
bFound=true;
break;
}
}
if (!bFound) {
g_print("Error, %s not find.\n", psynworditem->origword);
return;
}
do {
if (iThisIndex==0)
break;
pworditem = &g_array_index(array, struct _worditem, iThisIndex-1);
if (strcmp(psynworditem->origword, pworditem->word)==0)
iThisIndex--;
else
break;
} while (true);
bFound=false;
do {
pworditem = &g_array_index(array, struct _worditem, iThisIndex);
if (strcmp(psynworditem->origword, pworditem->word)==0) {
if (psynworditem->definition == pworditem->definition) {
bFound=true;
break;
} else
iThisIndex++;
} else
break;
} while (true);
if (!bFound) {
g_print("Error, %s definition not find.\n", psynworditem->origword);
return;
}
tmpglong = g_htonl(iThisIndex);
fwrite(&(tmpglong),sizeof(guint32),1, synfile);
}
fclose(synfile);
g_print("synwordcount: %d\n", array2->len);
}
int
test_buffer_2(void * data)
{
mfp_procinfo * line_t = g_hash_table_lookup(mfp_proc_registry, "line~");
mfp_procinfo * buf_t = g_hash_table_lookup(mfp_proc_registry, "buffer~");
mfp_processor * line = mfp_proc_create(line_t, 0, 1, (mfp_context *)data);
mfp_processor * b = mfp_proc_create(buf_t, 2, 1, (mfp_context *)data);
GArray * lparm = g_array_sized_new(TRUE, TRUE, sizeof(float), 3);
builtin_buffer_data * info = (builtin_buffer_data *)b->data;
int blocksize = ((mfp_context *)data)->blocksize;
int i;
int fail=0;
float ft;
ft = (float)(1000.0*(((mfp_context *)data)->blocksize/2)/((mfp_context *)data)->samplerate);
g_array_append_val(lparm, ft);
ft = 5.0;
g_array_append_val(lparm, ft);
ft = 0.0;
g_array_append_val(lparm, ft);
setparam_float(b, "buf_mode", 3.0);
setparam_float(b, "rec_channels", 1.0);
setparam_float(b, "rec_enabled", 1.0);
setparam_float(b, "trig_channel", 0.0);
setparam_float(b, "trig_thresh", 2.0);
setparam_float(b, "channels", 1.0);
setparam_float(b, "size", ((mfp_context *)data)->blocksize);
mfp_proc_connect(line, 0, b, 0);
mfp_dsp_schedule((mfp_context *)data);
mfp_dsp_run((mfp_context *)data);
/* give alloc thread time to work */
usleep(100000);
/* bang the line~ */
setparam_gpointer(line, "segments", lparm);
line->needs_config = 1;
mfp_dsp_run((mfp_context *)data);
if((info->buf_active.shm_fd == -1)
|| (info->buf_active.buf_size != blocksize*sizeof(float))
|| (info->chan_count != 1)
|| (info->chan_size != blocksize)) {
printf("config fail %d %d %d %d\n", info->buf_active.shm_fd,
info->buf_active.buf_size,
info->chan_count, info->chan_size);
return 0;
}
for(i=0; i < blocksize; i++) {
if (i < blocksize/2.0) {
if (info->buf_base == NULL || ((float *)(info->buf_base))[i] != 5.0) {
printf("Fail at %d (%f should be 5.0)\n", i, ((float *)(info->buf_base))[i]);
fail = 1;
}
}
else {
if (info->buf_base == NULL || ((float *)(info->buf_base))[i] != 0.0) {
printf("Fail at %d (%f should be 0.0)\n", i, ((float *)(info->buf_base))[i]);
fail = 1;
}
}
}
if (fail)
return 0;
return 1;
}
int
quick_dialog_skip (quick_dialog_t * quick_dlg, int nskip)
{
int len;
int blen = 0;
int x, y; /* current positions */
int y1 = 0; /* bottom of 1st column in case of two columns */
int y2 = -1; /* start of two columns */
int width1 = 0; /* width of single column */
int width2 = 0; /* width of each of two columns */
gboolean have_groupbox = FALSE;
gboolean two_columns = FALSE;
gboolean put_buttons = FALSE;
/* x position of 1st column is 3 */
const int x1 = 3;
/* x position of 2nd column is 4 and it will be fixed later, after creation of all widgets */
int x2 = 4;
GArray *widgets;
size_t i;
quick_widget_t *quick_widget;
WGroupbox *g = NULL;
WDialog *dd;
GList *input_labels = NULL; /* Widgets not directly requested by the user. */
int return_val;
len = str_term_width1 (I18N (quick_dlg->title)) + 6;
quick_dlg->cols = MAX (quick_dlg->cols, len);
y = 1;
x = x1;
/* create widgets */
widgets = g_array_sized_new (FALSE, FALSE, sizeof (quick_widget_item_t), 8);
for (quick_widget = quick_dlg->widgets; quick_widget->widget_type != quick_end; quick_widget++)
{
quick_widget_item_t item = { NULL, quick_widget };
int width = 0;
switch (quick_widget->widget_type)
{
case quick_checkbox:
item.widget =
WIDGET (check_new
(++y, x, *quick_widget->u.checkbox.state,
I18N (quick_widget->u.checkbox.text)));
g_array_append_val (widgets, item);
width = item.widget->cols;
if (g != NULL)
width += 2;
if (two_columns)
width2 = MAX (width2, width);
else
width1 = MAX (width1, width);
break;
case quick_button:
/* single button */
item.widget = WIDGET (button_new (++y, x, quick_widget->u.button.action,
quick_widget->u.button.action == B_ENTER ?
DEFPUSH_BUTTON : NORMAL_BUTTON,
I18N (quick_widget->u.button.text),
quick_widget->u.button.callback));
g_array_append_val (widgets, item);
width = item.widget->cols;
if (g != NULL)
width += 2;
if (two_columns)
width2 = MAX (width2, width);
else
width1 = MAX (width1, width);
break;
case quick_input:
*quick_widget->u.input.result = NULL;
y++;
if (quick_widget->u.input.label_location != input_label_none)
{
quick_create_labeled_input (widgets, &y, x, quick_widget, &width);
input_labels = g_list_prepend (input_labels, quick_widget->u.input.label);
}
else
{
item.widget = WIDGET (quick_create_input (y, x, quick_widget));
g_array_append_val (widgets, item);
width = item.widget->cols;
}
if (g != NULL)
width += 2;
if (two_columns)
width2 = MAX (width2, width);
else
width1 = MAX (width1, width);
break;
case quick_label:
item.widget = WIDGET (label_new (++y, x, I18N (quick_widget->u.label.text)));
g_array_append_val (widgets, item);
y += item.widget->lines - 1;
width = item.widget->cols;
if (g != NULL)
width += 2;
if (two_columns)
width2 = MAX (width2, width);
else
width1 = MAX (width1, width);
break;
case quick_radio:
{
WRadio *r;
char **items = NULL;
/* create the copy of radio_items to avoid mwmory leak */
items = g_new (char *, quick_widget->u.radio.count + 1);
for (i = 0; i < (size_t) quick_widget->u.radio.count; i++)
items[i] = g_strdup (_(quick_widget->u.radio.items[i]));
items[i] = NULL;
r = radio_new (++y, x, quick_widget->u.radio.count, (const char **) items);
r->pos = r->sel = *quick_widget->u.radio.value;
g_strfreev (items);
item.widget = WIDGET (r);
g_array_append_val (widgets, item);
y += item.widget->lines - 1;
width = item.widget->cols;
if (g != NULL)
width += 2;
if (two_columns)
width2 = MAX (width2, width);
else
width1 = MAX (width1, width);
}
break;
case quick_start_groupbox:
I18N (quick_widget->u.groupbox.title);
len = str_term_width1 (quick_widget->u.groupbox.title);
g = groupbox_new (++y, x, 1, len + 4, quick_widget->u.groupbox.title);
item.widget = WIDGET (g);
g_array_append_val (widgets, item);
have_groupbox = TRUE;
break;
case quick_stop_groupbox:
if (g != NULL)
{
Widget *w = WIDGET (g);
y++;
w->lines = y + 1 - w->y;
g = NULL;
g_array_append_val (widgets, item);
}
break;
case quick_separator:
y++;
if (quick_widget->u.separator.line)
{
item.widget = WIDGET (hline_new (y, x, 1));
g_array_append_val (widgets, item);
}
break;
case quick_start_columns:
y2 = y;
g_array_append_val (widgets, item);
two_columns = TRUE;
break;
case quick_next_column:
x = x2;
y1 = y;
y = y2;
break;
case quick_stop_columns:
x = x1;
y = MAX (y1, y);
g_array_append_val (widgets, item);
two_columns = FALSE;
break;
case quick_buttons:
/* start put several buttons in bottom line */
if (quick_widget->u.separator.space)
{
y++;
if (quick_widget->u.separator.line)
item.widget = WIDGET (hline_new (y, 1, -1));
}
g_array_append_val (widgets, item);
/* several buttons in bottom line */
y++;
quick_widget++;
for (; quick_widget->widget_type == quick_button; quick_widget++)
{
item.widget = WIDGET (button_new (y, x++, quick_widget->u.button.action,
quick_widget->u.button.action == B_ENTER ?
DEFPUSH_BUTTON : NORMAL_BUTTON,
I18N (quick_widget->u.button.text),
quick_widget->u.button.callback));
item.quick_widget = quick_widget;
g_array_append_val (widgets, item);
blen += item.widget->cols + 1;
}
/* stop dialog build here */
blen--;
quick_widget->widget_type = quick_end;
quick_widget--;
break;
default:
break;
}
}
/* adjust dialog width */
quick_dlg->cols = MAX (quick_dlg->cols, blen + 6);
if (have_groupbox)
{
if (width1 != 0)
width1 += 2;
if (width2 != 0)
width2 += 2;
}
if (width2 == 0)
len = width1 + 6;
else
{
len = width2 * 2 + 7;
if (width1 != 0)
len = MAX (len, width1 + 6);
}
quick_dlg->cols = MAX (quick_dlg->cols, len);
width1 = quick_dlg->cols - 6;
width2 = (quick_dlg->cols - 7) / 2;
if (quick_dlg->x == -1 || quick_dlg->y == -1)
dd = dlg_create (TRUE, 0, 0, y + 3, quick_dlg->cols, WPOS_CENTER | WPOS_TRYUP, FALSE,
dialog_colors, quick_dlg->callback, quick_dlg->mouse_callback,
quick_dlg->help, quick_dlg->title);
else
dd = dlg_create (TRUE, quick_dlg->y, quick_dlg->x, y + 3, quick_dlg->cols,
WPOS_KEEP_DEFAULT, FALSE, dialog_colors, quick_dlg->callback,
quick_dlg->mouse_callback, quick_dlg->help, quick_dlg->title);
/* add widgets into the dialog */
x2 = x1 + width2 + 1;
g = NULL;
two_columns = FALSE;
x = (WIDGET (dd)->cols - blen) / 2;
for (i = 0; i < widgets->len; i++)
{
quick_widget_item_t *item;
int column_width;
item = &g_array_index (widgets, quick_widget_item_t, i);
column_width = two_columns ? width2 : width1;
/* adjust widget width and x position */
switch (item->quick_widget->widget_type)
{
case quick_label:
{
quick_widget_t *input = item->quick_widget->u.label.input;
if (input != NULL && input->u.input.label_location == input_label_right)
{
/* location of this label will be adjusted later */
break;
}
}
/* fall through */
case quick_checkbox:
case quick_radio:
if (item->widget->x != x1)
item->widget->x = x2;
if (g != NULL)
item->widget->x += 2;
break;
case quick_button:
if (!put_buttons)
{
if (item->widget->x != x1)
item->widget->x = x2;
if (g != NULL)
item->widget->x += 2;
}
else
{
item->widget->x = x;
x += item->widget->cols + 1;
}
break;
case quick_input:
{
Widget *label = WIDGET (INPUT (item->widget)->label);
int width = column_width;
if (g != NULL)
width -= 4;
switch (item->quick_widget->u.input.label_location)
{
case input_label_left:
/* label was adjusted before; adjust input line */
item->widget->x = label->x + label->cols + 1 - WIDGET (label->owner)->x;
item->widget->cols = width - label->cols - 1;
break;
case input_label_right:
if (item->widget->x != x1)
item->widget->x = x2;
if (g != NULL)
item->widget->x += 2;
item->widget->cols = width - label->cols - 1;
label->x = item->widget->x + item->widget->cols + 1;
break;
default:
if (item->widget->x != x1)
item->widget->x = x2;
if (g != NULL)
item->widget->x += 2;
item->widget->cols = width;
break;
}
/* forced update internal variables of inpuit line */
widget_set_size (item->widget, item->widget->y, item->widget->x, 1,
item->widget->cols);
}
break;
case quick_start_groupbox:
g = GROUPBOX (item->widget);
if (item->widget->x != x1)
item->widget->x = x2;
item->widget->cols = column_width;
break;
case quick_stop_groupbox:
g = NULL;
break;
case quick_separator:
if (item->widget != NULL)
{
if (g != NULL)
{
Widget *wg = WIDGET (g);
HLINE (item->widget)->auto_adjust_cols = FALSE;
item->widget->x = wg->x + 1 - WIDGET (wg->owner)->x;
item->widget->cols = wg->cols;
}
else if (two_columns)
{
HLINE (item->widget)->auto_adjust_cols = FALSE;
if (item->widget->x != x1)
item->widget->x = x2;
item->widget->x--;
item->widget->cols = column_width + 2;
}
else
HLINE (item->widget)->auto_adjust_cols = TRUE;
}
break;
case quick_start_columns:
two_columns = TRUE;
break;
case quick_stop_columns:
two_columns = FALSE;
break;
case quick_buttons:
/* several buttons in bottom line */
put_buttons = TRUE;
break;
default:
break;
}
if (item->widget != NULL)
{
unsigned long id;
/* add widget into dialog */
item->widget->options |= item->quick_widget->options; /* FIXME: cannot reset flags, setup only */
item->widget->state |= item->quick_widget->state; /* FIXME: cannot reset flags, setup only */
id = add_widget_autopos (dd, item->widget, item->quick_widget->pos_flags, NULL);
if (item->quick_widget->id != NULL)
*item->quick_widget->id = id;
}
}
while (nskip-- != 0)
dlg_set_current_widget_next (dd);
return_val = dlg_run (dd);
/* Get the data if we found something interesting */
if (return_val != B_CANCEL)
for (i = 0; i < widgets->len; i++)
{
quick_widget_item_t *item;
item = &g_array_index (widgets, quick_widget_item_t, i);
switch (item->quick_widget->widget_type)
{
case quick_checkbox:
*item->quick_widget->u.checkbox.state = CHECK (item->widget)->state;
break;
case quick_input:
if ((quick_widget->u.input.completion_flags & INPUT_COMPLETE_CD) != 0)
*item->quick_widget->u.input.result =
tilde_expand (INPUT (item->widget)->buffer);
else
*item->quick_widget->u.input.result = g_strdup (INPUT (item->widget)->buffer);
break;
case quick_radio:
*item->quick_widget->u.radio.value = RADIO (item->widget)->sel;
break;
default:
break;
}
}
dlg_destroy (dd);
g_list_free_full (input_labels, g_free); /* destroy input labels created before */
g_array_free (widgets, TRUE);
return return_val;
}
static GstFlowReturn
gst_objectsinteraction_chain(GstPad *pad, GstBuffer *buf)
{
GstObjectsInteraction *filter;
// sanity checks
g_return_val_if_fail(pad != NULL, GST_FLOW_ERROR);
g_return_val_if_fail(buf != NULL, GST_FLOW_ERROR);
filter = GST_OBJECTSINTERACTION(GST_OBJECT_PARENT(pad));
filter->image->imageData = (char*) GST_BUFFER_DATA(buf);
// Process all objects
if ((filter->object_in_array != NULL) && (filter->object_in_array->len > 0)) {
// Find interceptions rects pairs
guint i, j;
for (i = 0; i < filter->object_in_array->len; ++i) {
for (j = i + 1; j < filter->object_in_array->len; ++j) {
InstanceObjectIn obj_a, obj_b;
gint interception;
obj_a = g_array_index(filter->object_in_array, InstanceObjectIn, i);
obj_b = g_array_index(filter->object_in_array, InstanceObjectIn, j);
interception = 100 * MIN(rectIntercept(&obj_a.rect, &obj_b.rect), rectIntercept(&obj_b.rect, &obj_a.rect));
if (interception) {
GstEvent *event;
GstMessage *message;
GstStructure *structure;
CvRect rect;
// Interception percentage
rect = rectIntersection(&obj_a.rect, &obj_b.rect);
if (filter->verbose)
GST_INFO_OBJECT(filter, "INTERCEPTION %i%%: rect_a(%i, %i, %i, %i), rect_b(%i, %i, %i, %i), rect_intercept(%i, %i, %i, %i)\n",
interception,
obj_a.rect.x, obj_a.rect.y, obj_a.rect.width, obj_a.rect.height,
obj_b.rect.x, obj_b.rect.y, obj_b.rect.width, obj_b.rect.height,
rect.x, rect.y, rect.width, rect.height);
// Draw intercept rect and label
if (filter->display) {
char *label;
float font_scaling;
cvRectangle(filter->image,
cvPoint(rect.x, rect.y),
cvPoint(rect.x + rect.width, rect.y + rect.height),
PRINT_COLOR, -1, 8, 0);
font_scaling = ((filter->image->width * filter->image->height) > (320 * 240)) ? 0.5f : 0.3f;
label = g_strdup_printf("%i+%i (%i%%)", obj_a.id, obj_b.id, interception);
printText(filter->image, cvPoint(rect.x + (rect.width / 2), rect.y + (rect.height / 2)), label, PRINT_COLOR, font_scaling, 1);
g_free(label);
}
// Send downstream event and bus message with the rect info
structure = gst_structure_new("object-interaction",
"id_a", G_TYPE_UINT, obj_a.id,
"id_b", G_TYPE_UINT, obj_b.id,
"percentage", G_TYPE_UINT, interception,
"x", G_TYPE_UINT, rect.x,
"y", G_TYPE_UINT, rect.y,
"width", G_TYPE_UINT, rect.width,
"height", G_TYPE_UINT, rect.height,
"timestamp", G_TYPE_UINT64, GST_BUFFER_TIMESTAMP(buf),
NULL);
message = gst_message_new_element(GST_OBJECT(filter), gst_structure_copy(structure));
gst_element_post_message(GST_ELEMENT(filter), message);
event = gst_event_new_custom(GST_EVENT_CUSTOM_DOWNSTREAM, structure);
gst_pad_push_event(filter->srcpad, event);
}
}
}
}
// Clean objects
g_array_free(filter->object_in_array, TRUE);
filter->object_in_array = g_array_sized_new(FALSE, FALSE, sizeof(InstanceObjectIn), 1);
gst_buffer_set_data(buf, (guint8*) filter->image->imageData, (guint) filter->image->imageSize);
return gst_pad_push(filter->srcpad, buf);
}
/**
* g_byte_array_new:
* @Returns: the new #GByteArray.
*
* Creates a new #GByteArray with a reference count of 1.
**/
GByteArray* g_byte_array_new (void)
{
return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, 0);
}
static gboolean
ensure_allowed_raw_caps (GstVaapiPluginBase * plugin)
{
GArray *formats, *out_formats;
GstVaapiSurface *surface;
GstVaapiDisplay *display;
guint i;
GstCaps *out_caps;
gboolean ret = FALSE;
if (plugin->allowed_raw_caps)
return TRUE;
out_formats = formats = NULL;
surface = NULL;
display = gst_vaapi_display_ref (plugin->display);
formats = gst_vaapi_display_get_image_formats (display);
if (!formats)
goto bail;
out_formats =
g_array_sized_new (FALSE, FALSE, sizeof (GstVideoFormat), formats->len);
if (!out_formats)
goto bail;
surface =
gst_vaapi_surface_new (display, GST_VAAPI_CHROMA_TYPE_YUV420, 64, 64);
if (!surface)
goto bail;
for (i = 0; i < formats->len; i++) {
const GstVideoFormat format = g_array_index (formats, GstVideoFormat, i);
GstVaapiImage *image;
if (format == GST_VIDEO_FORMAT_UNKNOWN)
continue;
image = gst_vaapi_image_new (display, format, 64, 64);
if (!image)
continue;
if (gst_vaapi_surface_put_image (surface, image))
g_array_append_val (out_formats, format);
gst_vaapi_object_unref (image);
}
out_caps = gst_vaapi_video_format_new_template_caps_from_list (out_formats);
if (!out_caps)
goto bail;
gst_caps_replace (&plugin->allowed_raw_caps, out_caps);
gst_caps_unref (out_caps);
ret = TRUE;
bail:
if (formats)
g_array_unref (formats);
if (out_formats)
g_array_unref (out_formats);
if (surface)
gst_vaapi_object_unref (surface);
gst_vaapi_display_unref (display);
return ret;
}
/**
* g_byte_array_sized_new:
* @reserved_size: number of bytes preallocated.
* @Returns: the new #GByteArray.
*
* Creates a new #GByteArray with @reserved_size bytes preallocated.
* This avoids frequent reallocation, if you are going to add many
* bytes to the array. Note however that the size of the array is still
* 0.
**/
GByteArray* g_byte_array_sized_new (guint reserved_size)
{
return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, reserved_size);
}
static void restore_state(session_callback_type type, gpointer data, gpointer user_data) {
JsonParser* jp = NULL;
JsonReader* jr = NULL;
const gchar* sqs;
saved_state* s = NULL;
GError* err = NULL;
/* Is it the callback we're interested in? */
if (type != SPOP_SESSION_LOGGED_IN)
return;
/* First disable the callback so it's not called again */
session_remove_callback(restore_state, NULL);
g_debug("savestate: reading saved state...");
s = g_new0(saved_state, 1);
/* Read and parse state file */
jp = json_parser_new();
if (!json_parser_load_from_file(jp, g_state_file_path, &err)) {
g_warning("savestate: error while reading state file: %s", err->message);
goto restorestate_error;
}
jr = json_reader_new(json_parser_get_root(jp));
/* Read basic state */
if (!json_reader_read_member(jr, "status")) goto restorestate_jr_error;
sqs = json_reader_get_string_value(jr);
json_reader_end_member(jr);
if (strcmp(sqs, "stopped")) s->qs = STOPPED;
else if (strcmp(sqs, "playing")) s->qs = PLAYING;
else if (strcmp(sqs, "paused")) s->qs = PAUSED;
else {
g_warning("savestate: bad value for queue status: %s", sqs);
goto restorestate_error;
}
if (!json_reader_read_member(jr, "repeat")) goto restorestate_jr_error;
s->repeat = json_reader_get_boolean_value(jr);
json_reader_end_member(jr);
if (!json_reader_read_member(jr, "shuffle")) goto restorestate_jr_error;
s->shuffle = json_reader_get_boolean_value(jr);
json_reader_end_member(jr);
if (!json_reader_read_member(jr, "current_track")) goto restorestate_jr_error;
s->cur_track = json_reader_get_int_value(jr);
json_reader_end_member(jr);
/* Now read tracks URIs */
if (!json_reader_read_member(jr, "tracks")) goto restorestate_jr_error;
if (!json_reader_is_array(jr)) {
g_warning("savestate: error while parsing JSON: tracks is not an array");
goto restorestate_error;
}
gint tracks = json_reader_count_elements(jr);
if (s->cur_track >= tracks) {
g_warning("savestate: incoherent state file: cur_track >= tracks");
goto restorestate_error;
}
s->tracks = g_array_sized_new(FALSE, FALSE, sizeof(sp_track*), tracks);
if (!s->tracks)
g_error("Can't allocate array of %d tracks.", tracks);
size_t i;
gboolean can_restore_now = TRUE;
for (i=0; i < tracks; i++) {
json_reader_read_element(jr, i);
const gchar* uri = json_reader_get_string_value(jr);
json_reader_end_element(jr);
sp_link* lnk = sp_link_create_from_string(uri);
sp_linktype lt = sp_link_type(lnk);
if (lt != SP_LINKTYPE_TRACK) {
g_warning("savestate: invalid link type for track %zu: %d", i, lt);
sp_link_release(lnk);
goto restorestate_error;
}
sp_track* tr = sp_link_as_track(lnk);
sp_track_add_ref(tr);
sp_link_release(lnk);
g_array_append_val(s->tracks, tr);
if (!sp_track_is_loaded(tr))
can_restore_now = FALSE;
}
/* If possible, restore now, else wait for all tracks to be loaded */
if (can_restore_now)
really_restore_state(s);
else {
g_timeout_add(100, (GSourceFunc) really_restore_state, s);
g_debug("savestate: waiting for all tracks to be loaded before restoring saved state...");
}
/* Add a notification callback */
if (!interface_notify_add_callback(savestate_notification_callback, NULL))
g_error("Could not add savestate callback.");
goto restorestate_clean;
restorestate_jr_error:
err = (GError*) json_reader_get_error(jr);
g_warning("savestate: error while parsing JSON: %s", err->message);
restorestate_error:
if (s) {
if (s->tracks)
g_array_free(s->tracks, TRUE);
g_free(s);
}
restorestate_clean:
if (jp)
g_object_unref(jp);
if (jr)
g_object_unref(jr);
}
void convert(const char *filename, print_info_t print_info)
{
struct stat stats;
if (g_stat (filename, &stats) == -1)
{
print_info("File not exist!\n");
return;
}
gchar *basefilename = g_path_get_basename(filename);
gchar *ch = strrchr(basefilename, '.');
if (ch)
*ch = '\0';
gchar *dirname = g_path_get_dirname(filename);
FILE *tabfile;
tabfile = g_fopen(filename,"r");
gchar *buffer = (gchar *)g_malloc (stats.st_size + 1);
size_t readsize = fread (buffer, 1, stats.st_size, tabfile);
fclose (tabfile);
buffer[readsize] = '\0';
GArray *array = g_array_sized_new(FALSE,FALSE, sizeof(struct _worditem),20000);
gchar *p, *p1, *p2;
p = buffer;
if ((guchar)*p==0xEF && (guchar)*(p+1)==0xBB && (guchar)*(p+2)==0xBF) // UTF-8 order characters.
p+=3;
struct _worditem worditem;
glong linenum=1;
while (1) {
if (*p == '\0') {
print_info("Convert over.\n");
break;
}
p1 = strchr(p,'\n');
if (!p1) {
print_info("Error, no new line at the end\n");
return;
}
*p1 = '\0';
p1++;
p2 = strchr(p,'=');
if (!p2) {
gchar *str = g_strdup_printf("Warning, no separater, %ld\n", linenum);
print_info(str);
g_free(str);
p= p1;
linenum++;
continue;
}
*p2 = '\0';
p2++;
worditem.word = p;
worditem.definition = p2;
my_strstrip(worditem.definition, linenum, print_info);
g_strstrip(worditem.word);
g_strstrip(worditem.definition);
if (!worditem.word[0]) {
gchar *str = g_strdup_printf("Warning: line %ld, bad word!\n", linenum);
print_info(str);
g_free(str);
p= p1;
linenum++;
continue;
}
if (!worditem.definition[0]) {
gchar *str = g_strdup_printf("Warning: line %ld, bad definition!\n", linenum);
print_info(str);
g_free(str);
p= p1;
linenum++;
continue;
}
g_array_append_val(array, worditem);
p= p1;
linenum++;
}
g_array_sort(array,comparefunc);
gchar ifofilename[256];
gchar idxfilename[256];
gchar dicfilename[256];
sprintf(ifofilename, "%s" G_DIR_SEPARATOR_S "%s.ifo", dirname, basefilename);
sprintf(idxfilename, "%s" G_DIR_SEPARATOR_S "%s.idx", dirname, basefilename);
sprintf(dicfilename, "%s" G_DIR_SEPARATOR_S "%s.dict", dirname, basefilename);
FILE *ifofile = g_fopen(ifofilename,"wb");
if (!ifofile) {
print_info("Write to ifo file failed!\n");
return;
}
FILE *idxfile = g_fopen(idxfilename,"wb");
if (!idxfile) {
print_info("Write to idx file failed!\n");
return;
}
FILE *dicfile = g_fopen(dicfilename,"wb");
if (!dicfile) {
print_info("Write to dict file failed!\n");
return;
}
guint32 offset_old;
guint32 tmpglong;
struct _worditem *pworditem;
gint definition_len;
gulong i;
for (i=0; i< array->len; i++) {
offset_old = ftell(dicfile);
pworditem = &g_array_index(array, struct _worditem, i);
definition_len = strlen(pworditem->definition);
fwrite(pworditem->definition, 1 ,definition_len,dicfile);
fwrite(pworditem->word,sizeof(gchar),strlen(pworditem->word)+1,idxfile);
tmpglong = g_htonl(offset_old);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
tmpglong = g_htonl(definition_len);
fwrite(&(tmpglong),sizeof(guint32),1,idxfile);
}
fclose(idxfile);
fclose(dicfile);
gchar *str = g_strdup_printf("%s wordcount: %d\n", basefilename, array->len);
print_info(str);
g_free(str);
#ifndef _WIN32
gchar command[256];
sprintf(command, "dictzip %s", dicfilename);
system(command);
#endif
g_stat(idxfilename, &stats);
fprintf(ifofile, "StarDict's dict ifo file\nversion=2.4.2\nwordcount=%d\nidxfilesize=%ld\nbookname=%s\nsametypesequence=m\n", array->len, stats.st_size, basefilename);
fclose(ifofile);
g_free(buffer);
g_array_free(array,TRUE);
g_free(basefilename);
g_free(dirname);
}
static GArray *
parse_mode_combination_string_list (const gchar *modes_str,
GError **error)
{
GArray *supported_mode_combinations;
gchar **mode_combinations;
MMModemMode all = MM_MODEM_MODE_NONE;
gboolean has_all = FALSE;
guint i;
mode_combinations = g_strsplit (modes_str, ",", -1);
supported_mode_combinations = g_array_sized_new (FALSE,
FALSE,
sizeof (MMHuaweiSyscfgexCombination),
g_strv_length (mode_combinations));
g_array_set_clear_func (supported_mode_combinations,
(GDestroyNotify)huawei_syscfgex_combination_free);
for (i = 0; mode_combinations[i]; i++) {
MMHuaweiSyscfgexCombination combination;
mode_combinations[i] = mm_strip_quotes (mode_combinations[i]);
if (!parse_mode_combination_string (mode_combinations[i],
&combination.allowed,
&combination.preferred))
continue;
if (combination.allowed != MM_MODEM_MODE_ANY) {
combination.mode_str = g_strdup (mode_combinations[i]);
g_array_append_val (supported_mode_combinations, combination);
all |= combination.allowed;
} else {
/* don't add the all_combination here, we may have more
* combinations in the loop afterwards */
has_all = TRUE;
}
}
g_strfreev (mode_combinations);
/* Add here the all_combination */
if (has_all) {
MMHuaweiSyscfgexCombination combination;
combination.allowed = all;
combination.preferred = MM_MODEM_MODE_NONE;
combination.mode_str = g_strdup ("00");
g_array_append_val (supported_mode_combinations, combination);
}
/* If we didn't build a valid array of combinations, return an error */
if (supported_mode_combinations->len == 0) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Cannot parse list of allowed mode combinations: '%s'",
modes_str);
g_array_unref (supported_mode_combinations);
return NULL;
}
return supported_mode_combinations;
}
void
load_file_position (const vfs_path_t * filename_vpath, long *line, long *column, off_t * offset,
GArray ** bookmarks)
{
char *fn;
FILE *f;
char buf[MC_MAXPATHLEN + 100];
const size_t len = vfs_path_len (filename_vpath);
char *filename;
/* defaults */
*line = 1;
*column = 0;
*offset = 0;
/* open file with positions */
fn = mc_config_get_full_path (MC_FILEPOS_FILE);
f = fopen (fn, "r");
g_free (fn);
if (f == NULL)
return;
/* prepare array for serialized bookmarks */
if (bookmarks != NULL)
*bookmarks = g_array_sized_new (FALSE, FALSE, sizeof (size_t), MAX_SAVED_BOOKMARKS);
filename = vfs_path_to_str (filename_vpath);
while (fgets (buf, sizeof (buf), f) != NULL)
{
const char *p;
gchar **pos_tokens;
/* check if the filename matches the beginning of string */
if (strncmp (buf, filename, len) != 0)
continue;
/* followed by single space */
if (buf[len] != ' ')
continue;
/* and string without spaces */
p = &buf[len + 1];
if (strchr (p, ' ') != NULL)
continue;
pos_tokens = g_strsplit (p, ";", 3 + MAX_SAVED_BOOKMARKS);
if (pos_tokens[0] == NULL)
{
*line = 1;
*column = 0;
*offset = 0;
}
else
{
*line = strtol (pos_tokens[0], NULL, 10);
if (pos_tokens[1] == NULL)
{
*column = 0;
*offset = 0;
}
else
{
*column = strtol (pos_tokens[1], NULL, 10);
if (pos_tokens[2] == NULL)
*offset = 0;
else if (bookmarks != NULL)
{
size_t i;
*offset = (off_t) g_ascii_strtoll (pos_tokens[2], NULL, 10);
for (i = 0; i < MAX_SAVED_BOOKMARKS && pos_tokens[3 + i] != NULL; i++)
{
size_t val;
val = strtoul (pos_tokens[3 + i], NULL, 10);
g_array_append_val (*bookmarks, val);
}
}
}
}
g_strfreev (pos_tokens);
}
g_free (filename);
fclose (f);
}
static GArray *
parse_syscfg_modes (const gchar *modes_str,
const gchar *acqorder_str,
GError **error)
{
GArray *out;
gchar **split;
guint i;
gint min_acqorder = 0;
gint max_acqorder = 0;
/* Start parsing acquisition order */
if (!sscanf (acqorder_str, "%d-%d", &min_acqorder, &max_acqorder))
mm_dbg ("Error parsing ^SYSCFG acquisition order range (%s)", acqorder_str);
/* Just in case, we default to supporting only auto */
if (max_acqorder < min_acqorder) {
min_acqorder = 0;
max_acqorder = 0;
}
/* Now parse modes */
split = g_strsplit (modes_str, ",", -1);
out = g_array_sized_new (FALSE,
FALSE,
sizeof (MMHuaweiSyscfgCombination),
g_strv_length (split));
for (i = 0; split[i]; i++) {
guint val;
guint allowed = MM_MODEM_MODE_NONE;
GError *inner_error = NULL;
MMHuaweiSyscfgCombination combination;
if (!mm_get_uint_from_str (mm_strip_quotes (split[i]), &val)) {
mm_dbg ("Error parsing ^SYSCFG mode value: %s", split[i]);
continue;
}
if (!mode_from_syscfg (val, &allowed, &inner_error)) {
if (inner_error) {
mm_dbg ("Unhandled ^SYSCFG: %s", inner_error->message);
g_error_free (inner_error);
}
continue;
}
switch (allowed) {
case MM_MODEM_MODE_2G:
case MM_MODEM_MODE_3G:
/* single mode */
combination.allowed = allowed;
combination.preferred = MM_MODEM_MODE_NONE;
combination.mode = val;
combination.acqorder = 0;
g_array_append_val (out, combination);
break;
case (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G):
/* 2G and 3G; auto */
combination.allowed = allowed;
combination.mode = val;
if (min_acqorder == 0) {
combination.preferred = MM_MODEM_MODE_NONE;
combination.acqorder = 0;
g_array_append_val (out, combination);
}
/* 2G and 3G; 2G preferred */
if (min_acqorder <= 1 && max_acqorder >= 1) {
combination.preferred = MM_MODEM_MODE_2G;
combination.acqorder = 1;
g_array_append_val (out, combination);
}
/* 2G and 3G; 3G preferred */
if (min_acqorder <= 2 && max_acqorder >= 2) {
combination.preferred = MM_MODEM_MODE_3G;
combination.acqorder = 2;
g_array_append_val (out, combination);
}
break;
default:
g_assert_not_reached ();
}
}
g_strfreev (split);
/* If we didn't build a valid array of combinations, return an error */
if (out->len == 0) {
g_set_error (error,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Cannot parse list of allowed mode combinations: '%s,%s'",
modes_str,
acqorder_str);
g_array_unref (out);
return NULL;
}
return out;
}
FullTree* qsearch_make_fulltree(QSearchTree *clt, const gsl_matrix *dm) {
int i,j;
int node_count = clt->total_node_count;
int leaf_count = (node_count + 2)/2;
FullTree *tree = malloc(sizeof(FullTree));
tree->node_count = node_count;
tree->data = malloc(sizeof(Misc));
((Misc *)tree->data)->nodes = malloc(sizeof(FullNode) * node_count);
((Misc *)tree->data)->tmpA = g_array_sized_new(FALSE, FALSE, sizeof(guint32), node_count);
((Misc *)tree->data)->tmpB = g_array_sized_new(FALSE, FALSE, sizeof(guint32), node_count);
FullNode *map = get_nodes(tree);
GArray *todo = g_array_sized_new(FALSE, FALSE, sizeof(guint32), node_count - leaf_count);
g_array_set_size(todo, node_count-leaf_count);
for (i = 0; i < node_count; ++i) {
FullNode *node = (map + i);
for (j = 0; j < 3; ++j) {
map[i].connections[j] = -1;
map[i].leaf_count[j] = 0;
map[i].dist[j] = 0;
}
guint8 *node_branch = malloc(sizeof(guint8) * node_count);
node->node_branch = node_branch;
if (i < leaf_count) {
for (j=0; j < node_count; ++j) node_branch[j] = 0;
node->leaf_count[0] = leaf_count - 1;
} else {
for (j = 0; j < node_count; ++j) node_branch[j] = -1;
g_array_index(todo, guint32, i - leaf_count) = i;
}
}
// set connections (construct tree)
for (i = 0; i < node_count; ++i) {
QSearchNeighborList *cln = g_ptr_array_index(clt->n, i);
// add to connected nodes
for (j = 0; j < cln->n->len; ++j) {
int node = g_array_index(cln->n, guint32, j);
// find unfilled branch
int branch = find_branch(map[node].connections, -1);
map[node].connections[branch] = i; // set connection
if (i < leaf_count) {
map[node].leaf_count[branch] = 1; // set leaf
}
map[node].node_branch[i] = branch; // leaf can be found in branch
// set connection back to this node
branch = find_branch(map[i].connections, -1);
map[i].connections[branch] = node;
map[i].node_branch[node] = branch;
}
}
// every iteration, this loop progresses by at least finishing one node. Worst case is n^3 (for 'linear' trees)
while (todo->len > 0) {
for (i = 0; i < todo->len; ++i) {
int this_node = g_array_index(todo, guint32, i);
for (j = 0; j < 3; ++j) {
int connected_node = map[this_node].connections[j];
int branch = find_branch(map[connected_node].connections, this_node);
if (map[connected_node].leaf_count[branch] == 0) {
int first = (3 + j-1) % 3;
int second = (j + 1) % 3;
if (map[this_node].leaf_count[first] != 0 && map[this_node].leaf_count[second] != 0) {
map[connected_node].leaf_count[branch] = map[this_node].leaf_count[first] + map[this_node].leaf_count[second];
// set the node_branch information
int k;
for (k = 0; k < node_count; ++k) {
// node present in one of the two branches pointing away from this
int node_present = k==this_node || map[this_node].node_branch[k] == first || map[this_node].node_branch[k] == second;
if (node_present) map[connected_node].node_branch[k] = branch;
}
}
}
}
}
for (i = 0; i < todo->len; ++i) {
int this_node = g_array_index(todo, guint32, i);
// we are done when all entries are set for this node, AND there are no pending assignments to neighbours
// are all entries set for this node?
for (j = 0; j < 3; ++j) {
if (map[this_node].leaf_count[j] == 0) {
break;
}
}
// are there pending assignments? (we could do the assignments here, but that would duplicate code)
int done = 1;
for (j = 0; j < 3; ++j) {
if (this_node < leaf_count) continue;
int connected_node = map[this_node].connections[j];
// find connection
int branch = find_branch(map[connected_node].connections, this_node);
if (map[connected_node].leaf_count[branch] == 0) {
done = 0;
break;
}
}
if (done) {
//printf("Removing node %d, counts %d %d %d\n", i, map[this_node].leaf_count[0], map[this_node].leaf_count[1], map[this_node].leaf_count[2]);
g_array_remove_index_fast(todo, i);
--i;
}
}
}
g_array_free(todo, TRUE);
int k;
// now fill in the distances
for (i=leaf_count; i < node_count; ++i) {
for (j = 0; j < leaf_count; ++j) {
for (k = j+1; k < leaf_count; ++k) {
int b1 = map[i].node_branch[j];
int b2 = map[i].node_branch[k];
if (b1 == b2) continue;
int b3 = 3 - b1 - b2;
map[i].dist[b3] += gsl_matrix_get(dm, j, k);
}
}
}
set_score(tree);
return tree;
}
