/* start file-based monitor */
void start(const char *name, const char *output)
{
char *env_name;
if (!output)
return;
env_name = NULL;
G_asprintf(&env_name, "MONITOR_%s_MAPFILE", name);
G_setenv(env_name, output);
}
/* start wxGUI display monitor */
void start_wx(const char *name, const char *tempfile,
const char *env_value, const char *cmd_value,
const char *width, const char *height)
{
char progname[GPATH_MAX];
char *env_name, *map_value;
env_name = NULL;
G_asprintf(&env_name, "MONITOR_%s_MAPFILE", name);
G_asprintf(&map_value, "%s.ppm", tempfile);
G_setenv(env_name, map_value);
/* close(creat(map_value, 0666)); */
G_debug(3, " mapfile = %s", map_value);
sprintf(progname, "%s/etc/gui/wxpython/gui_modules/mapdisp.py", G_gisbase());
G_spawn_ex(getenv("GRASS_PYTHON"), progname, progname,
name, map_value, cmd_value, env_value, width ? width : "", height ? height : "", SF_BACKGROUND, NULL);
}
int main(int argc, char *argv[])
{
struct Option *type, *rc_file;
struct Flag *update, *nolaunch;
struct GModule *module;
const char *gui_type_env;
char progname[GPATH_MAX];
char *desc;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("gui"));
G_add_keyword(_("user interface"));
module->label =
_("Launches a GRASS graphical user interface (GUI) session.");
module->description = _("And updates default user interface settings.");
type = G_define_option();
type->key = "ui";
type->type = TYPE_STRING;
type->label = _("User interface");
type->description = _("Default value: GRASS_GUI if defined otherwise wxpython");
desc = NULL;
G_asprintf(&desc,
"wxpython;%s;text;%s",
_("wxPython based GUI (wxGUI)"),
_("command line interface only"));
type->descriptions = desc;
type->options = "wxpython,text";
type->guisection = _("Type");
rc_file = G_define_standard_option(G_OPT_F_INPUT);
rc_file->key = "workspace";
rc_file->required = NO;
rc_file->key_desc = "name.gxw";
rc_file->description = _("Name of workspace file to load on start-up (valid only for wxGUI)");
update = G_define_flag();
update->key = 'd';
update->description = _("Update default user interface settings");
update->guisection = _("Default");
nolaunch = G_define_flag();
nolaunch->key = 'n';
nolaunch->description =
_("Do not launch GUI after updating the default user interface settings");
nolaunch->guisection = _("Default");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (type->answer && strcmp(type->answer, "text") == 0 &&
!nolaunch->answer)
nolaunch->answer = TRUE;
if (nolaunch->answer && !update->answer)
update->answer = TRUE;
gui_type_env = G__getenv("GUI");
if (!type->answer) {
if (gui_type_env && strcmp(gui_type_env, "text")) {
type->answer = G_store(gui_type_env);
}
else {
type->answer = "wxpython";
}
}
if (((gui_type_env && update->answer) &&
strcmp(gui_type_env, type->answer) != 0) || !gui_type_env) {
G_setenv("GUI", type->answer);
G_message(_("<%s> is now the default GUI"), type->answer);
}
else {
if(update->answer)
if(gui_type_env) {
G_debug(1, "No change: old gui_type_env=[%s], new type->ans=[%s]",
gui_type_env, type->answer);
}
}
if(nolaunch->answer)
exit(EXIT_SUCCESS);
G_message(_("Launching <%s> GUI in the background, please wait..."), type->answer);
if (strcmp(type->answer, "wxpython") == 0) {
sprintf(progname, "%s/gui/wxpython/wxgui.py", G_gisbase());
if (rc_file->answer) {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
"--workspace", rc_file->answer, SF_BACKGROUND, NULL);
}
else {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
SF_BACKGROUND, NULL);
}
}
/* stop the impatient from starting it again
before the splash screen comes up */
G_sleep(3);
exit(EXIT_SUCCESS);
}
int GRASS_LIB_EXPORT QgsGrassGisLib::G__gisinit( const char * version, const char * programName )
{
Q_UNUSED( version );
// We use this function also to init our fake lib
QgsDebugMsg( QString( "version = %1 programName = %2" ).arg( version ).arg( programName ) );
// Init providers path
int argc = 1;
char **argv = new char*[1];
argv[0] = qstrdup( programName );
// unfortunately it seems impossible to get QGIS prefix
// QCoreApplication::applicationDirPath() returns $GISBASE/lib on Linux
#if 0
QDir dir( QCoreApplication::applicationDirPath() );
dir.cdUp();
QString prefixPath = dir.absolutePath();
#endif
//QCoreApplication app( argc, argv ); // to init paths
QgsApplication app( argc, argv, false ); // to init paths
// TODO: WCS (network) fails with: "QTimer can only be used with threads started
// with QThread" because QCoreApplication::exec() was not called, but
// QCoreApplication::exec() goes to loop. We need to start QThread somehow.
// QGIS_PREFIX_PATH should be loaded by QgsApplication
//QString prefixPath = getenv( "QGIS_PREFIX_PATH" );
//if ( prefixPath.isEmpty() )
//{
// fatal( "Cannot get QGIS_PREFIX_PATH" );
//}
//QgsApplication::setPrefixPath( prefixPath, true );
QgsDebugMsg( "Plugin path: " + QgsApplication::pluginPath() );
QgsProviderRegistry::instance( QgsApplication::pluginPath() );
QgsDebugMsg( "qgisSettingsDirPath = " + app.qgisSettingsDirPath() );
G_set_error_routine( &errorRoutine );
G_set_gisrc_mode( G_GISRC_MODE_MEMORY );
G_setenv( "OVERWRITE", "1" ); // avoid checking if map exists
G_suppress_masking();
#if GRASS_VERSION_MAJOR<6 || (GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR <= 4)
G__init_null_patterns();
#endif
// Read projection if set
//mCrs.createFromOgcWmsCrs( "EPSG:900913" );
QString crsStr = getenv( "QGIS_GRASS_CRS" );
QgsDebugMsg( "Setting CRS to " + crsStr );
if ( !crsStr.isEmpty() )
{
if ( !mCrs.createFromProj4( crsStr ) )
{
fatal( "Cannot create CRS from QGIS_GRASS_CRS: " + crsStr );
}
//TODO: createFromProj4 used to save to the user database any new CRS
// this behavior was changed in order to separate creation and saving.
// Not sure if it necessary to save it here, should be checked by someone
// familiar with the code (should also give a more descriptive name to the generated CRS)
if ( mCrs.srsid() == 0 )
{
QString myName = QString( " * %1 (%2)" )
.arg( QObject::tr( "Generated CRS", "A CRS automatically generated from layer info get this prefix for description" ) )
.arg( mCrs.toProj4() );
mCrs.saveAsUserCRS( myName );
}
}
mDistanceArea.setSourceCrs( mCrs.srsid() );
// Read region fron environment variable
// QGIS_GRASS_REGION=west,south,east,north,cols,rows
#if 0
QString regionStr = getenv( "QGIS_GRASS_REGION" );
QStringList regionList = regionStr.split( "," );
if ( regionList.size() != 6 )
{
fatal( "Cannot read region from QGIS_GRASS_REGION environment variable" );
}
double xMin, yMin, xMax, yMax;
int cols, rows;
bool xMinOk, yMinOk, xMaxOk, yMaxOk, colsOk, rowsOk;
xMin = regionList.value( 0 ).toDouble( &xMinOk );
yMin = regionList.value( 1 ).toDouble( &yMinOk );
xMax = regionList.value( 2 ).toDouble( &xMaxOk );
yMax = regionList.value( 3 ).toDouble( &yMaxOk );
cols = regionList.value( 4 ).toInt( &colsOk );
rows = regionList.value( 5 ).toInt( &rowsOk );
if ( !xMinOk || !yMinOk || !xMaxOk || !yMaxOk || !colsOk || !rowsOk )
{
fatal( "Cannot parse QGIS_GRASS_REGION" );
}
struct Cell_head window;
window.west = xMin;
window.south = yMin;
window.east = xMax;
window.north = yMax;
window.rows = rows;
window.cols = cols;
char* err = G_adjust_Cell_head( &window, 1, 1 );
if ( err )
{
fatal( QString( err ) );
}
G_set_window( &window );
#endif
QString regionStr = getenv( "GRASS_REGION" );
if ( regionStr.isEmpty() )
{
fatal( "GRASS_REGION environment variable not set" );
}
QgsDebugMsg( "Getting region via true lib from GRASS_REGION: " + regionStr );
// GRASS true lib reads GRASS_REGION environment variable
G_get_window( &mWindow );
mExtent = QgsRectangle( mWindow.west, mWindow.south, mWindow.east, mWindow.north );
mRows = mWindow.rows;
mColumns = mWindow.cols;
mXRes = mExtent.width() / mColumns;
mYRes = mExtent.height() / mColumns;
QgsDebugMsg( "End" );
return 0;
}
int start_mon(const char *name, const char *output, int select,
const char *width, const char *height, const char *bgcolor,
int truecolor)
{
const char *curr_mon;
char *env_name, *env_value, *cmd_value;
char *tempfile, buf[1024];
int env_fd;
curr_mon = G__getenv("MONITOR");
if (curr_mon && strcmp(curr_mon, name) == 0 && check_mon(curr_mon))
G_fatal_error(_("Monitor <%s> already running"), name);
tempfile = G_tempfile();
env_name = env_value = NULL;
G_asprintf(&env_name, "MONITOR_%s_ENVFILE", name);
G_asprintf(&env_value, "%s.env", tempfile);
G_setenv(env_name, env_value);
env_fd = creat(env_value, 0666);
if (env_fd < 0)
G_fatal_error(_("Unable to create file '%s'"), env_value);
if (width) {
sprintf(buf, "GRASS_WIDTH=%s\n", width);
write(env_fd, buf, strlen(buf));
}
if (height) {
sprintf(buf, "GRASS_HEIGHT=%s\n", height);
write(env_fd, buf, strlen(buf));
}
if (bgcolor) {
if (strcmp(bgcolor, "none") == 0)
sprintf(buf, "GRASS_TRANSPARENT=TRUE\n");
else
sprintf(buf, "GRASS_BACKGROUNDCOLOR=%s\n", bgcolor);
write(env_fd, buf, strlen(buf));
}
if (truecolor) {
sprintf(buf, "GRASS_TRUECOLOR=TRUE\n");
write(env_fd, buf, strlen(buf));
}
close(env_fd);
cmd_value = NULL;
G_asprintf(&env_name, "MONITOR_%s_CMDFILE", name);
G_asprintf(&cmd_value, "%s.cmd", tempfile);
G_setenv(env_name, cmd_value);
close(creat(cmd_value, 0666));
G_verbose_message(_("Staring monitor <%s> with env file '%s'"), name, env_value);
G_debug(1, "start: name=%s ", name);
G_debug(3, " envfile = %s", env_value);
G_debug(3, " cmdfile = %s", cmd_value);
if (select)
G_setenv("MONITOR", name);
if (strncmp(name, "wx", 2) == 0) /* use G_strncasecmp() instead */
start_wx(name, tempfile, env_value, cmd_value,
width, height);
else
start(name, output);
return 0;
}
int main(int argc, char *argv[])
{
struct Option *type, *rc_file;
struct Flag *update_ui, *fglaunch, *nolaunch;
struct GModule *module;
const char *gui_type_env;
char progname[GPATH_MAX];
char *desc;
G_gisinit(argv[0]);
module = G_define_module();
G_add_keyword(_("general"));
G_add_keyword(_("GUI"));
G_add_keyword(_("user interface"));
module->label =
_("Launches a GRASS graphical user interface (GUI) session.");
module->description = _("Optionally updates default user interface settings.");
type = G_define_option();
type->key = "ui";
type->type = TYPE_STRING;
type->description = _("User interface");
desc = NULL;
G_asprintf(&desc,
"wxpython;%s;text;%s;gtext;%s;",
_("wxPython based GUI (wxGUI)"),
_("command line interface only"),
_("command line interface with GUI startup screen"));
type->descriptions = desc;
type->options = "wxpython,text,gtext";
type->answer = "wxpython";
type->guisection = _("Type");
rc_file = G_define_standard_option(G_OPT_F_INPUT);
rc_file->key = "workspace";
rc_file->required = NO;
rc_file->key_desc = "name.gxw";
rc_file->label = _("Name of workspace file to load on start-up");
rc_file->description = _("This is valid only for wxGUI (wxpython)");
fglaunch = G_define_flag();
fglaunch->key = 'f';
fglaunch->label = _("Start GUI in the foreground");
fglaunch->description = _("By default the GUI starts in the background"
" and control is immediately returned to the caller."
" When GUI runs in foregreound, it blocks the command line");
update_ui = G_define_flag();
update_ui->key = 'd';
update_ui->description = _("Update default user interface settings");
update_ui->guisection = _("Default");
nolaunch = G_define_flag();
nolaunch->key = 'n';
nolaunch->description =
_("Do not launch GUI after updating the default user interface settings");
nolaunch->guisection = _("Default");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
gui_type_env = G_getenv_nofatal("GUI");
G_debug(1, "GUI: %s", gui_type_env ? gui_type_env : "unset");
if (update_ui->answer) {
if (!gui_type_env || strcmp(type->answer, gui_type_env)) {
G_setenv("GUI", type->answer);
G_message(_("<%s> is now the default GUI"), type->answer);
}
}
if(strcmp(type->answer, "wxpython") != 0 || nolaunch->answer) {
if (!update_ui->answer)
G_warning(_("Nothing to do. For setting up <%s> as default UI use -%c flag."),
type->answer, update_ui->key);
exit(EXIT_SUCCESS);
}
sprintf(progname, "%s/gui/wxpython/wxgui.py", G_gisbase());
if (access(progname, F_OK) == -1)
G_fatal_error(_("Your installation doesn't include GUI, exiting."));
if (fglaunch->answer) {
G_message(_("Launching <%s> GUI, please wait..."), type->answer);
if (rc_file->answer) {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
"--workspace", rc_file->answer, NULL);
}
else {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
NULL);
}
}
else {
G_message(_("Launching <%s> GUI in the background, please wait..."), type->answer);
if (rc_file->answer) {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
"--workspace", rc_file->answer, SF_BACKGROUND, NULL);
}
else {
G_spawn_ex(getenv("GRASS_PYTHON"), getenv("GRASS_PYTHON"), progname,
SF_BACKGROUND, NULL);
}
/* stop the impatient from starting it again
before the splash screen comes up */
G_sleep(3);
}
exit(EXIT_SUCCESS);
}
int main(int argc, char *argv[])
{
int ret;
struct GModule *module;
struct Option *gisdbase_opt, *location_opt, *mapset_opt;
struct Flag *f_add, *f_list;
char *gisdbase_old, *location_old, *mapset_old;
char *gisdbase_new, *location_new, *mapset_new;
char *gis_lock;
char *mapset_old_path, *mapset_new_path;
char *lock_prog;
char path[GPATH_MAX];
char *shell, *monitor;
struct MON_CAP *cap;
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("general, settings");
module->label = _("Changes current mapset.");
module->description = _("Optionally create new mapset or list available mapsets in given location.");
mapset_opt = G_define_option();
mapset_opt->key = "mapset";
mapset_opt->type = TYPE_STRING;
mapset_opt->required = NO;
mapset_opt->multiple = NO;
mapset_opt->description = _("Name of mapset where to switch");
mapset_opt->guisection = _("Settings");
location_opt = G_define_option();
location_opt->key = "location";
location_opt->type = TYPE_STRING;
location_opt->required = NO;
location_opt->multiple = NO;
location_opt->description = _("Location name (not location path)");
location_opt->guisection = _("Settings");
gisdbase_opt = G_define_option();
gisdbase_opt->key = "gisdbase";
gisdbase_opt->type = TYPE_STRING;
gisdbase_opt->required = NO;
gisdbase_opt->multiple = NO;
gisdbase_opt->key_desc = "path";
gisdbase_opt->description =
_("GIS data directory (full path to the directory where the new location is)");
gisdbase_opt->guisection = _("Settings");
f_add = G_define_flag();
f_add->key = 'c';
f_add->description = _("Create mapset if it doesn't exist");
f_add->answer = FALSE;
f_add->guisection = _("Create");
f_list = G_define_flag();
f_list->key = 'l';
f_list->description = _("List available mapsets");
f_list->guisection = _("Print");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
if (!mapset_opt->answer && !f_list->answer)
G_fatal_error(_("Either mapset= or -l must be used"));
/* Store original values */
gisdbase_old = G__getenv("GISDBASE");
location_old = G__getenv("LOCATION_NAME");
mapset_old = G__getenv("MAPSET");
G_asprintf(&mapset_old_path, "%s/%s/%s", gisdbase_old, location_old,
mapset_old);
monitor = G__getenv("MONITOR");
/* New values */
if (gisdbase_opt->answer)
gisdbase_new = gisdbase_opt->answer;
else
gisdbase_new = gisdbase_old;
if (location_opt->answer)
location_new = location_opt->answer;
else
location_new = location_old;
if (f_list->answer) {
char **ms;
int nmapsets;
G__setenv("LOCATION_NAME", location_new);
G__setenv("GISDBASE", gisdbase_new);
ms = G_available_mapsets();
for (nmapsets = 0; ms[nmapsets]; nmapsets++) {
if (G__mapset_permissions(ms[nmapsets]) > 0) {
fprintf(stdout, "%s ", ms[nmapsets]);
}
}
fprintf(stdout, "\n");
exit(EXIT_SUCCESS);
}
mapset_new = mapset_opt->answer;
G_asprintf(&mapset_new_path, "%s/%s/%s", gisdbase_new, location_new,
mapset_new);
/* TODO: this should be checked better (repeated '/' etc.) */
if (strcmp(mapset_old_path, mapset_new_path) == 0)
G_fatal_error(_("<%s> is already the current mapset"), mapset_new);
/* Check if the mapset exists and user is owner */
G_debug(2, "check : %s", mapset_new_path);
ret = G__mapset_permissions2(gisdbase_new, location_new, mapset_new);
switch (ret) {
case 0:
G_fatal_error(_("You don't have permission to use this mapset"));
break;
case -1:
if (f_add->answer == TRUE) {
G_debug(2, "Mapset %s doesn't exist, attempting to create it",
mapset_new);
G_make_mapset(gisdbase_new, location_new, mapset_new);
}
else
G_fatal_error(_("The mapset does not exist. Use -c flag to create it."));
break;
default:
break;
}
/* Check if the mapset is in use */
gis_lock = getenv("GIS_LOCK");
if (!gis_lock)
G_fatal_error(_("Unable to read GIS_LOCK environment variable"));
G_asprintf(&lock_prog, "%s/etc/lock", G_gisbase());
sprintf(path, "%s/.gislock", mapset_new_path);
G_debug(2, path);
ret = G_spawn(lock_prog, lock_prog, path, gis_lock, NULL);
G_debug(2, "lock result = %d", ret);
G_free(lock_prog);
/* Warning: the value returned by system() is not that returned by exit() in executed program
* e.g. exit(1) -> 256 (multiplied by 256) */
if (ret != 0)
G_fatal_error(_("%s is currently running GRASS in selected mapset or lock file cannot be checked"),
G_whoami());
/* Erase monitors */
G_message(_("Erasing monitors..."));
while ((cap = R_parse_monitorcap(MON_NEXT, "")) != NULL) {
G__setenv("MONITOR", cap->name);
R__open_quiet();
if (R_open_driver() == 0) {
D_erase(DEFAULT_BG_COLOR);
D_add_to_list("d.erase");
R_close_driver();
R_release_driver();
}
}
if (monitor)
G_setenv("MONITOR", monitor);
/* Clean temporary directory */
sprintf(path, "%s/etc/clean_temp", G_gisbase());
G_verbose_message(_("Cleaning up temporary files..."));
G_spawn(path, "clean_temp", NULL);
/* Reset variables */
G_setenv("GISDBASE", gisdbase_new);
G_setenv("LOCATION_NAME", location_new);
G_setenv("MAPSET", mapset_new);
/* Remove old lock */
sprintf(path, "%s/.gislock", mapset_old_path);
remove(path);
G_free(mapset_old_path);
G_important_message(_("Your shell continues to use the history for the old mapset"));
if ((shell = getenv("SHELL"))) {
if (strstr(shell, "bash")) {
G_important_message(_("You can switch the history by commands:\n"
"history -w; history -r %s/.bash_history; HISTFILE=%s/.bash_history"),
mapset_new_path, mapset_new_path);
}
else if (strstr(shell, "tcsh")) {
G_important_message(_("You can switch the history by commands:\n"
"history -S; history -L %s/.history; setenv histfile=%s/.history"),
mapset_new_path, mapset_new_path);
}
}
G_message(_("Your current mapset is <%s>"), mapset_new);
G_free(mapset_new_path);
return (EXIT_SUCCESS);
}
