static int spawn_dvips (char *texsrc)
{
GError *error = NULL;
gchar *sout = NULL;
gchar *argv[5];
char outfile[MAXLEN];
int ok, status;
int ret = 0;
sprintf(outfile, "%s.ps", texsrc);
argv[0] = "dvips";
argv[1] = "-o";
argv[2] = outfile;
argv[3] = texsrc;
argv[4] = NULL;
ok = g_spawn_sync(gretl_dotdir(),
argv,
NULL, /* envp */
G_SPAWN_SEARCH_PATH |
G_SPAWN_STDERR_TO_DEV_NULL,
NULL, /* child_setup */
NULL, /* user_data */
&sout, /* standard output */
NULL, /* standard error */
&status, /* exit status */
&error);
if (!ok) {
errbox(error->message);
g_error_free(error);
ret = LATEX_EXEC_FAILED;
} else if (status != 0) {
gchar *errmsg;
errmsg = g_strdup_printf("%s\n%s",
_("Failed to process TeX file"),
sout);
errbox(errmsg);
g_free(errmsg);
ret = 1;
}
if (sout != NULL) g_free(sout);
return ret;
}
gchar *my_filename_to_utf8 (const char *fname)
{
GError *err = NULL;
gchar *ret = NULL;
if (g_utf8_validate(fname, -1, NULL)) {
ret = g_strdup(fname);
} else {
/* On Windows, with GTK >= 2.6, the GLib filename
encoding is UTF-8; however, filenames coming from
a native Windows source will be in the
locale charset
*/
gsize bytes;
#ifdef G_OS_WIN32
ret = g_locale_to_utf8(fname, -1, NULL, &bytes, &err);
#else
ret = g_filename_to_utf8(fname, -1, NULL, &bytes, &err);
#endif
}
if (err) {
errbox(err->message);
g_error_free(err);
}
return ret;
}
static void gpage_errmsg (char *msg, int gui)
{
if (gui) {
errbox(msg);
} else {
gretl_errmsg_set(msg);
}
}
int emf_to_clipboard (char *emfname)
{
HWND mainw;
HENHMETAFILE hemf, hemfclip;
HANDLE htest;
mainw = GDK_WINDOW_HWND(mdata->main->window);
if (mainw == NULL) {
errbox("Got NULL HWND");
return 1;
}
if (!OpenClipboard(mainw)) {
errbox(_("Cannot open the clipboard"));
return 1;
}
EmptyClipboard();
hemf = GetEnhMetaFile(emfname);
if (hemf == NULL) {
errbox("Couldn't get handle to graphic metafile");
return 1;
}
hemfclip = CopyEnhMetaFile(hemf, NULL);
if (hemfclip == NULL) {
errbox("Couldn't copy graphic metafile");
return 1;
}
htest = SetClipboardData(CF_ENHMETAFILE, hemfclip);
if (htest == NULL) {
errbox("Failed to put data on clipboard");
return 1;
}
CloseClipboard();
DeleteEnhMetaFile(hemf);
return 0;
}
static void pasteboard_set (int fmt)
{
FILE *fp = popen("/usr/bin/pbcopy", "w");
if (fp == NULL) {
errbox("Couldn't open pbcopy");
} else {
fputs(clipboard_buf, fp);
pclose(fp);
}
}
static int fnamencmp (const char *f1, const char *f2, int n)
{
gchar *u1 = NULL, *u2 = NULL;
GError *err = NULL;
gsize bytes;
int ret = 0;
if (g_utf8_validate(f1, -1, NULL)) {
u1 = g_strdup(f1);
} else {
u1 = g_locale_to_utf8(f1, -1, NULL, &bytes, &err);
}
if (err == NULL) {
if (g_utf8_validate(f2, -1, NULL)) {
u2 = g_strdup(f2);
} else {
u2 = g_locale_to_utf8(f2, -1, NULL, &bytes, &err);
}
}
if (err != NULL) {
errbox(err->message);
g_error_free(err);
} else {
gchar *c1 = g_utf8_casefold(u1, -1);
gchar *c2 = g_utf8_casefold(u2, -1);
trim_slash(c1);
trim_slash(c2);
if (n > 0) {
ret = strncmp(c1, c2, n);
} else {
ret = strcmp(c1, c2);
}
g_free(c1);
g_free(c2);
}
g_free(u1);
g_free(u2);
return ret;
}
static gchar *real_my_locale_to_utf8 (const gchar *src,
int starting)
{
static int errcount;
const gchar *charset = NULL;
gsize bytes;
GError *err = NULL;
gchar *ret;
if (g_get_charset(&charset)) {
/* in a UTF-8 locale */
if (starting) {
errcount = 0;
ret = g_convert(src, -1, "UTF-8", "ISO-8859-15",
NULL, &bytes, &err);
} else if (errcount == 0) {
ret = g_convert(src, -1, "UTF-8", "ISO-8859-15",
NULL, &bytes, &err);
} else {
ret = g_convert(src, -1, "UTF-8", "ISO-8859-15",
NULL, &bytes, NULL);
}
} else {
if (starting) {
errcount = 0;
ret = g_locale_to_utf8(src, -1, NULL, &bytes, &err);
} else if (errcount == 0) {
ret = g_locale_to_utf8(src, -1, NULL, &bytes, &err);
} else {
ret = g_locale_to_utf8(src, -1, NULL, &bytes, NULL);
}
}
if (err) {
errbox(err->message);
g_error_free(err);
errcount++;
}
return ret;
}
gchar *gp_locale_from_utf8 (const gchar *src)
{
gsize read, wrote;
GError *err = NULL;
gchar *ret;
if (gretl_is_ascii(src)) {
return NULL;
}
/* let glib figure out what the target locale is */
ret = g_locale_from_utf8(src, -1, &read, &wrote, &err);
if (err) {
errbox(err->message);
g_error_free(err);
}
return ret;
}
static gchar *gp_locale_to_utf8 (const gchar *src, int starting)
{
static int errcount;
static const char *from;
gsize read, wrote;
GError *err = NULL;
gchar *ret;
if (from == NULL) {
if (iso_latin_version() == 2) {
#ifdef G_OS_WIN32
from = "CP1250";
#else
from = "ISO-8859-2";
#endif
} else {
from = "ISO-8859-1";
}
}
if (starting) {
errcount = 0;
ret = g_convert(src, -1, "UTF-8", from,
&read, &wrote, &err);
} else if (errcount == 0) {
ret = g_convert(src, -1, "UTF-8", from,
&read, &wrote, &err);
} else {
ret = g_convert(src, -1, "UTF-8", from,
&read, &wrote, NULL);
}
if (err != NULL) {
errbox(err->message);
g_error_free(err);
errcount++;
}
return ret;
}
gchar *my_locale_from_utf8 (const gchar *src)
{
const gchar *cset;
gsize bytes;
GError *err = NULL;
gchar *ret = NULL;
if (g_get_charset(&cset)) {
/* g_get_charset returns TRUE if the returned
charset is UTF-8 */
return g_strdup(src);
}
ret = g_locale_from_utf8(src, -1, NULL, &bytes, &err);
if (err) {
errbox(err->message);
g_error_free(err);
}
return ret;
}
static void mle_gmm_iters_dialog (GtkWidget *w, dialog_t *d)
{
int maxit, lmem = 0, optim = BFGS_MAX;
double tol;
int resp;
BFGS_defaults(&maxit, &tol, d->ci);
lmem = libset_get_int(LBFGS_MEM);
if (maxit <= 0) {
maxit = 1000;
}
if ((d->opt & OPT_L) || libset_get_bool(USE_LBFGS)) {
optim = LBFGS_MAX;
}
resp = iter_control_dialog(&optim, &maxit, &tol, &lmem,
d->dialog);
if (!canceled(resp)) {
int err;
err = libset_set_int(BFGS_MAXITER, maxit);
err += libset_set_double(BFGS_TOLER, tol);
if (optim == LBFGS_MAX) {
d->opt |= OPT_L;
libset_set_int(LBFGS_MEM, lmem);
} else {
d->opt &= ~OPT_L;
}
if (err) {
errbox("Error setting values");
}
}
}
void newdata_callback (void)
{
int resp, n = 50;
if (dataset_locked()) {
return;
}
resp = spin_dialog(_("gretl: create data set"), NULL, &n,
_("Number of observations:"),
2, 1000000, 0, NULL);
if (resp < 0) {
/* canceled */
return;
}
if (open_nulldata(dataset, data_status, n, OPT_NONE, NULL)) {
errbox(_("Failed to create empty data set"));
return;
}
new_data_structure_dialog();
}
gchar *my_filename_from_utf8 (char *fname)
{
const gchar *cset;
GError *err = NULL;
gsize bytes;
gchar *tmp = NULL;
if (seven_bit_string((unsigned char *) fname)) {
return fname;
}
if (g_get_charset(&cset)) {
/* locale uses UTF-8, OK */
return fname;
}
#ifdef G_OS_WIN32
/* don't use g_filename_from_utf8 because on Windows
GLib uses UTF-8 for filenames and no conversion
will take place */
tmp = g_locale_from_utf8(fname, -1, NULL, &bytes, &err);
#else
tmp = g_filename_from_utf8(fname, -1, NULL, &bytes, &err);
#endif
if (err) {
errbox(err->message);
g_error_free(err);
} else {
strcpy(fname, tmp);
}
g_free(tmp);
return fname;
}
int prn_to_clipboard (PRN *prn, int fmt)
{
char *buf = gretl_print_steal_buffer(prn);
char *modbuf = NULL;
int rtf_format = 0;
int err = 0;
if (buf == NULL || *buf == '\0') {
errbox(_("Copy buffer was empty"));
return 0;
}
if (!OpenClipboard(NULL)) {
errbox(_("Cannot open the clipboard"));
return 1;
}
if (fmt == GRETL_FORMAT_RTF || fmt == GRETL_FORMAT_RTF_TXT) {
rtf_format = 1;
}
EmptyClipboard();
err = maybe_post_process_buffer(buf, fmt, W_COPY, &modbuf);
if (!err) {
HGLOBAL winclip;
LPTSTR ptr;
unsigned clip_format;
gunichar2 *ubuf = NULL;
char *winbuf;
glong wrote = 0;
size_t sz;
winbuf = modbuf != NULL ? modbuf : buf;
if (!rtf_format && !gretl_is_ascii(winbuf)) {
/* for Windows clipboard, recode UTF-8 to UTF-16 */
ubuf = g_utf8_to_utf16(winbuf, -1, NULL, &wrote, NULL);
}
if (ubuf != NULL) {
sz = (wrote + 1) * sizeof(gunichar2);
} else {
sz = strlen(winbuf) + 1;
}
winclip = GlobalAlloc(GMEM_MOVEABLE, sz);
ptr = GlobalLock(winclip);
if (ubuf != NULL) {
memcpy(ptr, ubuf, sz);
} else {
memcpy(ptr, winbuf, sz);
}
GlobalUnlock(winclip);
if (ubuf != NULL) {
clip_format = CF_UNICODETEXT;
} else if (rtf_format) {
clip_format = RegisterClipboardFormat("Rich Text Format");
} else if (fmt == GRETL_FORMAT_CSV) {
clip_format = RegisterClipboardFormat("CSV");
} else {
clip_format = CF_TEXT;
}
SetClipboardData(clip_format, winclip);
if (ubuf != NULL) {
g_free(ubuf);
}
}
CloseClipboard();
free(buf);
free(modbuf);
return err;
}
void selector_callback (GtkAction *action, gpointer data)
{
const gchar *s = gtk_action_get_name(action);
windata_t *vwin = (windata_t *) data;
int ci;
ci = selector_callback_code(s);
if (ci == COINT || ci == COINT2) {
selection_dialog(ci, _("gretl: cointegration test"), do_coint);
} else if (ci == VAR || ci == VECM) {
selection_dialog(ci, (ci == VAR)? _("gretl: VAR") : _("gretl: VECM"),
do_vector_model);
} else if (ci == VLAGSEL) {
selection_dialog(ci, _("gretl: VAR lag selection"), do_vector_model);
} else if (ci == GR_XY || ci == GR_IMP || ci == GR_DUMMY ||
ci == SCATTERS || ci == GR_3D || ci == GR_XYZ ||
ci == GR_FBOX) {
int (*selfunc)() = NULL;
switch (ci) {
case GR_XY:
case GR_IMP:
selfunc = do_graph_from_selector;
break;
case GR_3D:
selfunc = do_splot_from_selector;
break;
case GR_DUMMY:
selfunc = do_dummy_graph;
break;
case GR_XYZ:
selfunc = do_xyz_graph;
break;
case SCATTERS:
selfunc = do_scatters;
break;
case GR_FBOX:
selfunc = do_factorized_boxplot;
break;
default:
return;
}
selection_dialog(ci, _("gretl: define graph"), selfunc);
} else if (ci == ADD || ci == OMIT) {
simple_selection_for_viewer(ci, _("gretl: model tests"),
do_add_omit, vwin);
} else if (ci == VAROMIT) {
simple_selection_for_viewer(ci, _("gretl: model tests"),
do_VAR_omit, vwin);
} else if (ci == COEFFSUM) {
simple_selection_for_viewer(ci, _("gretl: model tests"),
do_coeff_sum, vwin);
} else if (ci == ELLIPSE) {
simple_selection_for_viewer(ci, _("gretl: model tests"),
do_confidence_region, vwin);
} else if (ci == GR_PLOT) {
simple_selection(ci, _("gretl: define graph"), do_graph_from_selector,
NULL);
} else if (ci == TSPLOTS) {
simple_selection(ci, _("gretl: define graph"), do_scatters, NULL);
} else if (ci == SPEARMAN) {
char title[64];
strcpy(title, "gretl: ");
strcat(title, _("rank correlation"));
simple_selection(ci, title, do_rankcorr, NULL);
} else if (ci == LOESS || ci == NADARWAT) {
char title[64];
strcpy(title, "gretl: ");
strcat(title, (ci == LOESS)? _("Loess") : _("Nadaraya-Watson"));
selection_dialog(ci, title, do_nonparam_model);
} else {
errbox("selector_callback: code was not recognized");
}
}
void dummy_call (void)
{
errbox(_("Sorry, this item not yet implemented!"));
}
static int process_panel_vars (DATASET *dwinfo, dw_opts *opts)
{
int n = dataset->n;
double *uid = NULL;
double *tid = NULL;
int uv, tv;
int nunits = 0;
int nperiods = 0;
int err = 0;
/* FIXME sub-sampled dataset? */
err = translate_panel_vars(opts, &uv, &tv);
if (err) {
return err;
}
if (uv == tv) {
/* "can't happen" */
errbox(_("The unit and time index variables must be distinct"));
return E_DATA;
}
uid = copyvec(dataset->Z[uv], n);
tid = copyvec(dataset->Z[tv], n);
if (uid == NULL || tid == NULL) {
nomem();
err = E_ALLOC;
}
if (!err) {
qsort(uid, n, sizeof *uid, gretl_compare_doubles);
nunits = count_distinct_values(uid, n);
qsort(tid, n, sizeof *tid, gretl_compare_doubles);
nperiods = count_distinct_values(tid, n);
/* heuristic: if a variable represents either the panel
unit or period, it must have at least two distinct
values, and must have fewer values than the total
number of observations. Further, the product of
the number of distinct values for the unit and time
variables must be at least equal to the number of
observations, otherwise there will be duplicated
rows (i.e. more than one row claiming to represent
unit i, period t, for some i, t).
Note that the product (nunits * nperiods) may be
_greater_ than total n: this may mean that we have
some implicit missing observations.
*/
if (nunits == 1 || nperiods == 1 ||
nunits == n || nperiods == n ||
nunits * nperiods < n) {
errbox(_("The selected index variables do not represent "
"a panel structure"));
err = E_DATA;
} else {
dwinfo->n = nunits;
dwinfo->pd = nperiods;
}
}
free(uid);
free(tid);
return err;
}
