void
Init (char *fname)
{
pwr_tInt32 ret;
char dbName[200];
dcli_translate_filename( dbName, fname);
/*create the database if it's not already created*/
if((ret = db_create(&dataBaseP, NULL, 0)) != 0)
{
/*error creating db-handle send the mess to errh, then exit*/
printf("error db_create: %s\n", db_strerror(ret));
printf("** Error when creating db handle, terminating\n");
exit(1);
}
#if (DB_VERSION_MAJOR > 3) && (DB_VERSION_MINOR > 0)
ret = dataBaseP->open(dataBaseP, NULL, dbName, NULL, DATABASETYPE, DB_RDONLY, 0);
#else
ret = dataBaseP->open(dataBaseP, dbName, NULL, DATABASETYPE, DB_RDONLY, 0);
#endif
if(ret != 0)
{
/*error opening/creating db send the mess to errh, then exit*/
printf("error db_open: %s\n", db_strerror(ret));
exit(1);
}
}
int sev_repair::init()
{
sev_dbms_env *env;
pwr_tFileName envname;
sprintf( envname, "$pwrp_db/%s.db", sev_dbms_env::dbName());
dcli_translate_filename( envname, envname);
env = new sev_dbms_env( envname);
env->open( envname);
if ( !env->exists()) {
printf( "** Error: Database environment doesn't exist\n");
exit(0);
}
if ( !env->openDb()) {
printf("Failed to connect to database '%s'", sev_dbms_env::dbName());
exit(0);
}
m_db = new sev_dbms( env);
printf("-- Database opened '%s'\n", sev_dbms_env::dbName());
m_db->get_items( &m_sts);
m_db->get_objectitems(&m_sts);
return 1;
}
static pwr_tStatus OpenDb (
ldh_sMenuCall *ip
)
{
int size;
int sts;
char volume_name[80];
pwr_tFileName filename;
pwr_tCmd cmd;
sts = ldh_ObjidToName ( ip->PointedSession, ip->Pointed.Objid,
ldh_eName_Object, volume_name, sizeof(volume_name), &size);
if ( EVEN(sts)) return sts;
dcli_translate_filename( filename, "$pwr_exe/wb_open_db.sh");
sprintf( cmd,
"%s \"%s\" \"%s\" \"%s\" \"%s\" &",
filename, CoLogin::username(), CoLogin::ucpassword(), volume_name, volume_name);
sts = system( cmd);
if ( sts == -1 || sts == 127) {
printf("-- Error when creating process.\n");
return sts;
}
return 1;
}
GtkWidget *XttMethodToolbarGtk::build()
{
pwr_tFileName fname;
// Toolbar
m_toolbar_w = (GtkWidget *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
for ( int i = 0; i < m_size; i++) {
if ( m_method_mask & (1 << i)) {
char tooltip[200];
strcpy( tooltip, m_data[i].tooltip);
strcat( tooltip, m_tooltip_suffix);
m_button_w[i] = gtk_button_new();
dcli_translate_filename( fname, m_data[i].image);
gtk_container_add( GTK_CONTAINER(m_button_w[i]),
gtk_image_new_from_file( fname));
g_signal_connect( m_button_w[i], "clicked", G_CALLBACK(activate_button), &m_cb[i]);
g_object_set( m_button_w[i], "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( GTK_TOOLBAR(m_toolbar_w), m_button_w[i], CoWowGtk::translate_utf8( tooltip), "");
}
}
return m_toolbar_w;
}
void wb_dbms::copy(wb_export &e, const char *fileName)
{
pwr_tStatus sts;
char l_fileName[512];
dcli_translate_filename(l_fileName, fileName);
if (!m_env) {
m_env = new wb_dbms_env(l_fileName);
m_env->open();
}
createDb();
importVolume(e);
close();
open();
try {
m_env->txn_begin(0, (wb_dbms_txn **)&m_txn);
wb_dbms_info i(this);
i.get(m_txn);
m_vid = i.vid();
m_cid = i.cid();
strcpy(m_volumeName, i.name());
commit(&sts);
}
catch (wb_dbms_error &e) {
m_txn->abort();
printf("exeption: %s\n", e.what().c_str());
}
}
int wb_utl_motif::create_mainwindow( int argc, char **argv)
{
Widget toplevel;
Widget mainwindow;
char uid_filename[200] = "pwr_exe:wb.uid";
char *uid_filename_p = uid_filename;
Arg args[20];
int sts;
MrmInitialize();
sts = dcli_translate_filename( uid_filename, uid_filename);
if ( EVEN(sts))
{
printf( "** pwr_exe is not defined\n");
exit(0);
}
toplevel = XtInitialize ("AutoPrint", "svn", NULL, 0, &argc, argv);
XtSetArg (args[0], XtNallowShellResize, TRUE);
XtSetValues (toplevel, args, 1);
uilutil_fetch( &uid_filename_p, 1, 0, 0,
toplevel, (char*) "mainwindow", (char*) "svn_svn", 0, 0,
&mainwindow, NULL );
XtSetArg (args[0], XmNheight, 500);
XtSetValues (mainwindow, args, 1);
XtManageChild(mainwindow);
widget = mainwindow;
return FOE__SUCCESS;
}
void PnViewerNav::vendorid_to_str(
unsigned int vendorid, char* vendorid_str, int size)
{
pwr_tFileName fname;
dcli_translate_filename(fname, "$pwr_exe/profinet_vendorid.dat");
std::ifstream fp;
char line[1024];
int found = 0;
unsigned int id;
int num;
char* s;
fp.open(fname);
if (fp) {
while (fp.getline(line, sizeof(line))) {
num = sscanf(line, "%u", &id);
if (num != 1)
continue;
if (id == vendorid) {
s = strchr(line, ' ');
strncpy(vendorid_str, s + 1, size);
vendorid_str[size - 1] = 0;
found = 1;
break;
}
}
fp.close();
}
if (!found)
sprintf(vendorid_str, "%d", vendorid);
}
void wb_db::copy(wb_export &e, const char *fileName)
{
pwr_tStatus sts;
dcli_translate_filename(m_fileName, fileName);
openDb(false);
importVolume(e);
close();
openDb(true);
try {
m_env->txn_begin(0, (DbTxn **)&m_txn, 0);
wb_db_info i(this);
i.get(m_txn);
m_vid = i.vid();
m_cid = i.cid();
strcpy(m_volumeName, i.name());
commit(&sts);
}
catch (DbException &e) {
//txn->abort();
printf("exeption: %s\n", e.what());
}
}
int GlowCustomColors::read_colorfile( GrowCtx *ctx, char *name)
{
char filename[120];
char path_name[120];
ifstream fp;
strcpy( filename, name);
if ( !strstr( filename, ".pwgc"))
strcat( filename, ".pwgc");
dcli_translate_filename( filename, filename);
int found = 0;
if ( check_file( filename))
found = 1;
// Add some search path
if ( !found && ctx) {
for ( int i = 0; i < ctx->path_cnt; i++) {
strcpy( path_name, ctx->path[i]);
strcat( path_name, filename);
dcli_translate_filename( path_name, path_name);
if ( check_file( path_name)) {
found = 1;
break;
}
}
}
else
strcpy( path_name, filename);
if ( !found)
return GLOW__FILEOPEN;
fp.open( path_name);
if ( !fp)
return GLOW__FILEOPEN;
open( fp);
fp.close();
if ( ctx)
ctx->gdraw->reset_customcolors( this);
return GLOW__SUCCESS;
}
void wb_build::application( pwr_tOid oid)
{
pwr_tString80 buildcmd;
pwr_tCmd cmd;
int check_hierarchy = cdh_ObjidIsNotNull( m_hierarchy);
int hierarchy_found = 0;
int sts;
wb_object o = m_session.object(oid);
if ( !o) {
m_sts = o.sts();
return;
}
// Check that no ancestor is a LibHier
for ( wb_object p = o.parent(); p.oddSts(); p = p.parent()) {
if ( p.cid() == pwr_eClass_LibHier) {
m_sts = PWRB__INLIBHIER;
return;
}
if ( check_hierarchy && cdh_ObjidIsEqual( m_hierarchy, p.oid()))
hierarchy_found = 1;
}
if ( check_hierarchy && !hierarchy_found) {
m_sts = PWRB__NOBUILT;
return;
}
wb_attribute a = m_session.attribute( oid, "DevBody", "BuildCmd");
if ( !a) {
m_sts = a.sts();
return;
}
a.value( &buildcmd);
if ( !a) {
m_sts = a.sts();
return;
}
if ( strcmp( buildcmd, "") == 0) {
m_sts = PWRB__NOBUILT;
return;
}
// Exectute the build command
dcli_translate_filename( cmd, buildcmd);
sts = system( cmd);
if ( sts != 0) {
char msg[300];
sprintf( msg, "Build Application error %s", o.longName().name(cdh_mName_path | cdh_mName_object));
MsgWindow::message( 'E', msg, msgw_ePop_Yes, oid);
m_sts = PWRB__SUCCESS;
}
else {
m_sts = PWRB__NOBUILT;
}
}
static int xtttbl_ccm_deffilename_func( char *outfile, char *infile, void *client_data)
{
pwr_tFileName fname;
dcli_translate_filename( fname, infile);
dcli_get_defaultfilename( fname, outfile, ".rtt_com");
return 1;
}
static FILE *navhelp_open_file( NavHelp *navhelp, navh_eHelpFile file_type, const char *file_name)
{
pwr_tFileName filestr;
FILE *file;
if ( file_type == navh_eHelpFile_Base)
dcli_get_defaultfilename( navhelp->base_file, filestr, NULL);
else if ( file_type == navh_eHelpFile_Project)
dcli_get_defaultfilename( navhelp->project_file, filestr, NULL);
else if ( file_name)
dcli_get_defaultfilename( file_name, filestr, NULL);
else
dcli_get_defaultfilename( navhelp->base_file, filestr, NULL);
// Replace symbol for language
if ( strncmp( filestr, "$pwr_lang/", 10) == 0) {
pwr_tFileName lng_filestr;
sprintf( lng_filestr, "$pwr_exe/%s/%s", Lng::get_language_str(),
&filestr[10]);
dcli_translate_filename( lng_filestr, lng_filestr);
file = fopen( lng_filestr, "r");
if ( file == 0) {
// Default to English version
sprintf( lng_filestr, "$pwr_exe/en_us/%s", &filestr[10]);
dcli_translate_filename( lng_filestr, lng_filestr);
file = fopen( lng_filestr, "r");
if ( file == 0)
return 0;
}
}
else {
dcli_translate_filename( filestr, filestr);
file = fopen( filestr, "r");
if ( file == 0)
return 0;
}
return file;
}
int main( int argc, char *argv[])
{
char uid_filename[120] = {"pwr_exe:wb.uid"};
char *uid_filename_p = uid_filename;
MrmHierarchy s_DRMh;
MrmType dclass;
pwr_tStatus sts;
XtAppContext app_ctx;
char title[80];
Admin *admin;
dcli_translate_filename( uid_filename, uid_filename);
// First argument is username, and second password
strcpy( login_prv.username, "-");
strcpy( login_prv.password, "-");
if ( argc > 0)
cdh_ToLower( login_prv.username, argv[1]);
if ( argc > 1)
cdh_ToLower( login_prv.password, argv[2]);
MrmInitialize();
strcpy( title, "PwR Administrator");
toplevel = XtVaAppInitialize (
&app_ctx,
"PWR_ADM",
NULL, 0,
&argc, argv,
fbr,
XtNallowShellResize, True,
XtNtitle, title,
XmNmappedWhenManaged, False,
NULL);
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh);
if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename);
sts = MrmFetchWidget(s_DRMh, "mainwindow", toplevel,
&mainwindow, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch mainwindow\n");
MrmCloseHierarchy( s_DRMh);
XtManageChild( mainwindow);
admin = new Admin( toplevel, 0);
admin->close_cb = &adm_close_cb;
XtRealizeWidget( toplevel);
XtAppMainLoop(app_ctx);
return (0);
}
static int find_symbol( char *name, char *value)
{
static int loaded = 0;
static char sym_vect[MAXSYMBOLS][80];
static char value_vect[MAXSYMBOLS][80];
static int vect_cnt;
int nr;
char elemv[3][80];
int j;
int found;
// Read the file
if ( !loaded) {
FILE *fp;
char line[200];
pwr_tFileName fname;
vect_cnt = 0;
sprintf( fname, "$pwrp_db/pwrp_cnf_websymbols.dat");
dcli_translate_filename( fname, fname);
fp = fopen( fname, "r");
if ( !fp)
return 0;
while ( dcli_read_line( line, sizeof( line), fp)) {
nr = dcli_parse( line, " ", "", (char *)elemv, sizeof( elemv) / sizeof( elemv[0]),
sizeof( elemv[0]), 0);
if ( nr != 3)
continue;
strcpy( sym_vect[vect_cnt], elemv[1]);
strcpy( value_vect[vect_cnt], elemv[2]);
vect_cnt++;
}
fclose( fp);
loaded = 1;
}
if ( !vect_cnt)
return 0;
for ( j = 0; j < vect_cnt; j++) {
if ( cdh_NoCaseStrcmp( name, sym_vect[j]) == 0) {
strcpy( value, value_vect[j]);
found = 1;
break;
}
}
if ( !found)
return 0;
return 1;
}
int xnav_open_URL( pwr_tURL url)
{
char cmd[200];
int sts;
pwr_sClass_WebBrowserConfig *config_p = 0;
char browser[40] = "firefox";
pwr_tObjid config_objid;
sts = gdh_GetClassList( pwr_cClass_WebBrowserConfig, &config_objid);
if ( ODD(sts))
sts = gdh_ObjidToPointer( config_objid, (void **)&config_p);
if ( ODD(sts)) {
if ( strcmp( config_p->WebBrowser, "") != 0)
strcpy( browser, config_p->WebBrowser);
}
if ( strncmp( url, "$pwr_lang/", 10) == 0) {
// If file in $pwr_lang, check if file exist, else take en_us
if ( Lng::current() != lng_eLanguage_en_US) {
pwr_tURL testurl;
pwr_tTime t;
replace_symbol( url, testurl, config_p);
dcli_translate_filename( testurl, testurl);
sts = dcli_file_time( testurl, &t);
if ( EVEN(sts)) {
// Try en_us
strcpy( testurl, "$pwr_doc/en_us/");
strcat( testurl, &url[10]);
strcpy( url, testurl);
}
}
}
replace_symbol( url, url, config_p);
if ( strcmp( browser, "mozilla") == 0 ||
strcmp( browser, "rt_mozilla") == 0) {
// Try remote display first
sprintf( cmd, "%s -remote \"openurl(%s,new-window)\"", browser, url);
sts = system(cmd);
if ( sts) {
// Not started yet
sprintf( cmd, "%s %s &", browser, url);
system( cmd);
}
}
else {
sprintf( cmd, "%s %s &", browser, url);
system( cmd);
}
return XNAV__SUCCESS;
}
// Create class dependency file
void CnvWblToHtml::create_cdp_file( const char *volume_name, const char *class_name,
const char *attr_typeref)
{
pwr_tFileName fname;
sprintf( fname, "$pwre_broot/$pwre_target/bld/wbl/%s.cdp", CnvCtx::low(class_name));
dcli_translate_filename( fname, fname);
ofstream fp( fname);
fp << volume_name << " " << class_name << " " << attr_typeref << endl;
}
/*************************************************************************
*
* Name: logg_get_filename
*
* Typ int
*
* Typ Parameter IOGF Beskrivning
*
* Beskrivning:
* Adderar extention till filname om det saknas.
*
**************************************************************************/
static int logg_get_filename(
char *inname,
char *outname,
char *ext)
{
char *s;
char *s2;
pwr_tFileName timestr;
char comp_timestr[80];
pwr_tTime time;
dcli_translate_filename( outname, inname);
/* Look for extension in filename */
if ( ext != NULL)
{
s = strrchr( outname, ':');
if ( s == 0)
s = outname;
s2 = strrchr( s, '>');
if ( s2 == 0)
{
s2 = strrchr( s, ']');
if ( s2 == 0)
s2 = s;
}
s = strrchr( s2, '.');
if ( s != 0)
*s = 0;
strcat( outname, ext);
}
#if defined OS_LYNX || defined OS_LINUX
/* Get current time to use as "version number" */
time_GetTime( &time);
time_AtoAscii( &time, time_eFormat_ComprDateAndTime, timestr,
sizeof(timestr));
comp_timestr[0] = '.';
memcpy(&comp_timestr[1], ×tr[0], 2);
memcpy(&comp_timestr[3], ×tr[3], 2);
memcpy(&comp_timestr[5], ×tr[6], 2);
memcpy(&comp_timestr[7], ×tr[9], 2);
memcpy(&comp_timestr[9], ×tr[12], 2);
memcpy(&comp_timestr[11], ×tr[15], 2);
comp_timestr[13] = 0;
// strcat(outname, comp_timestr);
#endif
return REM__SUCCESS;
}
void XttTbl::activate_print()
{
pwr_tFileName filename;
pwr_tCmd cmd;
dcli_translate_filename(filename, "$pwrp_tmp/sevxtt.ps");
tblnav->print(filename);
sprintf(cmd, "$pwr_exe/rt_print.sh %s", filename);
system(cmd);
}
void Ge::activate_print()
{
pwr_tFileName fname;
pwr_tCmd cmd;
dcli_translate_filename( fname, "$pwrp_tmp/graph.ps");
graph->print( fname);
sprintf( cmd, "$pwr_exe/rt_print.sh %s 1", fname);
system(cmd);
}
void XttMotif::print()
{
pwr_tFileName filename;
pwr_tCmd cmd;
dcli_translate_filename( filename, "$pwrp_tmp/xnav.ps");
xnav->print( filename);
sprintf( cmd, "$pwr_exe/rt_print.sh %s", filename);
system(cmd);
}
void WdaMotif::print( const char *title)
{
pwr_tFileName filename = "$pwrp_tmp/wda.ps";
pwr_tCmd cmd;
int sts;
dcli_translate_filename( filename, filename);
wdanav->print(filename);
sprintf( cmd, "wb_gre_print.sh %s", filename);
sts = system( cmd);
}
GsdmlAttr::GsdmlAttr( void *a_parent_ctx,
void *a_object,
pn_gsdml *a_gsdml,
int a_edit_mode,
const char *a_data_filename) :
parent_ctx(a_parent_ctx), gsdml(a_gsdml), edit_mode(a_edit_mode), input_open(0),
object(a_object),
close_cb(0), save_cb(0), help_cb(0), client_data(0), recall_idx(-1),
value_current_recall(0)
{
dcli_translate_filename( data_filename, a_data_filename);
}
XttLog::XttLog(const char* filename, int event) : m_event(event), m_level(1)
{
char category_str[20];
dcli_translate_filename(m_filename, filename);
strncpy(m_pid, syi_ProcessId(), sizeof(m_pid));
gdh_RegisterLogFunction(gdh_log_bc);
category_to_string(xttlog_eCategory_LogStart, category_str);
log(category_str, 0, 0, 0, 0);
}
void wb_dbms::open(const char *fileName)
{
char l_fileName[512];
dcli_translate_filename(l_fileName, fileName);
if (!m_env) {
m_env = new wb_dbms_env(l_fileName);
m_env->open();
}
open();
}
void GsdAttr::activate_print()
{
char filename[80] = "pwrp_tmp:wnav.ps";
char cmd[200];
int sts;
dcli_translate_filename( filename, filename);
attrnav->print( filename);
sprintf( cmd, "wb_gre_print.sh %s", filename);
sts = system( cmd);
}
void Ge::export_plcfo( Ge *gectx, char *filename)
{
int sts;
pwr_tFileName fname;
sprintf( fname, "$pwrp_exe/%s.flwn", filename);
dcli_translate_filename( fname, fname);
sts = gectx->graph->export_plcfo( fname);
if ( EVEN(sts))
gectx->message( sts);
}
static void get_config( char *name, unsigned int *lk_max_locks,
unsigned int *lk_max_objects)
{
pwr_tFileName fname;
FILE *fp;
char line[200];
char line_elem[2][100];
unsigned int max_locks;
unsigned int max_objects;
int nr;
*lk_max_locks = 50000;
*lk_max_objects = 20000;
strcpy( fname, name);
strcat( fname, ".cnf");
dcli_translate_filename( fname, fname);
fp = fopen( fname, "r");
if ( !fp)
return;
while ( dcli_read_line( line, sizeof(line), fp)) {
dcli_trim( line, line);
if ( line[0] == '#')
continue;
if ( strcmp( line, "") == 0)
continue;
nr = dcli_parse( line, " ", "",
(char *) line_elem, sizeof( line_elem)/sizeof( line_elem[0]),
sizeof( line_elem[0]), 1);
if ( nr != 2)
continue;
if ( cdh_NoCaseStrcmp( line_elem[0], "lk_max_locks") == 0) {
nr = sscanf( line_elem[1], "%d", &max_locks);
if ( nr == 1) {
*lk_max_locks = max_locks;
printf( "lk_max_locks.........%d\n", max_locks);
}
}
else if ( cdh_NoCaseStrcmp( line_elem[0], "lk_max_objects") == 0) {
nr = sscanf( line_elem[1], "%d", &max_objects);
if ( nr == 1) {
*lk_max_objects = max_objects;
printf( "lk_max_objects.......%d\n", max_objects);
}
}
}
fclose( fp);
}
void WNavMotif::print( const char *title)
{
char filename[80] = "pwrp_tmp:wnav.ps";
char cmd[200];
int sts;
dcli_translate_filename( filename, filename);
brow_Print( brow->ctx, filename);
#if defined OS_POSIX
sprintf( cmd, "wb_gre_print.sh %s", filename);
sts = system( cmd);
#endif
}
pwr_tStatus bck_print( char *filename)
{
char fname[256];
pwr_sAttrRef aref;
pwr_tAName objname;
FILE *fp = 0;
pwr_sAttrRef dataname;
int sts;
if ( filename) {
dcli_translate_filename( fname, filename);
fp = fopen( fname, "w");
if ( !fp) return 0;
}
sts = gdh_Init("pwr_bck_print");
if (EVEN(sts)) return sts;
sts = gdh_GetClassListAttrRef( pwr_cClass_Backup, &aref);
while ( ODD(sts)) {
if ( aref.Objid.vid < cdh_cUserVolMin) {
// In template plc, continue
sts = gdh_GetNextAttrRef( pwr_cClass_Backup, &aref, &aref);
continue;
}
sts = gdh_AttrrefToName( &aref, objname, sizeof(objname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
if ( fp)
fprintf( fp, "// %s\n", objname);
else
printf( "// %s\n", objname);
strcat( objname, ".DataName");
sts = gdh_GetObjectInfo( objname, &dataname, sizeof(dataname));
sts = print_data( &dataname, fp);
if ( EVEN(sts)) error_msg( sts, fp);
sts = gdh_GetNextAttrRef( pwr_cClass_Backup, &aref, &aref);
}
if ( fp)
fclose(fp);
return 1;
}
pwr_tStatus wb_bck_list::print( char *outfile)
{
pwr_tFileName fname;
FILE *fout;
pwr_tStatus sts;
dcli_translate_filename( fname, outfile);
fout = fopen( fname, "w");
if ( !fout)
return LDH__NOSUCHFILE;
bck_sItem *ip = m_first;
while (ip) {
char str[1024];
pwr_eType atype;
int printed = 0;
char *anamep;
int size;
sts = ldh_AttrRefToName( m_ldhses, &ip->aref, cdh_mName_volumeStrict, &anamep, &size);
if ( EVEN(sts)) return sts;
fprintf( fout, "%s", anamep);
sts = ldh_GetAttrRefType( m_ldhses, &ip->aref, &atype);
if ( ODD(sts)) {
sts = cdh_AttrValueToString( atype, ip->valuep, str, sizeof(str));
if ( ODD(sts)) {
fprintf( fout, "\n %s\n", str);
printed = 1;
}
}
if ( !printed) {
// Print as hex code
unsigned char *p = (unsigned char *)ip->valuep;
for ( int i = 0; i < (int)ip->size; i++, p++) {
if ((i % 16) == 0) fprintf( fout, "\n ");
fprintf( fout, "%02x ", *p);
}
fprintf( fout, "\n");
}
ip = ip->next;
}
fclose( fout);
return LDH__SUCCESS;
}
