~ubuntu-branches/ubuntu/intrepid/plplot/intrepid

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pl_1setcontlabelparam(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jint jarg4) {

1002

PLFLT arg1 ;

1003

PLFLT arg2 ;

1004

PLFLT arg3 ;

1005

PLINT arg4 ;

1006

1007

(void)jenv;

1008

(void)jcls;

1009

arg1 = (PLFLT)jarg1;

1010

arg2 = (PLFLT)jarg2;

1011

arg3 = (PLFLT)jarg3;

1012

arg4 = (PLINT)jarg4;

1013

pl_setcontlabelparam(arg1,arg2,arg3,arg4);

1014

1218

PLFLT arg1 ;

1219

PLFLT arg2 ;

1220

PLFLT arg3 ;

1221

PLINT arg4 ;

1222

1223

(void)jenv;

1224

(void)jcls;

1225

arg1 = (PLFLT)jarg1;

1226

arg2 = (PLFLT)jarg2;

1227

arg3 = (PLFLT)jarg3;

1228

arg4 = (PLINT)jarg4;

1229

pl_setcontlabelparam(arg1,arg2,arg3,arg4);

1230

1015

1231

}

1016

1232

1017

1233

1018

1234

#define _doc_pladv "Advance to subpage \"page\", or to the next one if \"page\" = 0."

1019

1235

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pladv(JNIEnv *jenv, jclass jcls, jint jarg1) {

1020

PLINT arg1 ;

1021

1022

(void)jenv;

1023

(void)jcls;

1024

arg1 = (PLINT)jarg1;

1025

pladv(arg1);

1026

1236

PLINT arg1 ;

1237

1238

(void)jenv;

1239

(void)jcls;

1240

arg1 = (PLINT)jarg1;

1241

pladv(arg1);

1242

1027

1243

}

1028

1244

1029

1245

1030

1246

#define _doc_plaxes "This functions similarly to plbox() except that the origin of the axes is placed at the user-specified point (x0, y0)."

1031

1247

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plaxes(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jstring jarg3, jdouble jarg4, jint jarg5, jstring jarg6, jdouble jarg7, jint jarg8) {

1032

PLFLT arg1 ;

1033

PLFLT arg2 ;

1034

char *arg3 ;

1035

PLFLT arg4 ;

1036

PLINT arg5 ;

1037

char *arg6 ;

1038

PLFLT arg7 ;

1039

PLINT arg8 ;

1040

1041

(void)jenv;

1042

(void)jcls;

1043

arg1 = (PLFLT)jarg1;

1044

arg2 = (PLFLT)jarg2;

1045

{

1046

arg3 = 0;

1047

if (jarg3) {

1048

arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);

1049

if (!arg3) return ;

1050

}

1051

}

1052

arg4 = (PLFLT)jarg4;

1053

arg5 = (PLINT)jarg5;

1054

{

1055

arg6 = 0;

1056

if (jarg6) {

1057

arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);

1058

if (!arg6) return ;

1059

}

1060

}

1061

arg7 = (PLFLT)jarg7;

1062

arg8 = (PLINT)jarg8;

1063

plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);

1064

1065

{

1066

if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, arg3);

1067

}

1068

{

1069

if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, arg6);

1070

}

1248

PLFLT arg1 ;

1249

PLFLT arg2 ;

1250

char *arg3 = (char *) 0 ;

1251

PLFLT arg4 ;

1252

PLINT arg5 ;

1253

char *arg6 = (char *) 0 ;

1254

PLFLT arg7 ;

1255

PLINT arg8 ;

1256

1257

(void)jenv;

1258

(void)jcls;

1259

arg1 = (PLFLT)jarg1;

1260

arg2 = (PLFLT)jarg2;

1261

arg3 = 0;

1262

if (jarg3) {

1263

arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);

1264

if (!arg3) return ;

1265

}

1266

arg4 = (PLFLT)jarg4;

1267

arg5 = (PLINT)jarg5;

1268

arg6 = 0;

1269

if (jarg6) {

1270

arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);

1271

if (!arg6) return ;

1272

}

1273

arg7 = (PLFLT)jarg7;

1274

arg8 = (PLINT)jarg8;

1275

plaxes(arg1,arg2,(char const *)arg3,arg4,arg5,(char const *)arg6,arg7,arg8);

1276

1277

if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, arg3);

1278

if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, arg6);

1071

1279

}

1072

1280

1073

1281

1074

1282

#define _doc_plbin "Plot a histogram using x to store data values and y to store frequencies."

1075

1283

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbin(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {

1076

PLINT arg1 ;

1077

PLFLT *arg2 = (PLFLT *) 0 ;

1078

PLFLT *arg3 = (PLFLT *) 0 ;

1079

PLINT arg4 ;

1080

1081

(void)jenv;

1082

(void)jcls;

1083

{

1084

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1085

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1086

Alen = arg1;

1087

setup_array_1d_d( &arg2, jxdata, Alen );

1088

/* Could find no easy way to do this as part of freearg so I modified

1089

* the previous function so it ALWAYS mallocs and copies so that

1090

* the java array can be released immediately. */

1091

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1092

}

1093

{

1094

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1095

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1096

printf("Vectors must be same length.\n");

1097

return;

1098

}

1099

setup_array_1d_d( &arg3, jydata, Alen );

1100

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1101

}

1102

arg4 = (PLINT)jarg4;

1103

plbin(arg1,arg2,arg3,arg4);

1104

1105

{

1106

free(arg2);

1107

}

1108

{

1109

free(arg3);

1110

}

1284

PLINT arg1 ;

1285

PLFLT *arg2 = (PLFLT *) 0 ;

1286

PLFLT *arg3 = (PLFLT *) 0 ;

1287

PLINT arg4 ;

1288

1289

(void)jenv;

1290

(void)jcls;

1291

{

1292

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1293

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1294

Alen = arg1;

1295

setup_array_1d_d( &arg2, jxdata, Alen );

1296

/* Could find no easy way to do this as part of freearg so I modified

1297

* the previous function so it ALWAYS mallocs and copies so that

1298

* the java array can be released immediately. */

1299

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1300

}

1301

{

1302

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1303

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1304

printf("Vectors must be same length.\n");

1305

return;

1306

}

1307

setup_array_1d_d( &arg3, jydata, Alen );

1308

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1309

}

1310

arg4 = (PLINT)jarg4;

1311

plbin(arg1,arg2,arg3,arg4);

1312

1313

{

1314

free(arg2);

1315

}

1316

{

1317

free(arg3);

1318

}

1111

1319

}

1112

1320

1113

1321

1114

1322

#define _doc_plbop "Start new page. Should only be used with pleop()."

1115

1323

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbop(JNIEnv *jenv, jclass jcls) {

1116

(void)jenv;

1117

(void)jcls;

1118

plbop();

1119

1324

(void)jenv;

1325

(void)jcls;

1326

plbop();

1327

1120

1328

}

1121

1329

1122

1330

1123

1331

#define _doc_plbox "Draw a box around the current viewport."

1124

1332

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbox(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jint jarg3, jstring jarg4, jdouble jarg5, jint jarg6) {

1125

char *arg1 ;

1126

PLFLT arg2 ;

1127

PLINT arg3 ;

1128

char *arg4 ;

1129

PLFLT arg5 ;

1130

PLINT arg6 ;

1131

1132

(void)jenv;

1133

(void)jcls;

1134

{

1135

arg1 = 0;

1136

if (jarg1) {

1137

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

1138

if (!arg1) return ;

1139

}

1140

}

1141

arg2 = (PLFLT)jarg2;

1142

arg3 = (PLINT)jarg3;

1143

{

1144

arg4 = 0;

1145

if (jarg4) {

1146

arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0);

1147

if (!arg4) return ;

1148

}

1149

}

1150

arg5 = (PLFLT)jarg5;

1151

arg6 = (PLINT)jarg6;

1152

plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);

1153

1154

{

1155

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

1156

}

1157

{

1158

if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, arg4);

1159

}

1333

char *arg1 = (char *) 0 ;

1334

PLFLT arg2 ;

1335

PLINT arg3 ;

1336

char *arg4 = (char *) 0 ;

1337

PLFLT arg5 ;

1338

PLINT arg6 ;

1339

1340

(void)jenv;

1341

(void)jcls;

1342

arg1 = 0;

1343

if (jarg1) {

1344

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

1345

if (!arg1) return ;

1346

}

1347

arg2 = (PLFLT)jarg2;

1348

arg3 = (PLINT)jarg3;

1349

arg4 = 0;

1350

if (jarg4) {

1351

arg4 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg4, 0);

1352

if (!arg4) return ;

1353

}

1354

arg5 = (PLFLT)jarg5;

1355

arg6 = (PLINT)jarg6;

1356

plbox((char const *)arg1,arg2,arg3,(char const *)arg4,arg5,arg6);

1357

1358

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

1359

if (arg4) (*jenv)->ReleaseStringUTFChars(jenv, jarg4, arg4);

1160

1360

}

1161

1361

1162

1362

1163

1363

#define _doc_plbox3 "This is the 3-d analogue of plbox()."

1164

1364

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plbox3(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jdouble jarg3, jint jarg4, jstring jarg5, jstring jarg6, jdouble jarg7, jint jarg8, jstring jarg9, jstring jarg10, jdouble jarg11, jint jarg12) {

1165

char *arg1 ;

1166

char *arg2 ;

1167

PLFLT arg3 ;

1168

PLINT arg4 ;

1169

char *arg5 ;

1170

char *arg6 ;

1171

PLFLT arg7 ;

1172

PLINT arg8 ;

1173

char *arg9 ;

1174

char *arg10 ;

1175

PLFLT arg11 ;

1176

PLINT arg12 ;

1177

1178

(void)jenv;

1179

(void)jcls;

1180

{

1181

arg1 = 0;

1182

if (jarg1) {

1183

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

1184

if (!arg1) return ;

1185

}

1186

}

1187

{

1188

arg2 = 0;

1189

if (jarg2) {

1190

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

1191

if (!arg2) return ;

1192

}

1193

}

1194

arg3 = (PLFLT)jarg3;

1195

arg4 = (PLINT)jarg4;

1196

{

1197

arg5 = 0;

1198

if (jarg5) {

1199

arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);

1200

if (!arg5) return ;

1201

}

1202

}

1203

{

1204

arg6 = 0;

1205

if (jarg6) {

1206

arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);

1207

if (!arg6) return ;

1208

}

1209

}

1210

arg7 = (PLFLT)jarg7;

1211

arg8 = (PLINT)jarg8;

1212

{

1213

arg9 = 0;

1214

if (jarg9) {

1215

arg9 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg9, 0);

1216

if (!arg9) return ;

1217

}

1218

}

1219

{

1220

arg10 = 0;

1221

if (jarg10) {

1222

arg10 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg10, 0);

1223

if (!arg10) return ;

1224

}

1225

}

1226

arg11 = (PLFLT)jarg11;

1227

arg12 = (PLINT)jarg12;

1228

plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);

1229

1230

{

1231

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

1232

}

1233

{

1234

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

1235

}

1236

{

1237

if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, arg5);

1238

}

1239

{

1240

if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, arg6);

1241

}

1242

{

1243

if (arg9) (*jenv)->ReleaseStringUTFChars(jenv, jarg9, arg9);

1244

}

1245

{

1246

if (arg10) (*jenv)->ReleaseStringUTFChars(jenv, jarg10, arg10);

1247

}

1365

char *arg1 = (char *) 0 ;

1366

char *arg2 = (char *) 0 ;

1367

PLFLT arg3 ;

1368

PLINT arg4 ;

1369

char *arg5 = (char *) 0 ;

1370

char *arg6 = (char *) 0 ;

1371

PLFLT arg7 ;

1372

PLINT arg8 ;

1373

char *arg9 = (char *) 0 ;

1374

char *arg10 = (char *) 0 ;

1375

PLFLT arg11 ;

1376

PLINT arg12 ;

1377

1378

(void)jenv;

1379

(void)jcls;

1380

arg1 = 0;

1381

if (jarg1) {

1382

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

1383

if (!arg1) return ;

1384

}

1385

arg2 = 0;

1386

if (jarg2) {

1387

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

1388

if (!arg2) return ;

1389

}

1390

arg3 = (PLFLT)jarg3;

1391

arg4 = (PLINT)jarg4;

1392

arg5 = 0;

1393

if (jarg5) {

1394

arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);

1395

if (!arg5) return ;

1396

}

1397

arg6 = 0;

1398

if (jarg6) {

1399

arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);

1400

if (!arg6) return ;

1401

}

1402

arg7 = (PLFLT)jarg7;

1403

arg8 = (PLINT)jarg8;

1404

arg9 = 0;

1405

if (jarg9) {

1406

arg9 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg9, 0);

1407

if (!arg9) return ;

1408

}

1409

arg10 = 0;

1410

if (jarg10) {

1411

arg10 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg10, 0);

1412

if (!arg10) return ;

1413

}

1414

arg11 = (PLFLT)jarg11;

1415

arg12 = (PLINT)jarg12;

1416

plbox3((char const *)arg1,(char const *)arg2,arg3,arg4,(char const *)arg5,(char const *)arg6,arg7,arg8,(char const *)arg9,(char const *)arg10,arg11,arg12);

1417

1418

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

1419

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

1420

if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, arg5);

1421

if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, arg6);

1422

if (arg9) (*jenv)->ReleaseStringUTFChars(jenv, jarg9, arg9);

1423

if (arg10) (*jenv)->ReleaseStringUTFChars(jenv, jarg10, arg10);

1248

1424

}

1249

1425

1250

1426

1251

1427

#define _doc_plcalc_world "Calculate world coordinates and subpage from relative device coordinates."

1252

1428

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcalc_1world(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdoubleArray jarg3, jdoubleArray jarg4, jintArray jarg5) {

1253

PLFLT arg1 ;

1254

PLFLT arg2 ;

1255

PLFLT *arg3 = (PLFLT *) 0 ;

1256

PLFLT *arg4 = (PLFLT *) 0 ;

1257

PLINT *arg5 = (PLINT *) 0 ;

1258

PLFLT temp3 ;

1259

PLFLT temp4 ;

1260

PLINT temp5 ;

1261

1262

(void)jenv;

1263

(void)jcls;

1264

arg1 = (PLFLT)jarg1;

1265

arg2 = (PLFLT)jarg2;

1266

{

1267

if (!jarg3) {

1268

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1269

return ;

1270

}

1271

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

1272

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1273

return ;

1274

}

1275

arg3 = &temp3;

1276

}

1277

{

1278

if (!jarg4) {

1279

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1280

return ;

1281

}

1282

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

1283

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1284

return ;

1285

}

1286

arg4 = &temp4;

1287

}

1288

{

1289

if (!jarg5) {

1290

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1291

return ;

1292

}

1293

if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {

1294

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1295

return ;

1296

}

1297

arg5 = &temp5;

1298

}

1299

plcalc_world(arg1,arg2,arg3,arg4,arg5);

1300

1301

{

1302

jdouble jvalue = (jdouble)temp3;

1303

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

1304

}

1305

{

1306

jdouble jvalue = (jdouble)temp4;

1307

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

1308

}

1309

{

1310

jint jvalue = (jint)temp5;

1311

(*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);

1312

}

1429

PLFLT arg1 ;

1430

PLFLT arg2 ;

1431

PLFLT *arg3 = (PLFLT *) 0 ;

1432

PLFLT *arg4 = (PLFLT *) 0 ;

1433

PLINT *arg5 = (PLINT *) 0 ;

1434

PLFLT temp3 ;

1435

PLFLT temp4 ;

1436

PLINT temp5 ;

1437

1438

(void)jenv;

1439

(void)jcls;

1440

arg1 = (PLFLT)jarg1;

1441

arg2 = (PLFLT)jarg2;

1442

{

1443

if (!jarg3) {

1444

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1445

return ;

1446

}

1447

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

1448

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1449

return ;

1450

}

1451

arg3 = &temp3;

1452

}

1453

{

1454

if (!jarg4) {

1455

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1456

return ;

1457

}

1458

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

1459

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1460

return ;

1461

}

1462

arg4 = &temp4;

1463

}

1464

{

1465

if (!jarg5) {

1466

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1467

return ;

1468

}

1469

if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {

1470

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1471

return ;

1472

}

1473

arg5 = &temp5;

1474

}

1475

plcalc_world(arg1,arg2,arg3,arg4,arg5);

1476

1477

{

1478

jdouble jvalue = (jdouble)temp3;

1479

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

1480

}

1481

{

1482

jdouble jvalue = (jdouble)temp4;

1483

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

1484

}

1485

{

1486

jint jvalue = (jint)temp5;

1487

(*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);

1488

}

1489

1490

1491

1313

1492

}

1314

1493

1315

1494

1316

1495

#define _doc_plclear "Clear current subpage."

1317

1496

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plclear(JNIEnv *jenv, jclass jcls) {

1318

(void)jenv;

1319

(void)jcls;

1320

plclear();

1321

1497

(void)jenv;

1498

(void)jcls;

1499

plclear();

1500

1322

1501

}

1323

1502

1324

1503

1325

1504

#define _doc_plcol0 "Set color, map 0. Argument is integer between 0 and 15."

1326

1505

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcol0(JNIEnv *jenv, jclass jcls, jint jarg1) {

1327

PLINT arg1 ;

1328

1329

(void)jenv;

1330

(void)jcls;

1331

arg1 = (PLINT)jarg1;

1332

plcol0(arg1);

1333

1506

PLINT arg1 ;

1507

1508

(void)jenv;

1509

(void)jcls;

1510

arg1 = (PLINT)jarg1;

1511

plcol0(arg1);

1512

1334

1513

}

1335

1514

1336

1515

1337

1516

#define _doc_plcol1 "Set color, map 1. Argument is a float between 0. and 1."

1338

1517

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcol1(JNIEnv *jenv, jclass jcls, jdouble jarg1) {

1339

PLFLT arg1 ;

1340

1341

(void)jenv;

1342

(void)jcls;

1343

arg1 = (PLFLT)jarg1;

1344

plcol1(arg1);

1345

1518

PLFLT arg1 ;

1519

1520

(void)jenv;

1521

(void)jcls;

1522

arg1 = (PLFLT)jarg1;

1523

plcol1(arg1);

1524

1346

1525

}

1347

1526

1348

1527

1349

1528

#define _doc_plcont "Draw a contour plot."

1350

1529

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcont(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg4, jint jarg5, jint jarg6, jint jarg7, jdoubleArray jarg8, jobjectArray jarg10, jobjectArray jarg11) {

1351

PLFLT **arg1 = (PLFLT **) 0 ;

1352

PLINT arg2 ;

1353

PLINT arg3 ;

1354

PLINT arg4 ;

1355

PLINT arg5 ;

1356

PLINT arg6 ;

1357

PLINT arg7 ;

1358

PLFLT *arg8 = (PLFLT *) 0 ;

1359

PLINT arg9 ;

1360

pltr_func arg10 ;

1361

PLPointer arg11 = (PLPointer) 0 ;

1362

1363

(void)jenv;

1364

(void)jcls;

1365

{

1366

jdouble **adat;

1367

jobject *ai;

1368

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

1369

int ny = -1;

1370

int i, j;

1371

ai = (jobject *) malloc( nx * sizeof(jobject) );

1372

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

1373

1374

for( i=0; i < nx; i++ )

1375

{

1376

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

1377

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

1378

1379

if (ny == -1)

1380

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

1381

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

1382

printf( "Misshapen a array.\n" );

1383

for( j=0; j <= i; j++ )

1384

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

1385

free(adat);

1386

free(ai);

1387

return;

1388

}

1389

}

1390

1391

Xlen = nx;

1392

Ylen = ny;

1393

setup_array_2d_d( &arg1, adat, nx, ny );

1394

arg2 = nx;

1395

arg3 = ny;

1396

for( i=0; i < nx; i++ ) {

1397

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1398

(*jenv)->DeleteLocalRef(jenv, ai[i]);

1399

}

1400

1401

free(adat);

1402

free(ai);

1403

1404

}

1405

arg4 = (PLINT)jarg4;

1406

arg5 = (PLINT)jarg5;

1407

arg6 = (PLINT)jarg6;

1408

arg7 = (PLINT)jarg7;

1409

{

1410

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg8, 0 );

1411

arg9 = (*jenv)->GetArrayLength( jenv, jarg8 );

1412

setup_array_1d_d( &arg8, jxdata, arg9);

1413

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg8, jxdata, 0 );

1414

}

1415

{

1416

jdouble **adat;

1417

jobject *ai;

1418

int nx = (*jenv)->GetArrayLength( jenv, jarg10 );

1419

int ny = -1;

1420

int i, j;

1421

ai = (jobject *) malloc( nx * sizeof(jobject) );

1422

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

1423

1424

for( i=0; i < nx; i++ )

1425

{

1426

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg10, i );

1427

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

1428

1429

if (ny == -1)

1430

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

1431

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

1432

printf( "Misshapen a array.\n" );

1433

for( j=0; j <= i; j++ )

1434

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

1435

free(adat);

1436

free(ai);

1437

return;

1438

}

1439

}

1440

1441

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

1442

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

1443

printf( "X vector or matrix must match matrix dimensions.\n" );

1444

for( i=0; i < nx; i++ )

1445

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1446

free(adat);

1447

free(ai);

1448

return;

1449

}

1450

/* Store whether second dimension is unity. */

1451

Alen = ny;

1452

setup_array_2d_d( &xg, adat, nx, ny );

1453

for( i=0; i < nx; i++ ) {

1454

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1455

(*jenv)->DeleteLocalRef(jenv, ai[i]);

1456

}

1457

1458

free(adat);

1459

free(ai);

1460

arg10 = pltr2;

1461

1462

}

1463

{

1464

jdouble **adat;

1465

jobject *ai;

1466

int nx = (*jenv)->GetArrayLength( jenv, jarg11 );

1467

int ny = -1;

1468

int i, j;

1469

PLcGrid2 cgrid;

1470

ai = (jobject *) malloc( nx * sizeof(jobject) );

1471

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

1472

1473

for( i=0; i < nx; i++ )

1474

{

1475

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg11, i );

1476

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

1477

1478

if (ny == -1)

1479

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

1480

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

1481

printf( "Misshapen a array.\n" );

1482

for( j=0; j <= i; j++ )

1483

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

1484

free(adat);

1485

free(ai);

1486

return;

1487

}

1488

}

1489

1490

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

1491

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

1492

Xlen, nx, Ylen, Alen, ny );

1493

printf( "Y vector or matrix must match matrix dimensions.\n" );

1494

for( i=0; i < nx; i++ )

1495

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1496

free(adat);

1497

free(ai);

1498

return;

1499

}

1500

setup_array_2d_d( &yg, adat, nx, ny );

1501

for( i=0; i < nx; i++ ) {

1502

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1503

(*jenv)->DeleteLocalRef(jenv, ai[i]);

1504

}

1505

1506

free(adat);

1507

free(ai);

1508

cgrid.xg = xg;

1509

cgrid.yg = yg;

1510

cgrid.nx = nx;

1511

cgrid.ny = ny;

1512

arg11 = &cgrid;

1513

1514

}

1515

plcont(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);

1516

1517

{

1518

free(arg1[0]);

1519

free(arg1);

1520

}

1521

{

1522

free(arg8);

1523

}

1524

{

1525

free(xg[0]);

1526

free(xg);

1527

}

1528

{

1529

free(yg[0]);

1530

free(yg);

1531

}

1530

PLFLT **arg1 = (PLFLT **) 0 ;

1531

PLINT arg2 ;

1532

PLINT arg3 ;

1533

PLINT arg4 ;

1534

PLINT arg5 ;

1535

PLINT arg6 ;

1536

PLINT arg7 ;

1537

PLFLT *arg8 = (PLFLT *) 0 ;

1538

PLINT arg9 ;

1539

pltr_func arg10 ;

1540

PLPointer arg11 = (PLPointer) 0 ;

1541

1542

(void)jenv;

1543

(void)jcls;

1544

{

1545

jdouble **adat;

1546

jobject *ai;

1547

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

1548

int ny = -1;

1549

int i, j;

1550

ai = (jobject *) malloc( nx * sizeof(jobject) );

1551

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

1552

1553

for( i=0; i < nx; i++ )

1554

{

1555

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

1556

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

1557

1558

if (ny == -1)

1559

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

1560

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

1561

printf( "Misshapen a array.\n" );

1562

for( j=0; j <= i; j++ )

1563

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

1564

free(adat);

1565

free(ai);

1566

return;

1567

}

1568

}

1569

1570

Xlen = nx;

1571

Ylen = ny;

1572

setup_array_2d_d( &arg1, adat, nx, ny );

1573

arg2 = nx;

1574

arg3 = ny;

1575

for( i=0; i < nx; i++ ) {

1576

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1577

(*jenv)->DeleteLocalRef(jenv, ai[i]);

1578

}

1579

1580

free(adat);

1581

free(ai);

1582

1583

}

1584

arg4 = (PLINT)jarg4;

1585

arg5 = (PLINT)jarg5;

1586

arg6 = (PLINT)jarg6;

1587

arg7 = (PLINT)jarg7;

1588

{

1589

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg8, 0 );

1590

arg9 = (*jenv)->GetArrayLength( jenv, jarg8 );

1591

setup_array_1d_d( &arg8, jxdata, arg9);

1592

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg8, jxdata, 0 );

1593

}

1594

{

1595

jdouble **adat;

1596

jobject *ai;

1597

int nx = (*jenv)->GetArrayLength( jenv, jarg10 );

1598

int ny = -1;

1599

int i, j;

1600

ai = (jobject *) malloc( nx * sizeof(jobject) );

1601

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

1602

1603

for( i=0; i < nx; i++ )

1604

{

1605

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg10, i );

1606

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

1607

1608

if (ny == -1)

1609

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

1610

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

1611

printf( "Misshapen a array.\n" );

1612

for( j=0; j <= i; j++ )

1613

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

1614

free(adat);

1615

free(ai);

1616

return;

1617

}

1618

}

1619

1620

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

1621

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

1622

printf( "X vector or matrix must match matrix dimensions.\n" );

1623

for( i=0; i < nx; i++ )

1624

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1625

free(adat);

1626

free(ai);

1627

return;

1628

}

1629

/* Store whether second dimension is unity. */

1630

Alen = ny;

1631

setup_array_2d_d( &xg, adat, nx, ny );

1632

for( i=0; i < nx; i++ ) {

1633

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1634

(*jenv)->DeleteLocalRef(jenv, ai[i]);

1635

}

1636

1637

free(adat);

1638

free(ai);

1639

arg10 = pltr2;

1640

1641

}

1642

{

1643

jdouble **adat;

1644

jobject *ai;

1645

int nx = (*jenv)->GetArrayLength( jenv, jarg11 );

1646

int ny = -1;

1647

int i, j;

1648

PLcGrid2 cgrid;

1649

ai = (jobject *) malloc( nx * sizeof(jobject) );

1650

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

1651

1652

for( i=0; i < nx; i++ )

1653

{

1654

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg11, i );

1655

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

1656

1657

if (ny == -1)

1658

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

1659

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

1660

printf( "Misshapen a array.\n" );

1661

for( j=0; j <= i; j++ )

1662

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

1663

free(adat);

1664

free(ai);

1665

return;

1666

}

1667

}

1668

1669

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

1670

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

1671

Xlen, nx, Ylen, Alen, ny );

1672

printf( "Y vector or matrix must match matrix dimensions.\n" );

1673

for( i=0; i < nx; i++ )

1674

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1675

free(adat);

1676

free(ai);

1677

return;

1678

}

1679

setup_array_2d_d( &yg, adat, nx, ny );

1680

for( i=0; i < nx; i++ ) {

1681

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

1682

(*jenv)->DeleteLocalRef(jenv, ai[i]);

1683

}

1684

1685

free(adat);

1686

free(ai);

1687

cgrid.xg = xg;

1688

cgrid.yg = yg;

1689

cgrid.nx = nx;

1690

cgrid.ny = ny;

1691

arg11 = &cgrid;

1692

1693

}

1694

plcont(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);

1695

1696

{

1697

free(arg1[0]);

1698

free(arg1);

1699

}

1700

{

1701

free(arg8);

1702

}

1703

{

1704

free(xg[0]);

1705

free(xg);

1706

}

1707

{

1708

free(yg[0]);

1709

free(yg);

1710

}

1532

1711

}

1533

1712

1534

1713

1535

1714

#define _doc_plcpstrm "Copy state parameters from the reference stream to the current stream."

1536

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcpstrm(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

1537

PLINT arg1 ;

1538

PLINT arg2 ;

1539

1540

(void)jenv;

1541

(void)jcls;

1542

arg1 = (PLINT)jarg1;

1543

arg2 = (PLINT)jarg2;

1544

plcpstrm(arg1,arg2);

1545

1715

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plcpstrm(JNIEnv *jenv, jclass jcls, jint jarg1, jboolean jarg2) {

1716

PLINT arg1 ;

1717

PLBOOL arg2 ;

1718

1719

(void)jenv;

1720

(void)jcls;

1721

arg1 = (PLINT)jarg1;

1722

arg2 = jarg2 ? 1 : 0;

1723

plcpstrm(arg1,arg2);

1724

1546

1725

}

1547

1726

1548

1727

1549

1728

#define _doc_plend "End a plotting session for all open streams."

1550

1729

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plend(JNIEnv *jenv, jclass jcls) {

1551

(void)jenv;

1552

(void)jcls;

1553

plend();

1554

1730

(void)jenv;

1731

(void)jcls;

1732

plend();

1733

1555

1734

}

1556

1735

1557

1736

1558

1737

#define _doc_plend1 "End a plotting session for the current stream only."

1559

1738

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plend1(JNIEnv *jenv, jclass jcls) {

1560

(void)jenv;

1561

(void)jcls;

1562

plend1();

1563

1739

(void)jenv;

1740

(void)jcls;

1741

plend1();

1742

1564

1743

}

1565

1744

1566

1745

1567

1746

#define _doc_plenv "Simple interface for defining viewport and window."

1568

1747

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plenv(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {

1569

PLFLT arg1 ;

1570

PLFLT arg2 ;

1571

PLFLT arg3 ;

1572

PLFLT arg4 ;

1573

PLINT arg5 ;

1574

PLINT arg6 ;

1575

1576

(void)jenv;

1577

(void)jcls;

1578

arg1 = (PLFLT)jarg1;

1579

arg2 = (PLFLT)jarg2;

1580

arg3 = (PLFLT)jarg3;

1581

arg4 = (PLFLT)jarg4;

1582

arg5 = (PLINT)jarg5;

1583

arg6 = (PLINT)jarg6;

1584

plenv(arg1,arg2,arg3,arg4,arg5,arg6);

1585

1748

PLFLT arg1 ;

1749

PLFLT arg2 ;

1750

PLFLT arg3 ;

1751

PLFLT arg4 ;

1752

PLINT arg5 ;

1753

PLINT arg6 ;

1754

1755

(void)jenv;

1756

(void)jcls;

1757

arg1 = (PLFLT)jarg1;

1758

arg2 = (PLFLT)jarg2;

1759

arg3 = (PLFLT)jarg3;

1760

arg4 = (PLFLT)jarg4;

1761

arg5 = (PLINT)jarg5;

1762

arg6 = (PLINT)jarg6;

1763

plenv(arg1,arg2,arg3,arg4,arg5,arg6);

1764

1586

1765

}

1587

1766

1588

1767

1589

1768

#define _doc_pleop "End current page. Should only be used with plbop()."

1590

1769

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pleop(JNIEnv *jenv, jclass jcls) {

1591

(void)jenv;

1592

(void)jcls;

1593

pleop();

1594

1770

(void)jenv;

1771

(void)jcls;

1772

pleop();

1773

1595

1774

}

1596

1775

1597

1776

1598

1777

#define _doc_plerrx "Plot horizontal error bars (xmin(i),y(i)) to (xmax(i),y(i))."

1599

1778

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plerrx(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {

1600

PLINT arg1 ;

1601

PLFLT *arg2 = (PLFLT *) 0 ;

1602

PLFLT *arg3 = (PLFLT *) 0 ;

1603

PLFLT *arg4 = (PLFLT *) 0 ;

1604

1605

(void)jenv;

1606

(void)jcls;

1607

{

1608

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1609

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1610

Alen = arg1;

1611

setup_array_1d_d( &arg2, jxdata, Alen );

1612

/* Could find no easy way to do this as part of freearg so I modified

1613

* the previous function so it ALWAYS mallocs and copies so that

1614

* the java array can be released immediately. */

1615

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1616

}

1617

{

1618

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1619

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1620

printf("Vectors must be same length.\n");

1621

return;

1622

}

1623

setup_array_1d_d( &arg3, jydata, Alen );

1624

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1625

}

1626

{

1627

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

1628

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

1629

printf("Vectors must be same length.\n");

1630

return;

1631

}

1632

setup_array_1d_d( &arg4, jydata, Alen );

1633

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

1634

}

1635

plerrx(arg1,arg2,arg3,arg4);

1636

1637

{

1638

free(arg2);

1639

}

1640

{

1641

free(arg3);

1642

}

1643

{

1644

free(arg4);

1645

}

1779

PLINT arg1 ;

1780

PLFLT *arg2 = (PLFLT *) 0 ;

1781

PLFLT *arg3 = (PLFLT *) 0 ;

1782

PLFLT *arg4 = (PLFLT *) 0 ;

1783

1784

(void)jenv;

1785

(void)jcls;

1786

{

1787

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1788

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1789

Alen = arg1;

1790

setup_array_1d_d( &arg2, jxdata, Alen );

1791

/* Could find no easy way to do this as part of freearg so I modified

1792

* the previous function so it ALWAYS mallocs and copies so that

1793

* the java array can be released immediately. */

1794

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1795

}

1796

{

1797

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1798

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1799

printf("Vectors must be same length.\n");

1800

return;

1801

}

1802

setup_array_1d_d( &arg3, jydata, Alen );

1803

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1804

}

1805

{

1806

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

1807

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

1808

printf("Vectors must be same length.\n");

1809

return;

1810

}

1811

setup_array_1d_d( &arg4, jydata, Alen );

1812

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

1813

}

1814

plerrx(arg1,arg2,arg3,arg4);

1815

1816

{

1817

free(arg2);

1818

}

1819

{

1820

free(arg3);

1821

}

1822

{

1823

free(arg4);

1824

}

1646

1825

}

1647

1826

1648

1827

1649

1828

#define _doc_plerry "Plot vertical error bars (x,ymin(i)) to (x(i),ymax(i))."

1650

1829

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plerry(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {

1651

PLINT arg1 ;

1652

PLFLT *arg2 = (PLFLT *) 0 ;

1653

PLFLT *arg3 = (PLFLT *) 0 ;

1654

PLFLT *arg4 = (PLFLT *) 0 ;

1655

1656

(void)jenv;

1657

(void)jcls;

1658

{

1659

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1660

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1661

Alen = arg1;

1662

setup_array_1d_d( &arg2, jxdata, Alen );

1663

/* Could find no easy way to do this as part of freearg so I modified

1664

* the previous function so it ALWAYS mallocs and copies so that

1665

* the java array can be released immediately. */

1666

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1667

}

1668

{

1669

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1670

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1671

printf("Vectors must be same length.\n");

1672

return;

1673

}

1674

setup_array_1d_d( &arg3, jydata, Alen );

1675

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1676

}

1677

{

1678

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

1679

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

1680

printf("Vectors must be same length.\n");

1681

return;

1682

}

1683

setup_array_1d_d( &arg4, jydata, Alen );

1684

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

1685

}

1686

plerry(arg1,arg2,arg3,arg4);

1687

1688

{

1689

free(arg2);

1690

}

1691

{

1692

free(arg3);

1693

}

1694

{

1695

free(arg4);

1696

}

1830

PLINT arg1 ;

1831

PLFLT *arg2 = (PLFLT *) 0 ;

1832

PLFLT *arg3 = (PLFLT *) 0 ;

1833

PLFLT *arg4 = (PLFLT *) 0 ;

1834

1835

(void)jenv;

1836

(void)jcls;

1837

{

1838

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1839

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1840

Alen = arg1;

1841

setup_array_1d_d( &arg2, jxdata, Alen );

1842

/* Could find no easy way to do this as part of freearg so I modified

1843

* the previous function so it ALWAYS mallocs and copies so that

1844

* the java array can be released immediately. */

1845

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1846

}

1847

{

1848

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1849

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1850

printf("Vectors must be same length.\n");

1851

return;

1852

}

1853

setup_array_1d_d( &arg3, jydata, Alen );

1854

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1855

}

1856

{

1857

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

1858

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

1859

printf("Vectors must be same length.\n");

1860

return;

1861

}

1862

setup_array_1d_d( &arg4, jydata, Alen );

1863

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

1864

}

1865

plerry(arg1,arg2,arg3,arg4);

1866

1867

{

1868

free(arg2);

1869

}

1870

{

1871

free(arg3);

1872

}

1873

{

1874

free(arg4);

1875

}

1697

1876

}

1698

1877

1699

1878

1700

1879

#define _doc_plfamadv "Advance to the next family file on the next new page."

1701

1880

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfamadv(JNIEnv *jenv, jclass jcls) {

1702

(void)jenv;

1703

(void)jcls;

1704

plfamadv();

1705

1881

(void)jenv;

1882

(void)jcls;

1883

plfamadv();

1884

1706

1885

}

1707

1886

1708

1887

1709

1888

#define _doc_plfill "Pattern fills the polygon bounded by the input points."

1710

1889

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfill(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3) {

1711

PLINT arg1 ;

1712

PLFLT *arg2 = (PLFLT *) 0 ;

1713

PLFLT *arg3 = (PLFLT *) 0 ;

1714

1715

(void)jenv;

1716

(void)jcls;

1717

{

1718

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1719

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1720

Alen = arg1;

1721

setup_array_1d_d( &arg2, jxdata, Alen );

1722

/* Could find no easy way to do this as part of freearg so I modified

1723

* the previous function so it ALWAYS mallocs and copies so that

1724

* the java array can be released immediately. */

1725

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1726

}

1727

{

1728

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1729

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1730

printf("Vectors must be same length.\n");

1731

return;

1732

}

1733

setup_array_1d_d( &arg3, jydata, Alen );

1734

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1735

}

1736

plfill(arg1,arg2,arg3);

1737

1738

{

1739

free(arg2);

1740

}

1741

{

1742

free(arg3);

1743

}

1890

PLINT arg1 ;

1891

PLFLT *arg2 = (PLFLT *) 0 ;

1892

PLFLT *arg3 = (PLFLT *) 0 ;

1893

1894

(void)jenv;

1895

(void)jcls;

1896

{

1897

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1898

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1899

Alen = arg1;

1900

setup_array_1d_d( &arg2, jxdata, Alen );

1901

/* Could find no easy way to do this as part of freearg so I modified

1902

* the previous function so it ALWAYS mallocs and copies so that

1903

* the java array can be released immediately. */

1904

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1905

}

1906

{

1907

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1908

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1909

printf("Vectors must be same length.\n");

1910

return;

1911

}

1912

setup_array_1d_d( &arg3, jydata, Alen );

1913

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1914

}

1915

plfill(arg1,arg2,arg3);

1916

1917

{

1918

free(arg2);

1919

}

1920

{

1921

free(arg3);

1922

}

1744

1923

}

1745

1924

1746

1925

1747

1926

#define _doc_plfill3 "Pattern fills the 3d polygon bounded by the input points."

1748

1927

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfill3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {

1749

PLINT arg1 ;

1750

PLFLT *arg2 = (PLFLT *) 0 ;

1751

PLFLT *arg3 = (PLFLT *) 0 ;

1752

PLFLT *arg4 = (PLFLT *) 0 ;

1753

1754

(void)jenv;

1755

(void)jcls;

1756

{

1757

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1758

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1759

Alen = arg1;

1760

setup_array_1d_d( &arg2, jxdata, Alen );

1761

/* Could find no easy way to do this as part of freearg so I modified

1762

* the previous function so it ALWAYS mallocs and copies so that

1763

* the java array can be released immediately. */

1764

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1765

}

1766

{

1767

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1768

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1769

printf("Vectors must be same length.\n");

1770

return;

1771

}

1772

setup_array_1d_d( &arg3, jydata, Alen );

1773

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1774

}

1775

{

1776

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

1777

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

1778

printf("Vectors must be same length.\n");

1779

return;

1780

}

1781

setup_array_1d_d( &arg4, jydata, Alen );

1782

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

1783

}

1784

plfill3(arg1,arg2,arg3,arg4);

1785

1786

{

1787

free(arg2);

1788

}

1789

{

1790

free(arg3);

1791

}

1792

{

1793

free(arg4);

1794

}

1928

PLINT arg1 ;

1929

PLFLT *arg2 = (PLFLT *) 0 ;

1930

PLFLT *arg3 = (PLFLT *) 0 ;

1931

PLFLT *arg4 = (PLFLT *) 0 ;

1932

1933

(void)jenv;

1934

(void)jcls;

1935

{

1936

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

1937

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

1938

Alen = arg1;

1939

setup_array_1d_d( &arg2, jxdata, Alen );

1940

/* Could find no easy way to do this as part of freearg so I modified

1941

* the previous function so it ALWAYS mallocs and copies so that

1942

* the java array can be released immediately. */

1943

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

1944

}

1945

{

1946

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

1947

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

1948

printf("Vectors must be same length.\n");

1949

return;

1950

}

1951

setup_array_1d_d( &arg3, jydata, Alen );

1952

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

1953

}

1954

{

1955

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

1956

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

1957

printf("Vectors must be same length.\n");

1958

return;

1959

}

1960

setup_array_1d_d( &arg4, jydata, Alen );

1961

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

1962

}

1963

plfill3(arg1,arg2,arg3,arg4);

1964

1965

{

1966

free(arg2);

1967

}

1968

{

1969

free(arg3);

1970

}

1971

{

1972

free(arg4);

1973

}

1795

1974

}

1796

1975

1797

1976

1798

1977

#define _doc_plflush "Flush the output stream. Use sparingly, if at all."

1799

1978

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plflush(JNIEnv *jenv, jclass jcls) {

1800

(void)jenv;

1801

(void)jcls;

1802

plflush();

1803

1979

(void)jenv;

1980

(void)jcls;

1981

plflush();

1982

1804

1983

}

1805

1984

1806

1985

1807

1986

#define _doc_plfont "Set the global font flag to 'ifont'."

1808

1987

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfont(JNIEnv *jenv, jclass jcls, jint jarg1) {

1809

PLINT arg1 ;

1810

1811

(void)jenv;

1812

(void)jcls;

1813

arg1 = (PLINT)jarg1;

1814

plfont(arg1);

1815

1988

PLINT arg1 ;

1989

1990

(void)jenv;

1991

(void)jcls;

1992

arg1 = (PLINT)jarg1;

1993

plfont(arg1);

1994

1816

1995

}

1817

1996

1818

1997

1819

1998

#define _doc_plfontld "Load specified font set."

1820

1999

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plfontld(JNIEnv *jenv, jclass jcls, jint jarg1) {

1821

PLINT arg1 ;

1822

1823

(void)jenv;

1824

(void)jcls;

1825

arg1 = (PLINT)jarg1;

1826

plfontld(arg1);

1827

2000

PLINT arg1 ;

2001

2002

(void)jenv;

2003

(void)jcls;

2004

arg1 = (PLINT)jarg1;

2005

plfontld(arg1);

2006

1828

2007

}

1829

2008

1830

2009

1831

2010

#define _doc_plgchr "Get character default height and current (scaled) height."

1832

2011

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgchr(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2) {

1833

PLFLT *arg1 = (PLFLT *) 0 ;

1834

PLFLT *arg2 = (PLFLT *) 0 ;

1835

PLFLT temp1 ;

1836

PLFLT temp2 ;

1837

1838

(void)jenv;

1839

(void)jcls;

1840

{

1841

if (!jarg1) {

1842

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1843

return ;

1844

}

1845

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

1846

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1847

return ;

1848

}

1849

arg1 = &temp1;

1850

}

1851

{

1852

if (!jarg2) {

1853

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1854

return ;

1855

}

1856

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

1857

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1858

return ;

1859

}

1860

arg2 = &temp2;

1861

}

1862

plgchr(arg1,arg2);

1863

1864

{

1865

jdouble jvalue = (jdouble)temp1;

1866

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

1867

}

1868

{

1869

jdouble jvalue = (jdouble)temp2;

1870

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

1871

}

2012

PLFLT *arg1 = (PLFLT *) 0 ;

2013

PLFLT *arg2 = (PLFLT *) 0 ;

2014

PLFLT temp1 ;

2015

PLFLT temp2 ;

2016

2017

(void)jenv;

2018

(void)jcls;

2019

{

2020

if (!jarg1) {

2021

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2022

return ;

2023

}

2024

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2025

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2026

return ;

2027

}

2028

arg1 = &temp1;

2029

}

2030

{

2031

if (!jarg2) {

2032

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2033

return ;

2034

}

2035

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2036

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2037

return ;

2038

}

2039

arg2 = &temp2;

2040

}

2041

plgchr(arg1,arg2);

2042

2043

{

2044

jdouble jvalue = (jdouble)temp1;

2045

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2046

}

2047

{

2048

jdouble jvalue = (jdouble)temp2;

2049

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2050

}

2051

2052

1872

2053

}

1873

2054

1874

2055

1875

2056

#define _doc_plgcol0 "Get 8 bit RGB values for given color from color map 0."

1876

2057

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcol0(JNIEnv *jenv, jclass jcls, jint jarg1, jintArray jarg2, jintArray jarg3, jintArray jarg4) {

1877

PLINT arg1 ;

1878

PLINT *arg2 = (PLINT *) 0 ;

1879

PLINT *arg3 = (PLINT *) 0 ;

1880

PLINT *arg4 = (PLINT *) 0 ;

1881

PLINT temp2 ;

1882

PLINT temp3 ;

1883

PLINT temp4 ;

1884

1885

(void)jenv;

1886

(void)jcls;

1887

arg1 = (PLINT)jarg1;

1888

{

1889

if (!jarg2) {

1890

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1891

return ;

1892

}

1893

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

1894

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1895

return ;

1896

}

1897

arg2 = &temp2;

1898

}

1899

{

1900

if (!jarg3) {

1901

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1902

return ;

1903

}

1904

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

1905

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1906

return ;

1907

}

1908

arg3 = &temp3;

1909

}

1910

{

1911

if (!jarg4) {

1912

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1913

return ;

1914

}

1915

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

1916

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1917

return ;

1918

}

1919

arg4 = &temp4;

1920

}

1921

plgcol0(arg1,arg2,arg3,arg4);

1922

1923

{

1924

jint jvalue = (jint)temp2;

1925

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

1926

}

1927

{

1928

jint jvalue = (jint)temp3;

1929

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

1930

}

1931

{

1932

jint jvalue = (jint)temp4;

1933

(*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);

1934

}

2058

PLINT arg1 ;

2059

PLINT *arg2 = (PLINT *) 0 ;

2060

PLINT *arg3 = (PLINT *) 0 ;

2061

PLINT *arg4 = (PLINT *) 0 ;

2062

PLINT temp2 ;

2063

PLINT temp3 ;

2064

PLINT temp4 ;

2065

2066

(void)jenv;

2067

(void)jcls;

2068

arg1 = (PLINT)jarg1;

2069

{

2070

if (!jarg2) {

2071

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2072

return ;

2073

}

2074

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2075

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2076

return ;

2077

}

2078

arg2 = &temp2;

2079

}

2080

{

2081

if (!jarg3) {

2082

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2083

return ;

2084

}

2085

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2086

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2087

return ;

2088

}

2089

arg3 = &temp3;

2090

}

2091

{

2092

if (!jarg4) {

2093

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2094

return ;

2095

}

2096

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2097

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2098

return ;

2099

}

2100

arg4 = &temp4;

2101

}

2102

plgcol0(arg1,arg2,arg3,arg4);

2103

2104

{

2105

jint jvalue = (jint)temp2;

2106

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2107

}

2108

{

2109

jint jvalue = (jint)temp3;

2110

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2111

}

2112

{

2113

jint jvalue = (jint)temp4;

2114

(*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2115

}

2116

2117

2118

1935

2119

}

1936

2120

1937

2121

1938

2122

#define _doc_plgcolbg "Get 8-bit RGB background color."

1939

2123

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcolbg(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {

1940

PLINT *arg1 = (PLINT *) 0 ;

1941

PLINT *arg2 = (PLINT *) 0 ;

1942

PLINT *arg3 = (PLINT *) 0 ;

1943

PLINT temp1 ;

1944

PLINT temp2 ;

1945

PLINT temp3 ;

1946

1947

(void)jenv;

1948

(void)jcls;

1949

{

1950

if (!jarg1) {

1951

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1952

return ;

1953

}

1954

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

1955

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1956

return ;

1957

}

1958

arg1 = &temp1;

1959

}

1960

{

1961

if (!jarg2) {

1962

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1963

return ;

1964

}

1965

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

1966

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1967

return ;

1968

}

1969

arg2 = &temp2;

1970

}

1971

{

1972

if (!jarg3) {

1973

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

1974

return ;

1975

}

1976

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

1977

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

1978

return ;

1979

}

1980

arg3 = &temp3;

1981

}

1982

plgcolbg(arg1,arg2,arg3);

1983

1984

{

1985

jint jvalue = (jint)temp1;

1986

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

1987

}

1988

{

1989

jint jvalue = (jint)temp2;

1990

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

1991

}

1992

{

1993

jint jvalue = (jint)temp3;

1994

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

1995

}

2124

PLINT *arg1 = (PLINT *) 0 ;

2125

PLINT *arg2 = (PLINT *) 0 ;

2126

PLINT *arg3 = (PLINT *) 0 ;

2127

PLINT temp1 ;

2128

PLINT temp2 ;

2129

PLINT temp3 ;

2130

2131

(void)jenv;

2132

(void)jcls;

2133

{

2134

if (!jarg1) {

2135

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2136

return ;

2137

}

2138

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2139

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2140

return ;

2141

}

2142

arg1 = &temp1;

2143

}

2144

{

2145

if (!jarg2) {

2146

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2147

return ;

2148

}

2149

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2150

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2151

return ;

2152

}

2153

arg2 = &temp2;

2154

}

2155

{

2156

if (!jarg3) {

2157

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2158

return ;

2159

}

2160

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2161

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2162

return ;

2163

}

2164

arg3 = &temp3;

2165

}

2166

plgcolbg(arg1,arg2,arg3);

2167

2168

{

2169

jint jvalue = (jint)temp1;

2170

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2171

}

2172

{

2173

jint jvalue = (jint)temp2;

2174

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2175

}

2176

{

2177

jint jvalue = (jint)temp3;

2178

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2179

}

2180

2181

2182

1996

2183

}

1997

2184

1998

2185

1999

2186

#define _doc_plgcompression "Get the current compression setting."

2000

2187

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgcompression(JNIEnv *jenv, jclass jcls, jintArray jarg1) {

2001

PLINT *arg1 = (PLINT *) 0 ;

2002

PLINT temp1 ;

2003

2004

(void)jenv;

2005

(void)jcls;

2006

{

2007

if (!jarg1) {

2008

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2009

return ;

2010

}

2011

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2012

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2013

return ;

2014

}

2015

arg1 = &temp1;

2016

}

2017

plgcompression(arg1);

2018

2019

{

2020

jint jvalue = (jint)temp1;

2021

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2022

}

2188

PLINT *arg1 = (PLINT *) 0 ;

2189

PLINT temp1 ;

2190

2191

(void)jenv;

2192

(void)jcls;

2193

{

2194

if (!jarg1) {

2195

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2196

return ;

2197

}

2198

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2199

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2200

return ;

2201

}

2202

arg1 = &temp1;

2203

}

2204

plgcompression(arg1);

2205

2206

{

2207

jint jvalue = (jint)temp1;

2208

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2209

}

2210

2023

2211

}

2024

2212

2025

2213

2026

2214

#define _doc_plgdev "Get the current device (keyword) name."

2027

2215

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdev(JNIEnv *jenv, jclass jcls, jobject jarg1) {

2028

char *arg1 ;

2029

2030

(void)jenv;

2031

(void)jcls;

2032

{

2033

arg1 = NULL;

2034

if(jarg1 != NULL) {

2035

/* Get the String from the StringBuffer */

2036

jmethodID setLengthID;

2037

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2038

jmethodID toStringID = (*jenv)->GetMethodID(jenv, sbufClass, "toString", "()Ljava/lang/String;");

2039

jstring js = (jstring) (*jenv)->CallObjectMethod(jenv, jarg1, toStringID);

2040

2041

/* Convert the String to a C string */

2042

const char *pCharStr = (*jenv)->GetStringUTFChars(jenv, js, 0);

2043

2044

/* Take a copy of the C string as the typemap is for a non const C string */

2045

jmethodID capacityID = (*jenv)->GetMethodID(jenv, sbufClass, "capacity", "()I");

2046

jint capacity = (*jenv)->CallIntMethod(jenv, jarg1, capacityID);

2047

arg1 = (char *) malloc(capacity+1);

2048

strcpy(arg1, pCharStr);

2049

2050

/* Release the UTF string we obtained with GetStringUTFChars */

2051

(*jenv)->ReleaseStringUTFChars(jenv, js, pCharStr);

2052

2053

/* Zero the original StringBuffer, so we can replace it with the result */

2054

setLengthID = (*jenv)->GetMethodID(jenv, sbufClass, "setLength", "(I)V");

2055

(*jenv)->CallVoidMethod(jenv, jarg1, setLengthID, (jint) 0);

2056

}

2057

}

2058

plgdev(arg1);

2059

2060

{

2061

if(arg1 != NULL) {

2062

/* Append the result to the empty StringBuffer */

2063

jstring newString = (*jenv)->NewStringUTF(jenv, arg1);

2064

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2065

jmethodID appendStringID = (*jenv)->GetMethodID(jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

2066

(*jenv)->CallObjectMethod(jenv, jarg1, appendStringID, newString);

2067

2068

/* Clean up the string object, no longer needed */

2069

free(arg1);

2070

arg1 = NULL;

2071

}

2072

}

2073

2216

char *arg1 = (char *) 0 ;

2217

2218

(void)jenv;

2219

(void)jcls;

2220

{

2221

arg1 = NULL;

2222

if(jarg1 != NULL) {

2223

/* Get the String from the StringBuffer */

2224

jmethodID setLengthID;

2225

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2226

/* Take a copy of the C string as the typemap is for a non const C string */

2227

jmethodID capacityID = (*jenv)->GetMethodID(jenv, sbufClass, "capacity", "()I");

2228

jint capacity = (*jenv)->CallIntMethod(jenv, jarg1, capacityID);

2229

arg1 = (char *) malloc(capacity+1);

2230

2231

/* Zero the original StringBuffer, so we can replace it with the result */

2232

setLengthID = (*jenv)->GetMethodID(jenv, sbufClass, "setLength", "(I)V");

2233

(*jenv)->CallVoidMethod(jenv, jarg1, setLengthID, (jint) 0);

2234

}

2235

}

2236

plgdev(arg1);

2237

2238

{

2239

if(arg1 != NULL) {

2240

/* Append the result to the empty StringBuffer */

2241

jstring newString = (*jenv)->NewStringUTF(jenv, arg1);

2242

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2243

jmethodID appendStringID = (*jenv)->GetMethodID(jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

2244

(*jenv)->CallObjectMethod(jenv, jarg1, appendStringID, newString);

2245

2246

/* Clean up the string object, no longer needed */

2247

free(arg1);

2248

arg1 = NULL;

2249

}

2250

}

2251

2074

2252

}

2075

2253

2076

2254

2077

2255

#define _doc_plgdidev "Retrieve current window into device space."

2078

2256

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdidev(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {

2079

PLFLT *arg1 = (PLFLT *) 0 ;

2080

PLFLT *arg2 = (PLFLT *) 0 ;

2081

PLFLT *arg3 = (PLFLT *) 0 ;

2082

PLFLT *arg4 = (PLFLT *) 0 ;

2083

PLFLT temp1 ;

2084

PLFLT temp2 ;

2085

PLFLT temp3 ;

2086

PLFLT temp4 ;

2087

2088

(void)jenv;

2089

(void)jcls;

2090

{

2091

if (!jarg1) {

2092

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2093

return ;

2094

}

2095

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2096

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2097

return ;

2098

}

2099

arg1 = &temp1;

2100

}

2101

{

2102

if (!jarg2) {

2103

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2104

return ;

2105

}

2106

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2107

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2108

return ;

2109

}

2110

arg2 = &temp2;

2111

}

2112

{

2113

if (!jarg3) {

2114

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2115

return ;

2116

}

2117

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2118

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2119

return ;

2120

}

2121

arg3 = &temp3;

2122

}

2123

{

2124

if (!jarg4) {

2125

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2126

return ;

2127

}

2128

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2129

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2130

return ;

2131

}

2132

arg4 = &temp4;

2133

}

2134

plgdidev(arg1,arg2,arg3,arg4);

2135

2136

{

2137

jdouble jvalue = (jdouble)temp1;

2138

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2139

}

2140

{

2141

jdouble jvalue = (jdouble)temp2;

2142

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2143

}

2144

{

2145

jdouble jvalue = (jdouble)temp3;

2146

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2147

}

2148

{

2149

jdouble jvalue = (jdouble)temp4;

2150

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2151

}

2257

PLFLT *arg1 = (PLFLT *) 0 ;

2258

PLFLT *arg2 = (PLFLT *) 0 ;

2259

PLFLT *arg3 = (PLFLT *) 0 ;

2260

PLFLT *arg4 = (PLFLT *) 0 ;

2261

PLFLT temp1 ;

2262

PLFLT temp2 ;

2263

PLFLT temp3 ;

2264

PLFLT temp4 ;

2265

2266

(void)jenv;

2267

(void)jcls;

2268

{

2269

if (!jarg1) {

2270

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2271

return ;

2272

}

2273

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2274

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2275

return ;

2276

}

2277

arg1 = &temp1;

2278

}

2279

{

2280

if (!jarg2) {

2281

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2282

return ;

2283

}

2284

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2285

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2286

return ;

2287

}

2288

arg2 = &temp2;

2289

}

2290

{

2291

if (!jarg3) {

2292

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2293

return ;

2294

}

2295

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2296

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2297

return ;

2298

}

2299

arg3 = &temp3;

2300

}

2301

{

2302

if (!jarg4) {

2303

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2304

return ;

2305

}

2306

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2307

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2308

return ;

2309

}

2310

arg4 = &temp4;

2311

}

2312

plgdidev(arg1,arg2,arg3,arg4);

2313

2314

{

2315

jdouble jvalue = (jdouble)temp1;

2316

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2317

}

2318

{

2319

jdouble jvalue = (jdouble)temp2;

2320

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2321

}

2322

{

2323

jdouble jvalue = (jdouble)temp3;

2324

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2325

}

2326

{

2327

jdouble jvalue = (jdouble)temp4;

2328

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2329

}

2330

2331

2332

2333

2152

2334

}

2153

2335

2154

2336

2155

2337

#define _doc_plgdiori "Get plot orientation."

2156

2338

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdiori(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1) {

2157

PLFLT *arg1 = (PLFLT *) 0 ;

2158

PLFLT temp1 ;

2159

2160

(void)jenv;

2161

(void)jcls;

2162

{

2163

if (!jarg1) {

2164

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2165

return ;

2166

}

2167

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2168

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2169

return ;

2170

}

2171

arg1 = &temp1;

2172

}

2173

plgdiori(arg1);

2174

2175

{

2176

jdouble jvalue = (jdouble)temp1;

2177

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2178

}

2339

PLFLT *arg1 = (PLFLT *) 0 ;

2340

PLFLT temp1 ;

2341

2342

(void)jenv;

2343

(void)jcls;

2344

{

2345

if (!jarg1) {

2346

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2347

return ;

2348

}

2349

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2350

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2351

return ;

2352

}

2353

arg1 = &temp1;

2354

}

2355

plgdiori(arg1);

2356

2357

{

2358

jdouble jvalue = (jdouble)temp1;

2359

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2360

}

2361

2179

2362

}

2180

2363

2181

2364

2182

2365

#define _doc_plgdiplt "Retrieve current window into plot space."

2183

2366

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgdiplt(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {

2184

PLFLT *arg1 = (PLFLT *) 0 ;

2185

PLFLT *arg2 = (PLFLT *) 0 ;

2186

PLFLT *arg3 = (PLFLT *) 0 ;

2187

PLFLT *arg4 = (PLFLT *) 0 ;

2188

PLFLT temp1 ;

2189

PLFLT temp2 ;

2190

PLFLT temp3 ;

2191

PLFLT temp4 ;

2192

2193

(void)jenv;

2194

(void)jcls;

2195

{

2196

if (!jarg1) {

2197

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2198

return ;

2199

}

2200

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2201

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2202

return ;

2203

}

2204

arg1 = &temp1;

2205

}

2206

{

2207

if (!jarg2) {

2208

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2209

return ;

2210

}

2211

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2212

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2213

return ;

2214

}

2215

arg2 = &temp2;

2216

}

2217

{

2218

if (!jarg3) {

2219

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2220

return ;

2221

}

2222

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2223

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2224

return ;

2225

}

2226

arg3 = &temp3;

2227

}

2228

{

2229

if (!jarg4) {

2230

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2231

return ;

2232

}

2233

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2234

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2235

return ;

2236

}

2237

arg4 = &temp4;

2238

}

2239

plgdiplt(arg1,arg2,arg3,arg4);

2240

2241

{

2242

jdouble jvalue = (jdouble)temp1;

2243

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2244

}

2245

{

2246

jdouble jvalue = (jdouble)temp2;

2247

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2248

}

2249

{

2250

jdouble jvalue = (jdouble)temp3;

2251

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2252

}

2253

{

2254

jdouble jvalue = (jdouble)temp4;

2255

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2256

}

2367

PLFLT *arg1 = (PLFLT *) 0 ;

2368

PLFLT *arg2 = (PLFLT *) 0 ;

2369

PLFLT *arg3 = (PLFLT *) 0 ;

2370

PLFLT *arg4 = (PLFLT *) 0 ;

2371

PLFLT temp1 ;

2372

PLFLT temp2 ;

2373

PLFLT temp3 ;

2374

PLFLT temp4 ;

2375

2376

(void)jenv;

2377

(void)jcls;

2378

{

2379

if (!jarg1) {

2380

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2381

return ;

2382

}

2383

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2384

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2385

return ;

2386

}

2387

arg1 = &temp1;

2388

}

2389

{

2390

if (!jarg2) {

2391

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2392

return ;

2393

}

2394

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2395

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2396

return ;

2397

}

2398

arg2 = &temp2;

2399

}

2400

{

2401

if (!jarg3) {

2402

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2403

return ;

2404

}

2405

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2406

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2407

return ;

2408

}

2409

arg3 = &temp3;

2410

}

2411

{

2412

if (!jarg4) {

2413

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2414

return ;

2415

}

2416

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2417

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2418

return ;

2419

}

2420

arg4 = &temp4;

2421

}

2422

plgdiplt(arg1,arg2,arg3,arg4);

2423

2424

{

2425

jdouble jvalue = (jdouble)temp1;

2426

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2427

}

2428

{

2429

jdouble jvalue = (jdouble)temp2;

2430

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2431

}

2432

{

2433

jdouble jvalue = (jdouble)temp3;

2434

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2435

}

2436

{

2437

jdouble jvalue = (jdouble)temp4;

2438

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2439

}

2440

2441

2442

2443

2257

2444

}

2258

2445

2259

2446

2260

2447

#define _doc_plgfam "Get family file parameters."

2261

2448

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfam(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {

2262

PLINT *arg1 = (PLINT *) 0 ;

2263

PLINT *arg2 = (PLINT *) 0 ;

2264

PLINT *arg3 = (PLINT *) 0 ;

2265

PLINT temp1 ;

2266

PLINT temp2 ;

2267

PLINT temp3 ;

2268

2269

(void)jenv;

2270

(void)jcls;

2271

{

2272

if (!jarg1) {

2273

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2274

return ;

2275

}

2276

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2277

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2278

return ;

2279

}

2280

arg1 = &temp1;

2281

}

2282

{

2283

if (!jarg2) {

2284

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2285

return ;

2286

}

2287

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2288

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2289

return ;

2290

}

2291

arg2 = &temp2;

2292

}

2293

{

2294

if (!jarg3) {

2295

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2296

return ;

2297

}

2298

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2299

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2300

return ;

2301

}

2302

arg3 = &temp3;

2303

}

2304

plgfam(arg1,arg2,arg3);

2305

2306

{

2307

jint jvalue = (jint)temp1;

2308

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2309

}

2310

{

2311

jint jvalue = (jint)temp2;

2312

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2313

}

2314

{

2315

jint jvalue = (jint)temp3;

2316

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2317

}

2449

PLINT *arg1 = (PLINT *) 0 ;

2450

PLINT *arg2 = (PLINT *) 0 ;

2451

PLINT *arg3 = (PLINT *) 0 ;

2452

PLINT temp1 ;

2453

PLINT temp2 ;

2454

PLINT temp3 ;

2455

2456

(void)jenv;

2457

(void)jcls;

2458

{

2459

if (!jarg1) {

2460

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2461

return ;

2462

}

2463

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2464

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2465

return ;

2466

}

2467

arg1 = &temp1;

2468

}

2469

{

2470

if (!jarg2) {

2471

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2472

return ;

2473

}

2474

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2475

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2476

return ;

2477

}

2478

arg2 = &temp2;

2479

}

2480

{

2481

if (!jarg3) {

2482

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2483

return ;

2484

}

2485

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2486

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2487

return ;

2488

}

2489

arg3 = &temp3;

2490

}

2491

plgfam(arg1,arg2,arg3);

2492

2493

{

2494

jint jvalue = (jint)temp1;

2495

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2496

}

2497

{

2498

jint jvalue = (jint)temp2;

2499

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2500

}

2501

{

2502

jint jvalue = (jint)temp3;

2503

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2504

}

2505

2506

2507

2508

}

2509

2510

2511

#define _doc_plgfci "Get FCI (font characterization integer)."

2512

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfci(JNIEnv *jenv, jclass jcls, jlongArray jarg1) {

2513

PLUNICODE *arg1 = (PLUNICODE *) 0 ;

2514

PLUNICODE temp1 ;

2515

2516

(void)jenv;

2517

(void)jcls;

2518

{

2519

if (!jarg1) {

2520

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2521

return ;

2522

}

2523

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2524

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2525

return ;

2526

}

2527

arg1 = &temp1;

2528

}

2529

plgfci(arg1);

2530

2531

{

2532

jlong jvalue = (jlong)temp1;

2533

(*jenv)->SetLongArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2534

}

2535

2318

2536

}

2319

2537

2320

2538

2321

2539

#define _doc_plgfnam "Get the (current) output file name."

2322

2540

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgfnam(JNIEnv *jenv, jclass jcls, jobject jarg1) {

2323

char *arg1 ;

2324

2325

(void)jenv;

2326

(void)jcls;

2327

{

2328

arg1 = NULL;

2329

if(jarg1 != NULL) {

2330

/* Get the String from the StringBuffer */

2331

jmethodID setLengthID;

2332

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2333

jmethodID toStringID = (*jenv)->GetMethodID(jenv, sbufClass, "toString", "()Ljava/lang/String;");

2334

jstring js = (jstring) (*jenv)->CallObjectMethod(jenv, jarg1, toStringID);

2335

2336

/* Convert the String to a C string */

2337

const char *pCharStr = (*jenv)->GetStringUTFChars(jenv, js, 0);

2338

2339

/* Take a copy of the C string as the typemap is for a non const C string */

2340

jmethodID capacityID = (*jenv)->GetMethodID(jenv, sbufClass, "capacity", "()I");

2341

jint capacity = (*jenv)->CallIntMethod(jenv, jarg1, capacityID);

2342

arg1 = (char *) malloc(capacity+1);

2343

strcpy(arg1, pCharStr);

2344

2345

/* Release the UTF string we obtained with GetStringUTFChars */

2346

(*jenv)->ReleaseStringUTFChars(jenv, js, pCharStr);

2347

2348

/* Zero the original StringBuffer, so we can replace it with the result */

2349

setLengthID = (*jenv)->GetMethodID(jenv, sbufClass, "setLength", "(I)V");

2350

(*jenv)->CallVoidMethod(jenv, jarg1, setLengthID, (jint) 0);

2351

}

2352

}

2353

plgfnam(arg1);

2354

2355

{

2356

if(arg1 != NULL) {

2357

/* Append the result to the empty StringBuffer */

2358

jstring newString = (*jenv)->NewStringUTF(jenv, arg1);

2359

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2360

jmethodID appendStringID = (*jenv)->GetMethodID(jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

2361

(*jenv)->CallObjectMethod(jenv, jarg1, appendStringID, newString);

2362

2363

/* Clean up the string object, no longer needed */

2364

free(arg1);

2365

arg1 = NULL;

2366

}

2367

}

2368

2541

char *arg1 = (char *) 0 ;

2542

2543

(void)jenv;

2544

(void)jcls;

2545

{

2546

arg1 = NULL;

2547

if(jarg1 != NULL) {

2548

/* Get the String from the StringBuffer */

2549

jmethodID setLengthID;

2550

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2551

/* Take a copy of the C string as the typemap is for a non const C string */

2552

jmethodID capacityID = (*jenv)->GetMethodID(jenv, sbufClass, "capacity", "()I");

2553

jint capacity = (*jenv)->CallIntMethod(jenv, jarg1, capacityID);

2554

arg1 = (char *) malloc(capacity+1);

2555

2556

/* Zero the original StringBuffer, so we can replace it with the result */

2557

setLengthID = (*jenv)->GetMethodID(jenv, sbufClass, "setLength", "(I)V");

2558

(*jenv)->CallVoidMethod(jenv, jarg1, setLengthID, (jint) 0);

2559

}

2560

}

2561

plgfnam(arg1);

2562

2563

{

2564

if(arg1 != NULL) {

2565

/* Append the result to the empty StringBuffer */

2566

jstring newString = (*jenv)->NewStringUTF(jenv, arg1);

2567

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2568

jmethodID appendStringID = (*jenv)->GetMethodID(jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

2569

(*jenv)->CallObjectMethod(jenv, jarg1, appendStringID, newString);

2570

2571

/* Clean up the string object, no longer needed */

2572

free(arg1);

2573

arg1 = NULL;

2574

}

2575

}

2576

2369

2577

}

2370

2578

2371

2579

2372

2580

#define _doc_plglevel "Get the (current) run level."

2373

2581

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plglevel(JNIEnv *jenv, jclass jcls, jintArray jarg1) {

2374

PLINT *arg1 = (PLINT *) 0 ;

2375

PLINT temp1 ;

2376

2377

(void)jenv;

2378

(void)jcls;

2379

{

2380

if (!jarg1) {

2381

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2382

return ;

2383

}

2384

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2385

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2386

return ;

2387

}

2388

arg1 = &temp1;

2389

}

2390

plglevel(arg1);

2391

2392

{

2393

jint jvalue = (jint)temp1;

2394

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2395

}

2582

PLINT *arg1 = (PLINT *) 0 ;

2583

PLINT temp1 ;

2584

2585

(void)jenv;

2586

(void)jcls;

2587

{

2588

if (!jarg1) {

2589

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2590

return ;

2591

}

2592

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2593

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2594

return ;

2595

}

2596

arg1 = &temp1;

2597

}

2598

plglevel(arg1);

2599

2600

{

2601

jint jvalue = (jint)temp1;

2602

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2603

}

2604

2396

2605

}

2397

2606

2398

2607

2399

2608

#define _doc_plgpage "Get output device parameters."

2400

2609

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgpage(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jintArray jarg3, jintArray jarg4, jintArray jarg5, jintArray jarg6) {

2401

PLFLT *arg1 = (PLFLT *) 0 ;

2402

PLFLT *arg2 = (PLFLT *) 0 ;

2403

PLINT *arg3 = (PLINT *) 0 ;

2404

PLINT *arg4 = (PLINT *) 0 ;

2405

PLINT *arg5 = (PLINT *) 0 ;

2406

PLINT *arg6 = (PLINT *) 0 ;

2407

PLFLT temp1 ;

2408

PLFLT temp2 ;

2409

PLINT temp3 ;

2410

PLINT temp4 ;

2411

PLINT temp5 ;

2412

PLINT temp6 ;

2413

2414

(void)jenv;

2415

(void)jcls;

2416

{

2417

if (!jarg1) {

2418

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2419

return ;

2420

}

2421

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2422

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2423

return ;

2424

}

2425

arg1 = &temp1;

2426

}

2427

{

2428

if (!jarg2) {

2429

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2430

return ;

2431

}

2432

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2433

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2434

return ;

2435

}

2436

arg2 = &temp2;

2437

}

2438

{

2439

if (!jarg3) {

2440

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2441

return ;

2442

}

2443

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2444

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2445

return ;

2446

}

2447

arg3 = &temp3;

2448

}

2449

{

2450

if (!jarg4) {

2451

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2452

return ;

2453

}

2454

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2455

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2456

return ;

2457

}

2458

arg4 = &temp4;

2459

}

2460

{

2461

if (!jarg5) {

2462

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2463

return ;

2464

}

2465

if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {

2466

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2467

return ;

2468

}

2469

arg5 = &temp5;

2470

}

2471

{

2472

if (!jarg6) {

2473

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2474

return ;

2475

}

2476

if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {

2477

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2478

return ;

2479

}

2480

arg6 = &temp6;

2481

}

2482

plgpage(arg1,arg2,arg3,arg4,arg5,arg6);

2483

2484

{

2485

jdouble jvalue = (jdouble)temp1;

2486

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2487

}

2488

{

2489

jdouble jvalue = (jdouble)temp2;

2490

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2491

}

2492

{

2493

jint jvalue = (jint)temp3;

2494

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2495

}

2496

{

2497

jint jvalue = (jint)temp4;

2498

(*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2499

}

2500

{

2501

jint jvalue = (jint)temp5;

2502

(*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);

2503

}

2504

{

2505

jint jvalue = (jint)temp6;

2506

(*jenv)->SetIntArrayRegion(jenv, jarg6, 0, 1, &jvalue);

2507

}

2610

PLFLT *arg1 = (PLFLT *) 0 ;

2611

PLFLT *arg2 = (PLFLT *) 0 ;

2612

PLINT *arg3 = (PLINT *) 0 ;

2613

PLINT *arg4 = (PLINT *) 0 ;

2614

PLINT *arg5 = (PLINT *) 0 ;

2615

PLINT *arg6 = (PLINT *) 0 ;

2616

PLFLT temp1 ;

2617

PLFLT temp2 ;

2618

PLINT temp3 ;

2619

PLINT temp4 ;

2620

PLINT temp5 ;

2621

PLINT temp6 ;

2622

2623

(void)jenv;

2624

(void)jcls;

2625

{

2626

if (!jarg1) {

2627

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2628

return ;

2629

}

2630

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2631

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2632

return ;

2633

}

2634

arg1 = &temp1;

2635

}

2636

{

2637

if (!jarg2) {

2638

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2639

return ;

2640

}

2641

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2642

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2643

return ;

2644

}

2645

arg2 = &temp2;

2646

}

2647

{

2648

if (!jarg3) {

2649

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2650

return ;

2651

}

2652

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2653

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2654

return ;

2655

}

2656

arg3 = &temp3;

2657

}

2658

{

2659

if (!jarg4) {

2660

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2661

return ;

2662

}

2663

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2664

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2665

return ;

2666

}

2667

arg4 = &temp4;

2668

}

2669

{

2670

if (!jarg5) {

2671

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2672

return ;

2673

}

2674

if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {

2675

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2676

return ;

2677

}

2678

arg5 = &temp5;

2679

}

2680

{

2681

if (!jarg6) {

2682

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2683

return ;

2684

}

2685

if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {

2686

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2687

return ;

2688

}

2689

arg6 = &temp6;

2690

}

2691

plgpage(arg1,arg2,arg3,arg4,arg5,arg6);

2692

2693

{

2694

jdouble jvalue = (jdouble)temp1;

2695

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2696

}

2697

{

2698

jdouble jvalue = (jdouble)temp2;

2699

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2700

}

2701

{

2702

jint jvalue = (jint)temp3;

2703

(*jenv)->SetIntArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2704

}

2705

{

2706

jint jvalue = (jint)temp4;

2707

(*jenv)->SetIntArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2708

}

2709

{

2710

jint jvalue = (jint)temp5;

2711

(*jenv)->SetIntArrayRegion(jenv, jarg5, 0, 1, &jvalue);

2712

}

2713

{

2714

jint jvalue = (jint)temp6;

2715

(*jenv)->SetIntArrayRegion(jenv, jarg6, 0, 1, &jvalue);

2716

}

2717

2718

2719

2720

2721

2722

2508

2723

}

2509

2724

2510

2725

2511

2726

#define _doc_plgra "Switch to graphics screen."

2512

2727

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgra(JNIEnv *jenv, jclass jcls) {

2513

(void)jenv;

2514

(void)jcls;

2515

plgra();

2516

2728

(void)jenv;

2729

(void)jcls;

2730

plgra();

2731

2517

2732

}

2518

2733

2519

2734

2520

2735

#define _doc_plgspa "Get subpage boundaries in absolute coordinates."

2521

2736

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgspa(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {

2522

PLFLT *arg1 = (PLFLT *) 0 ;

2523

PLFLT *arg2 = (PLFLT *) 0 ;

2524

PLFLT *arg3 = (PLFLT *) 0 ;

2525

PLFLT *arg4 = (PLFLT *) 0 ;

2526

PLFLT temp1 ;

2527

PLFLT temp2 ;

2528

PLFLT temp3 ;

2529

PLFLT temp4 ;

2530

2531

(void)jenv;

2532

(void)jcls;

2533

{

2534

if (!jarg1) {

2535

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2536

return ;

2537

}

2538

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2539

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2540

return ;

2541

}

2542

arg1 = &temp1;

2543

}

2544

{

2545

if (!jarg2) {

2546

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2547

return ;

2548

}

2549

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2550

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2551

return ;

2552

}

2553

arg2 = &temp2;

2554

}

2555

{

2556

if (!jarg3) {

2557

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2558

return ;

2559

}

2560

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2561

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2562

return ;

2563

}

2564

arg3 = &temp3;

2565

}

2566

{

2567

if (!jarg4) {

2568

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2569

return ;

2570

}

2571

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2572

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2573

return ;

2574

}

2575

arg4 = &temp4;

2576

}

2577

plgspa(arg1,arg2,arg3,arg4);

2578

2579

{

2580

jdouble jvalue = (jdouble)temp1;

2581

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2582

}

2583

{

2584

jdouble jvalue = (jdouble)temp2;

2585

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2586

}

2587

{

2588

jdouble jvalue = (jdouble)temp3;

2589

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2590

}

2591

{

2592

jdouble jvalue = (jdouble)temp4;

2593

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2594

}

2737

PLFLT *arg1 = (PLFLT *) 0 ;

2738

PLFLT *arg2 = (PLFLT *) 0 ;

2739

PLFLT *arg3 = (PLFLT *) 0 ;

2740

PLFLT *arg4 = (PLFLT *) 0 ;

2741

PLFLT temp1 ;

2742

PLFLT temp2 ;

2743

PLFLT temp3 ;

2744

PLFLT temp4 ;

2745

2746

(void)jenv;

2747

(void)jcls;

2748

{

2749

if (!jarg1) {

2750

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2751

return ;

2752

}

2753

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2754

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2755

return ;

2756

}

2757

arg1 = &temp1;

2758

}

2759

{

2760

if (!jarg2) {

2761

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2762

return ;

2763

}

2764

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2765

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2766

return ;

2767

}

2768

arg2 = &temp2;

2769

}

2770

{

2771

if (!jarg3) {

2772

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2773

return ;

2774

}

2775

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2776

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2777

return ;

2778

}

2779

arg3 = &temp3;

2780

}

2781

{

2782

if (!jarg4) {

2783

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2784

return ;

2785

}

2786

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2787

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2788

return ;

2789

}

2790

arg4 = &temp4;

2791

}

2792

plgspa(arg1,arg2,arg3,arg4);

2793

2794

{

2795

jdouble jvalue = (jdouble)temp1;

2796

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2797

}

2798

{

2799

jdouble jvalue = (jdouble)temp2;

2800

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2801

}

2802

{

2803

jdouble jvalue = (jdouble)temp3;

2804

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2805

}

2806

{

2807

jdouble jvalue = (jdouble)temp4;

2808

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2809

}

2810

2811

2812

2813

2595

2814

}

2596

2815

2597

2816

2598

2817

#define _doc_plgstrm "Get current stream number."

2599

2818

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgstrm(JNIEnv *jenv, jclass jcls, jintArray jarg1) {

2600

PLINT *arg1 = (PLINT *) 0 ;

2601

PLINT temp1 ;

2602

2603

(void)jenv;

2604

(void)jcls;

2605

{

2606

if (!jarg1) {

2607

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2608

return ;

2609

}

2610

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2611

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2612

return ;

2613

}

2614

arg1 = &temp1;

2615

}

2616

plgstrm(arg1);

2617

2618

{

2619

jint jvalue = (jint)temp1;

2620

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2621

}

2819

PLINT *arg1 = (PLINT *) 0 ;

2820

PLINT temp1 ;

2821

2822

(void)jenv;

2823

(void)jcls;

2824

{

2825

if (!jarg1) {

2826

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2827

return ;

2828

}

2829

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2830

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2831

return ;

2832

}

2833

arg1 = &temp1;

2834

}

2835

plgstrm(arg1);

2836

2837

{

2838

jint jvalue = (jint)temp1;

2839

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2840

}

2841

2622

2842

}

2623

2843

2624

2844

2625

2845

#define _doc_plgver "Get current library version number."

2626

2846

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgver(JNIEnv *jenv, jclass jcls, jobject jarg1) {

2627

char *arg1 ;

2628

2629

(void)jenv;

2630

(void)jcls;

2631

{

2632

arg1 = NULL;

2633

if(jarg1 != NULL) {

2634

/* Get the String from the StringBuffer */

2635

jmethodID setLengthID;

2636

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2637

jmethodID toStringID = (*jenv)->GetMethodID(jenv, sbufClass, "toString", "()Ljava/lang/String;");

2638

jstring js = (jstring) (*jenv)->CallObjectMethod(jenv, jarg1, toStringID);

2639

2640

/* Convert the String to a C string */

2641

const char *pCharStr = (*jenv)->GetStringUTFChars(jenv, js, 0);

2642

2643

/* Take a copy of the C string as the typemap is for a non const C string */

2644

jmethodID capacityID = (*jenv)->GetMethodID(jenv, sbufClass, "capacity", "()I");

2645

jint capacity = (*jenv)->CallIntMethod(jenv, jarg1, capacityID);

2646

arg1 = (char *) malloc(capacity+1);

2647

strcpy(arg1, pCharStr);

2648

2649

/* Release the UTF string we obtained with GetStringUTFChars */

2650

(*jenv)->ReleaseStringUTFChars(jenv, js, pCharStr);

2651

2652

/* Zero the original StringBuffer, so we can replace it with the result */

2653

setLengthID = (*jenv)->GetMethodID(jenv, sbufClass, "setLength", "(I)V");

2654

(*jenv)->CallVoidMethod(jenv, jarg1, setLengthID, (jint) 0);

2655

}

2656

}

2657

plgver(arg1);

2658

2659

{

2660

if(arg1 != NULL) {

2661

/* Append the result to the empty StringBuffer */

2662

jstring newString = (*jenv)->NewStringUTF(jenv, arg1);

2663

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2664

jmethodID appendStringID = (*jenv)->GetMethodID(jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

2665

(*jenv)->CallObjectMethod(jenv, jarg1, appendStringID, newString);

2666

2667

/* Clean up the string object, no longer needed */

2668

free(arg1);

2669

arg1 = NULL;

2670

}

2671

}

2672

2847

char *arg1 = (char *) 0 ;

2848

2849

(void)jenv;

2850

(void)jcls;

2851

{

2852

arg1 = NULL;

2853

if(jarg1 != NULL) {

2854

/* Get the String from the StringBuffer */

2855

jmethodID setLengthID;

2856

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2857

/* Take a copy of the C string as the typemap is for a non const C string */

2858

jmethodID capacityID = (*jenv)->GetMethodID(jenv, sbufClass, "capacity", "()I");

2859

jint capacity = (*jenv)->CallIntMethod(jenv, jarg1, capacityID);

2860

arg1 = (char *) malloc(capacity+1);

2861

2862

/* Zero the original StringBuffer, so we can replace it with the result */

2863

setLengthID = (*jenv)->GetMethodID(jenv, sbufClass, "setLength", "(I)V");

2864

(*jenv)->CallVoidMethod(jenv, jarg1, setLengthID, (jint) 0);

2865

}

2866

}

2867

plgver(arg1);

2868

2869

{

2870

if(arg1 != NULL) {

2871

/* Append the result to the empty StringBuffer */

2872

jstring newString = (*jenv)->NewStringUTF(jenv, arg1);

2873

jclass sbufClass = (*jenv)->GetObjectClass(jenv, jarg1);

2874

jmethodID appendStringID = (*jenv)->GetMethodID(jenv, sbufClass, "append", "(Ljava/lang/String;)Ljava/lang/StringBuffer;");

2875

(*jenv)->CallObjectMethod(jenv, jarg1, appendStringID, newString);

2876

2877

/* Clean up the string object, no longer needed */

2878

free(arg1);

2879

arg1 = NULL;

2880

}

2881

}

2882

2673

2883

}

2674

2884

2675

2885

2676

2886

#define _doc_plgvpd "Get viewport boundaries in normalized device coordinates."

2677

2887

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgvpd(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {

2678

PLFLT *arg1 = (PLFLT *) 0 ;

2679

PLFLT *arg2 = (PLFLT *) 0 ;

2680

PLFLT *arg3 = (PLFLT *) 0 ;

2681

PLFLT *arg4 = (PLFLT *) 0 ;

2682

PLFLT temp1 ;

2683

PLFLT temp2 ;

2684

PLFLT temp3 ;

2685

PLFLT temp4 ;

2686

2687

(void)jenv;

2688

(void)jcls;

2689

{

2690

if (!jarg1) {

2691

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2692

return ;

2693

}

2694

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2695

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2696

return ;

2697

}

2698

arg1 = &temp1;

2699

}

2700

{

2701

if (!jarg2) {

2702

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2703

return ;

2704

}

2705

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2706

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2707

return ;

2708

}

2709

arg2 = &temp2;

2710

}

2711

{

2712

if (!jarg3) {

2713

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2714

return ;

2715

}

2716

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2717

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2718

return ;

2719

}

2720

arg3 = &temp3;

2721

}

2722

{

2723

if (!jarg4) {

2724

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2725

return ;

2726

}

2727

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2728

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2729

return ;

2730

}

2731

arg4 = &temp4;

2732

}

2733

plgvpd(arg1,arg2,arg3,arg4);

2734

2735

{

2736

jdouble jvalue = (jdouble)temp1;

2737

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2738

}

2739

{

2740

jdouble jvalue = (jdouble)temp2;

2741

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2742

}

2743

{

2744

jdouble jvalue = (jdouble)temp3;

2745

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2746

}

2747

{

2748

jdouble jvalue = (jdouble)temp4;

2749

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2750

}

2888

PLFLT *arg1 = (PLFLT *) 0 ;

2889

PLFLT *arg2 = (PLFLT *) 0 ;

2890

PLFLT *arg3 = (PLFLT *) 0 ;

2891

PLFLT *arg4 = (PLFLT *) 0 ;

2892

PLFLT temp1 ;

2893

PLFLT temp2 ;

2894

PLFLT temp3 ;

2895

PLFLT temp4 ;

2896

2897

(void)jenv;

2898

(void)jcls;

2899

{

2900

if (!jarg1) {

2901

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2902

return ;

2903

}

2904

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2905

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2906

return ;

2907

}

2908

arg1 = &temp1;

2909

}

2910

{

2911

if (!jarg2) {

2912

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2913

return ;

2914

}

2915

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2916

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2917

return ;

2918

}

2919

arg2 = &temp2;

2920

}

2921

{

2922

if (!jarg3) {

2923

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2924

return ;

2925

}

2926

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2927

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2928

return ;

2929

}

2930

arg3 = &temp3;

2931

}

2932

{

2933

if (!jarg4) {

2934

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2935

return ;

2936

}

2937

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2938

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2939

return ;

2940

}

2941

arg4 = &temp4;

2942

}

2943

plgvpd(arg1,arg2,arg3,arg4);

2944

2945

{

2946

jdouble jvalue = (jdouble)temp1;

2947

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2948

}

2949

{

2950

jdouble jvalue = (jdouble)temp2;

2951

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2952

}

2953

{

2954

jdouble jvalue = (jdouble)temp3;

2955

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2956

}

2957

{

2958

jdouble jvalue = (jdouble)temp4;

2959

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2960

}

2961

2962

2963

2964

2751

2965

}

2752

2966

2753

2967

2754

2968

#define _doc_plgvpw "Get viewport boundaries in world coordinates."

2755

2969

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgvpw(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jdoubleArray jarg3, jdoubleArray jarg4) {

2756

PLFLT *arg1 = (PLFLT *) 0 ;

2757

PLFLT *arg2 = (PLFLT *) 0 ;

2758

PLFLT *arg3 = (PLFLT *) 0 ;

2759

PLFLT *arg4 = (PLFLT *) 0 ;

2760

PLFLT temp1 ;

2761

PLFLT temp2 ;

2762

PLFLT temp3 ;

2763

PLFLT temp4 ;

2764

2765

(void)jenv;

2766

(void)jcls;

2767

{

2768

if (!jarg1) {

2769

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2770

return ;

2771

}

2772

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2773

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2774

return ;

2775

}

2776

arg1 = &temp1;

2777

}

2778

{

2779

if (!jarg2) {

2780

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2781

return ;

2782

}

2783

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2784

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2785

return ;

2786

}

2787

arg2 = &temp2;

2788

}

2789

{

2790

if (!jarg3) {

2791

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2792

return ;

2793

}

2794

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

2795

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2796

return ;

2797

}

2798

arg3 = &temp3;

2799

}

2800

{

2801

if (!jarg4) {

2802

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2803

return ;

2804

}

2805

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

2806

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2807

return ;

2808

}

2809

arg4 = &temp4;

2810

}

2811

plgvpw(arg1,arg2,arg3,arg4);

2812

2813

{

2814

jdouble jvalue = (jdouble)temp1;

2815

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2816

}

2817

{

2818

jdouble jvalue = (jdouble)temp2;

2819

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2820

}

2821

{

2822

jdouble jvalue = (jdouble)temp3;

2823

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

2824

}

2825

{

2826

jdouble jvalue = (jdouble)temp4;

2827

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

2828

}

2970

PLFLT *arg1 = (PLFLT *) 0 ;

2971

PLFLT *arg2 = (PLFLT *) 0 ;

2972

PLFLT *arg3 = (PLFLT *) 0 ;

2973

PLFLT *arg4 = (PLFLT *) 0 ;

2974

PLFLT temp1 ;

2975

PLFLT temp2 ;

2976

PLFLT temp3 ;

2977

PLFLT temp4 ;

2978

2979

(void)jenv;

2980

(void)jcls;

2981

{

2982

if (!jarg1) {

2983

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2984

return ;

2985

}

2986

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2987

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2988

return ;

2989

}

2990

arg1 = &temp1;

2991

}

2992

{

2993

if (!jarg2) {

2994

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2995

return ;

2996

}

2997

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2998

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2999

return ;

3000

}

3001

arg2 = &temp2;

3002

}

3003

{

3004

if (!jarg3) {

3005

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3006

return ;

3007

}

3008

if ((*jenv)->GetArrayLength(jenv, jarg3) == 0) {

3009

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3010

return ;

3011

}

3012

arg3 = &temp3;

3013

}

3014

{

3015

if (!jarg4) {

3016

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3017

return ;

3018

}

3019

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

3020

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3021

return ;

3022

}

3023

arg4 = &temp4;

3024

}

3025

plgvpw(arg1,arg2,arg3,arg4);

3026

3027

{

3028

jdouble jvalue = (jdouble)temp1;

3029

(*jenv)->SetDoubleArrayRegion(jenv, jarg1, 0, 1, &jvalue);

3030

}

3031

{

3032

jdouble jvalue = (jdouble)temp2;

3033

(*jenv)->SetDoubleArrayRegion(jenv, jarg2, 0, 1, &jvalue);

3034

}

3035

{

3036

jdouble jvalue = (jdouble)temp3;

3037

(*jenv)->SetDoubleArrayRegion(jenv, jarg3, 0, 1, &jvalue);

3038

}

3039

{

3040

jdouble jvalue = (jdouble)temp4;

3041

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

3042

}

3043

3044

3045

3046

2829

3047

}

2830

3048

2831

3049

2832

3050

#define _doc_plgxax "Get x axis labeling parameters."

2833

3051

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgxax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {

2834

PLINT *arg1 = (PLINT *) 0 ;

2835

PLINT *arg2 = (PLINT *) 0 ;

2836

PLINT temp1 ;

2837

PLINT temp2 ;

2838

2839

(void)jenv;

2840

(void)jcls;

2841

{

2842

if (!jarg1) {

2843

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2844

return ;

2845

}

2846

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2847

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2848

return ;

2849

}

2850

arg1 = &temp1;

2851

}

2852

{

2853

if (!jarg2) {

2854

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2855

return ;

2856

}

2857

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2858

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2859

return ;

2860

}

2861

arg2 = &temp2;

2862

}

2863

plgxax(arg1,arg2);

2864

2865

{

2866

jint jvalue = (jint)temp1;

2867

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2868

}

2869

{

2870

jint jvalue = (jint)temp2;

2871

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2872

}

3052

PLINT *arg1 = (PLINT *) 0 ;

3053

PLINT *arg2 = (PLINT *) 0 ;

3054

PLINT temp1 ;

3055

PLINT temp2 ;

3056

3057

(void)jenv;

3058

(void)jcls;

3059

{

3060

if (!jarg1) {

3061

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3062

return ;

3063

}

3064

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

3065

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3066

return ;

3067

}

3068

arg1 = &temp1;

3069

}

3070

{

3071

if (!jarg2) {

3072

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3073

return ;

3074

}

3075

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

3076

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3077

return ;

3078

}

3079

arg2 = &temp2;

3080

}

3081

plgxax(arg1,arg2);

3082

3083

{

3084

jint jvalue = (jint)temp1;

3085

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

3086

}

3087

{

3088

jint jvalue = (jint)temp2;

3089

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

3090

}

3091

3092

2873

3093

}

2874

3094

2875

3095

2876

3096

#define _doc_plgyax "Get y axis labeling parameters."

2877

3097

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgyax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {

2878

PLINT *arg1 = (PLINT *) 0 ;

2879

PLINT *arg2 = (PLINT *) 0 ;

2880

PLINT temp1 ;

2881

PLINT temp2 ;

2882

2883

(void)jenv;

2884

(void)jcls;

2885

{

2886

if (!jarg1) {

2887

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2888

return ;

2889

}

2890

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2891

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2892

return ;

2893

}

2894

arg1 = &temp1;

2895

}

2896

{

2897

if (!jarg2) {

2898

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2899

return ;

2900

}

2901

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2902

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2903

return ;

2904

}

2905

arg2 = &temp2;

2906

}

2907

plgyax(arg1,arg2);

2908

2909

{

2910

jint jvalue = (jint)temp1;

2911

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2912

}

2913

{

2914

jint jvalue = (jint)temp2;

2915

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2916

}

3098

PLINT *arg1 = (PLINT *) 0 ;

3099

PLINT *arg2 = (PLINT *) 0 ;

3100

PLINT temp1 ;

3101

PLINT temp2 ;

3102

3103

(void)jenv;

3104

(void)jcls;

3105

{

3106

if (!jarg1) {

3107

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3108

return ;

3109

}

3110

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

3111

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3112

return ;

3113

}

3114

arg1 = &temp1;

3115

}

3116

{

3117

if (!jarg2) {

3118

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3119

return ;

3120

}

3121

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

3122

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3123

return ;

3124

}

3125

arg2 = &temp2;

3126

}

3127

plgyax(arg1,arg2);

3128

3129

{

3130

jint jvalue = (jint)temp1;

3131

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

3132

}

3133

{

3134

jint jvalue = (jint)temp2;

3135

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

3136

}

3137

3138

2917

3139

}

2918

3140

2919

3141

2920

3142

#define _doc_plgzax "Get z axis labeling parameters."

2921

3143

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plgzax(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2) {

2922

PLINT *arg1 = (PLINT *) 0 ;

2923

PLINT *arg2 = (PLINT *) 0 ;

2924

PLINT temp1 ;

2925

PLINT temp2 ;

2926

2927

(void)jenv;

2928

(void)jcls;

2929

{

2930

if (!jarg1) {

2931

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2932

return ;

2933

}

2934

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

2935

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2936

return ;

2937

}

2938

arg1 = &temp1;

2939

}

2940

{

2941

if (!jarg2) {

2942

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

2943

return ;

2944

}

2945

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

2946

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

2947

return ;

2948

}

2949

arg2 = &temp2;

2950

}

2951

plgzax(arg1,arg2);

2952

2953

{

2954

jint jvalue = (jint)temp1;

2955

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

2956

}

2957

{

2958

jint jvalue = (jint)temp2;

2959

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

2960

}

3144

PLINT *arg1 = (PLINT *) 0 ;

3145

PLINT *arg2 = (PLINT *) 0 ;

3146

PLINT temp1 ;

3147

PLINT temp2 ;

3148

3149

(void)jenv;

3150

(void)jcls;

3151

{

3152

if (!jarg1) {

3153

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3154

return ;

3155

}

3156

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

3157

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3158

return ;

3159

}

3160

arg1 = &temp1;

3161

}

3162

{

3163

if (!jarg2) {

3164

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3165

return ;

3166

}

3167

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

3168

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3169

return ;

3170

}

3171

arg2 = &temp2;

3172

}

3173

plgzax(arg1,arg2);

3174

3175

{

3176

jint jvalue = (jint)temp1;

3177

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

3178

}

3179

{

3180

jint jvalue = (jint)temp2;

3181

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

3182

}

3183

3184

2961

3185

}

2962

3186

2963

3187

2964

3188

#define _doc_plhist "Draw histogram."

2965

3189

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhist(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdouble jarg3, jdouble jarg4, jint jarg5, jint jarg6) {

2966

PLINT arg1 ;

2967

PLFLT *arg2 = (PLFLT *) 0 ;

2968

PLFLT arg3 ;

2969

PLFLT arg4 ;

2970

PLINT arg5 ;

2971

PLINT arg6 ;

2972

2973

(void)jenv;

2974

(void)jcls;

2975

{

2976

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

2977

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

2978

Alen = arg1;

2979

setup_array_1d_d( &arg2, jxdata, Alen );

2980

/* Could find no easy way to do this as part of freearg so I modified

2981

* the previous function so it ALWAYS mallocs and copies so that

2982

* the java array can be released immediately. */

2983

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

2984

}

2985

arg3 = (PLFLT)jarg3;

2986

arg4 = (PLFLT)jarg4;

2987

arg5 = (PLINT)jarg5;

2988

arg6 = (PLINT)jarg6;

2989

plhist(arg1,arg2,arg3,arg4,arg5,arg6);

2990

2991

{

2992

free(arg2);

2993

}

3190

PLINT arg1 ;

3191

PLFLT *arg2 = (PLFLT *) 0 ;

3192

PLFLT arg3 ;

3193

PLFLT arg4 ;

3194

PLINT arg5 ;

3195

PLINT arg6 ;

3196

3197

(void)jenv;

3198

(void)jcls;

3199

{

3200

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3201

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

3202

Alen = arg1;

3203

setup_array_1d_d( &arg2, jxdata, Alen );

3204

/* Could find no easy way to do this as part of freearg so I modified

3205

* the previous function so it ALWAYS mallocs and copies so that

3206

* the java array can be released immediately. */

3207

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3208

}

3209

arg3 = (PLFLT)jarg3;

3210

arg4 = (PLFLT)jarg4;

3211

arg5 = (PLINT)jarg5;

3212

arg6 = (PLINT)jarg6;

3213

plhist(arg1,arg2,arg3,arg4,arg5,arg6);

3214

3215

{

3216

free(arg2);

3217

}

2994

3218

}

2995

3219

2996

3220

2997

3221

#define _doc_plhls "Set current color (map 0) by hue, lightness, and saturation."

2998

3222

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhls(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3) {

2999

PLFLT arg1 ;

3000

PLFLT arg2 ;

3001

PLFLT arg3 ;

3002

3003

(void)jenv;

3004

(void)jcls;

3005

arg1 = (PLFLT)jarg1;

3006

arg2 = (PLFLT)jarg2;

3007

arg3 = (PLFLT)jarg3;

3008

plhls(arg1,arg2,arg3);

3009

3223

PLFLT arg1 ;

3224

PLFLT arg2 ;

3225

PLFLT arg3 ;

3226

3227

(void)jenv;

3228

(void)jcls;

3229

arg1 = (PLFLT)jarg1;

3230

arg2 = (PLFLT)jarg2;

3231

arg3 = (PLFLT)jarg3;

3232

plhls(arg1,arg2,arg3);

3233

3234

}

3235

3236

3237

#define _doc_plhlsrgb "Transform from HLS to RGB form of colours"

3238

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plhlsrgb(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {

3239

PLFLT arg1 ;

3240

PLFLT arg2 ;

3241

PLFLT arg3 ;

3242

PLFLT *arg4 = (PLFLT *) 0 ;

3243

PLFLT *arg5 = (PLFLT *) 0 ;

3244

PLFLT *arg6 = (PLFLT *) 0 ;

3245

PLFLT temp4 ;

3246

PLFLT temp5 ;

3247

PLFLT temp6 ;

3248

3249

(void)jenv;

3250

(void)jcls;

3251

arg1 = (PLFLT)jarg1;

3252

arg2 = (PLFLT)jarg2;

3253

arg3 = (PLFLT)jarg3;

3254

{

3255

if (!jarg4) {

3256

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3257

return ;

3258

}

3259

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

3260

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3261

return ;

3262

}

3263

arg4 = &temp4;

3264

}

3265

{

3266

if (!jarg5) {

3267

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3268

return ;

3269

}

3270

if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {

3271

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3272

return ;

3273

}

3274

arg5 = &temp5;

3275

}

3276

{

3277

if (!jarg6) {

3278

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3279

return ;

3280

}

3281

if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {

3282

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3283

return ;

3284

}

3285

arg6 = &temp6;

3286

}

3287

plhlsrgb(arg1,arg2,arg3,arg4,arg5,arg6);

3288

3289

{

3290

jdouble jvalue = (jdouble)temp4;

3291

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

3292

}

3293

{

3294

jdouble jvalue = (jdouble)temp5;

3295

(*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);

3296

}

3297

{

3298

jdouble jvalue = (jdouble)temp6;

3299

(*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);

3300

}

3301

3302

3303

3010

3304

}

3011

3305

3012

3306

3013

3307

#define _doc_plinit "Initialize PLplot, using preset or default options."

3014

3308

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plinit(JNIEnv *jenv, jclass jcls) {

3015

(void)jenv;

3016

(void)jcls;

3017

plinit();

3018

3309

(void)jenv;

3310

(void)jcls;

3311

plinit();

3312

3019

3313

}

3020

3314

3021

3315

3022

3316

#define _doc_pljoin "Draw a line segment from (x1, y1) to (x2, y2)."

3023

3317

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pljoin(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

3024

PLFLT arg1 ;

3025

PLFLT arg2 ;

3026

PLFLT arg3 ;

3027

PLFLT arg4 ;

3028

3029

(void)jenv;

3030

(void)jcls;

3031

arg1 = (PLFLT)jarg1;

3032

arg2 = (PLFLT)jarg2;

3033

arg3 = (PLFLT)jarg3;

3034

arg4 = (PLFLT)jarg4;

3035

pljoin(arg1,arg2,arg3,arg4);

3036

3318

PLFLT arg1 ;

3319

PLFLT arg2 ;

3320

PLFLT arg3 ;

3321

PLFLT arg4 ;

3322

3323

(void)jenv;

3324

(void)jcls;

3325

arg1 = (PLFLT)jarg1;

3326

arg2 = (PLFLT)jarg2;

3327

arg3 = (PLFLT)jarg3;

3328

arg4 = (PLFLT)jarg4;

3329

pljoin(arg1,arg2,arg3,arg4);

3330

3037

3331

}

3038

3332

3039

3333

3040

3334

#define _doc_pllab "Label graphs."

3041

3335

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllab(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2, jstring jarg3) {

3042

char *arg1 ;

3043

char *arg2 ;

3044

char *arg3 ;

3045

3046

(void)jenv;

3047

(void)jcls;

3048

{

3049

arg1 = 0;

3050

if (jarg1) {

3051

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

3052

if (!arg1) return ;

3053

}

3054

}

3055

{

3056

arg2 = 0;

3057

if (jarg2) {

3058

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

3059

if (!arg2) return ;

3060

}

3061

}

3062

{

3063

arg3 = 0;

3064

if (jarg3) {

3065

arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);

3066

if (!arg3) return ;

3067

}

3068

}

3069

pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);

3070

3071

{

3072

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

3073

}

3074

{

3075

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

3076

}

3077

{

3078

if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, arg3);

3079

}

3336

char *arg1 = (char *) 0 ;

3337

char *arg2 = (char *) 0 ;

3338

char *arg3 = (char *) 0 ;

3339

3340

(void)jenv;

3341

(void)jcls;

3342

arg1 = 0;

3343

if (jarg1) {

3344

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

3345

if (!arg1) return ;

3346

}

3347

arg2 = 0;

3348

if (jarg2) {

3349

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

3350

if (!arg2) return ;

3351

}

3352

arg3 = 0;

3353

if (jarg3) {

3354

arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);

3355

if (!arg3) return ;

3356

}

3357

pllab((char const *)arg1,(char const *)arg2,(char const *)arg3);

3358

3359

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

3360

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

3361

if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, arg3);

3080

3362

}

3081

3363

3082

3364

3083

3365

#define _doc_pllightsource "Set position of the light source."

3084

3366

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllightsource(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3) {

3085

PLFLT arg1 ;

3086

PLFLT arg2 ;

3087

PLFLT arg3 ;

3088

3089

(void)jenv;

3090

(void)jcls;

3091

arg1 = (PLFLT)jarg1;

3092

arg2 = (PLFLT)jarg2;

3093

arg3 = (PLFLT)jarg3;

3094

pllightsource(arg1,arg2,arg3);

3095

3367

PLFLT arg1 ;

3368

PLFLT arg2 ;

3369

PLFLT arg3 ;

3370

3371

(void)jenv;

3372

(void)jcls;

3373

arg1 = (PLFLT)jarg1;

3374

arg2 = (PLFLT)jarg2;

3375

arg3 = (PLFLT)jarg3;

3376

pllightsource(arg1,arg2,arg3);

3377

3096

3378

}

3097

3379

3098

3380

3099

3381

#define _doc_plline "Draw line segments connecting a series of points."

3100

3382

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plline(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3) {

3101

PLINT arg1 ;

3102

PLFLT *arg2 = (PLFLT *) 0 ;

3103

PLFLT *arg3 = (PLFLT *) 0 ;

3104

3105

(void)jenv;

3106

(void)jcls;

3107

{

3108

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3109

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

3110

Alen = arg1;

3111

setup_array_1d_d( &arg2, jxdata, Alen );

3112

/* Could find no easy way to do this as part of freearg so I modified

3113

* the previous function so it ALWAYS mallocs and copies so that

3114

* the java array can be released immediately. */

3115

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3116

}

3117

{

3118

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

3119

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

3120

printf("Vectors must be same length.\n");

3121

return;

3122

}

3123

setup_array_1d_d( &arg3, jydata, Alen );

3124

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

3125

}

3126

plline(arg1,arg2,arg3);

3127

3128

{

3129

free(arg2);

3130

}

3131

{

3132

free(arg3);

3133

}

3383

PLINT arg1 ;

3384

PLFLT *arg2 = (PLFLT *) 0 ;

3385

PLFLT *arg3 = (PLFLT *) 0 ;

3386

3387

(void)jenv;

3388

(void)jcls;

3389

{

3390

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3391

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

3392

Alen = arg1;

3393

setup_array_1d_d( &arg2, jxdata, Alen );

3394

/* Could find no easy way to do this as part of freearg so I modified

3395

* the previous function so it ALWAYS mallocs and copies so that

3396

* the java array can be released immediately. */

3397

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3398

}

3399

{

3400

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

3401

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

3402

printf("Vectors must be same length.\n");

3403

return;

3404

}

3405

setup_array_1d_d( &arg3, jydata, Alen );

3406

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

3407

}

3408

plline(arg1,arg2,arg3);

3409

3410

{

3411

free(arg2);

3412

}

3413

{

3414

free(arg3);

3415

}

3134

3416

}

3135

3417

3136

3418

3137

3419

#define _doc_plline3 "Draw a line in 3 space."

3138

3420

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plline3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4) {

3139

PLINT arg1 ;

3140

PLFLT *arg2 = (PLFLT *) 0 ;

3141

PLFLT *arg3 = (PLFLT *) 0 ;

3142

PLFLT *arg4 = (PLFLT *) 0 ;

3143

3144

(void)jenv;

3145

(void)jcls;

3146

{

3147

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3148

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

3149

Alen = arg1;

3150

setup_array_1d_d( &arg2, jxdata, Alen );

3151

/* Could find no easy way to do this as part of freearg so I modified

3152

* the previous function so it ALWAYS mallocs and copies so that

3153

* the java array can be released immediately. */

3154

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3155

}

3156

{

3157

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

3158

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

3159

printf("Vectors must be same length.\n");

3160

return;

3161

}

3162

setup_array_1d_d( &arg3, jydata, Alen );

3163

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

3164

}

3165

{

3166

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

3167

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

3168

printf("Vectors must be same length.\n");

3169

return;

3170

}

3171

setup_array_1d_d( &arg4, jydata, Alen );

3172

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

3173

}

3174

plline3(arg1,arg2,arg3,arg4);

3175

3176

{

3177

free(arg2);

3178

}

3179

{

3180

free(arg3);

3181

}

3182

{

3183

free(arg4);

3184

}

3421

PLINT arg1 ;

3422

PLFLT *arg2 = (PLFLT *) 0 ;

3423

PLFLT *arg3 = (PLFLT *) 0 ;

3424

PLFLT *arg4 = (PLFLT *) 0 ;

3425

3426

(void)jenv;

3427

(void)jcls;

3428

{

3429

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3430

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

3431

Alen = arg1;

3432

setup_array_1d_d( &arg2, jxdata, Alen );

3433

/* Could find no easy way to do this as part of freearg so I modified

3434

* the previous function so it ALWAYS mallocs and copies so that

3435

* the java array can be released immediately. */

3436

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3437

}

3438

{

3439

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

3440

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

3441

printf("Vectors must be same length.\n");

3442

return;

3443

}

3444

setup_array_1d_d( &arg3, jydata, Alen );

3445

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

3446

}

3447

{

3448

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

3449

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

3450

printf("Vectors must be same length.\n");

3451

return;

3452

}

3453

setup_array_1d_d( &arg4, jydata, Alen );

3454

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

3455

}

3456

plline3(arg1,arg2,arg3,arg4);

3457

3458

{

3459

free(arg2);

3460

}

3461

{

3462

free(arg3);

3463

}

3464

{

3465

free(arg4);

3466

}

3185

3467

}

3186

3468

3187

3469

3188

3470

#define _doc_pllsty "Set line style."

3189

3471

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pllsty(JNIEnv *jenv, jclass jcls, jint jarg1) {

3190

PLINT arg1 ;

3191

3192

(void)jenv;

3193

(void)jcls;

3194

arg1 = (PLINT)jarg1;

3195

pllsty(arg1);

3196

3472

PLINT arg1 ;

3473

3474

(void)jenv;

3475

(void)jcls;

3476

arg1 = (PLINT)jarg1;

3477

pllsty(arg1);

3478

3197

3479

}

3198

3480

3199

3481

3200

3482

#define _doc_plmesh "Plot a 3-d mesh representation of z[x][y]."

3201

3483

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmesh(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6) {

3202

PLFLT *arg1 = (PLFLT *) 0 ;

3203

PLFLT *arg2 = (PLFLT *) 0 ;

3204

PLFLT **arg3 = (PLFLT **) 0 ;

3205

PLINT arg4 ;

3206

PLINT arg5 ;

3207

PLINT arg6 ;

3484

PLFLT *arg1 = (PLFLT *) 0 ;

3485

PLFLT *arg2 = (PLFLT *) 0 ;

3486

PLFLT **arg3 = (PLFLT **) 0 ;

3487

PLINT arg4 ;

3488

PLINT arg5 ;

3489

PLINT arg6 ;

3490

3491

(void)jenv;

3492

(void)jcls;

3493

{

3494

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3495

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3496

setup_array_1d_d( &arg1, jxdata, Xlen);

3497

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3498

}

3499

{

3500

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3501

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3502

setup_array_1d_d( &arg2, jydata, Ylen);

3503

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3504

}

3505

{

3506

jdouble **adat;

3507

jobject *ai;

3508

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3509

int ny = -1;

3510

int i, j;

3511

ai = (jobject *) malloc( nx * sizeof(jobject) );

3512

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3208

3513

3209

(void)jenv;

3210

(void)jcls;

3211

{

3212

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3213

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3214

setup_array_1d_d( &arg1, jxdata, Xlen);

3215

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3216

}

3217

{

3218

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3219

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3220

setup_array_1d_d( &arg2, jydata, Ylen);

3221

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3222

}

3223

{

3224

jdouble **adat;

3225

jobject *ai;

3226

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3227

int ny = -1;

3228

int i, j;

3229

ai = (jobject *) malloc( nx * sizeof(jobject) );

3230

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3231

3232

for( i=0; i < nx; i++ )

3233

{

3234

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3235

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3236

3237

if (ny == -1)

3238

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3239

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3240

printf( "Misshapen a array.\n" );

3241

for( j=0; j <= i; j++ )

3242

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3243

free(adat);

3244

free(ai);

3245

return;

3246

}

3247

}

3248

3249

if( nx != Xlen || ny != Ylen ) {

3250

printf( "Vectors must match matrix.\n" );

3251

for( i=0; i < nx; i++ )

3252

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3253

free(adat);

3254

free(ai);

3255

return;

3256

}

3257

setup_array_2d_d( &arg3, adat, nx, ny );

3258

arg4 = nx;

3259

arg5 = ny;

3260

for( i=0; i < nx; i++ ) {

3261

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3262

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3263

}

3264

3265

3514

for( i=0; i < nx; i++ )

3515

{

3516

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3517

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3518

3519

if (ny == -1)

3520

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3521

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3522

printf( "Misshapen a array.\n" );

3523

for( j=0; j <= i; j++ )

3524

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3266

3525

free(adat);

3267

3526

free(ai);

3268

3269

}

3270

arg6 = (PLINT)jarg6;

3271

plmesh(arg1,arg2,arg3,arg4,arg5,arg6);

3272

3273

{

3274

free(arg1);

3275

}

3276

{

3277

free(arg2);

3278

}

3279

{

3280

free(arg3[0]);

3281

free(arg3);

3282

}

3527

return;

3528

}

3529

}

3530

3531

if( nx != Xlen || ny != Ylen ) {

3532

printf( "Vectors must match matrix.\n" );

3533

for( i=0; i < nx; i++ )

3534

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3535

free(adat);

3536

free(ai);

3537

return;

3538

}

3539

setup_array_2d_d( &arg3, adat, nx, ny );

3540

arg4 = nx;

3541

arg5 = ny;

3542

for( i=0; i < nx; i++ ) {

3543

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3544

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3545

}

3546

3547

3548

free(adat);

3549

free(ai);

3550

3551

}

3552

arg6 = (PLINT)jarg6;

3553

plmesh(arg1,arg2,arg3,arg4,arg5,arg6);

3554

3555

{

3556

free(arg1);

3557

}

3558

{

3559

free(arg2);

3560

}

3561

{

3562

free(arg3[0]);

3563

free(arg3);

3564

}

3283

3565

}

3284

3566

3285

3567

3286

3568

#define _doc_plmeshc "Plot a 3-d contoured mesh representation of the function z[x][y]."

3287

3569

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmeshc(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {

3288

PLFLT *arg1 = (PLFLT *) 0 ;

3289

PLFLT *arg2 = (PLFLT *) 0 ;

3290

PLFLT **arg3 = (PLFLT **) 0 ;

3291

PLINT arg4 ;

3292

PLINT arg5 ;

3293

PLINT arg6 ;

3294

PLFLT *arg7 = (PLFLT *) 0 ;

3295

PLINT arg8 ;

3570

PLFLT *arg1 = (PLFLT *) 0 ;

3571

PLFLT *arg2 = (PLFLT *) 0 ;

3572

PLFLT **arg3 = (PLFLT **) 0 ;

3573

PLINT arg4 ;

3574

PLINT arg5 ;

3575

PLINT arg6 ;

3576

PLFLT *arg7 = (PLFLT *) 0 ;

3577

PLINT arg8 ;

3578

3579

(void)jenv;

3580

(void)jcls;

3581

{

3582

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3583

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3584

setup_array_1d_d( &arg1, jxdata, Xlen);

3585

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3586

}

3587

{

3588

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3589

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3590

setup_array_1d_d( &arg2, jydata, Ylen);

3591

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3592

}

3593

{

3594

jdouble **adat;

3595

jobject *ai;

3596

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3597

int ny = -1;

3598

int i, j;

3599

ai = (jobject *) malloc( nx * sizeof(jobject) );

3600

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3296

3601

3297

(void)jenv;

3298

(void)jcls;

3299

{

3300

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3301

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3302

setup_array_1d_d( &arg1, jxdata, Xlen);

3303

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3304

}

3305

{

3306

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3307

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3308

setup_array_1d_d( &arg2, jydata, Ylen);

3309

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3310

}

3311

{

3312

jdouble **adat;

3313

jobject *ai;

3314

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3315

int ny = -1;

3316

int i, j;

3317

ai = (jobject *) malloc( nx * sizeof(jobject) );

3318

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3319

3320

for( i=0; i < nx; i++ )

3321

{

3322

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3323

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3324

3325

if (ny == -1)

3326

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3327

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3328

printf( "Misshapen a array.\n" );

3329

for( j=0; j <= i; j++ )

3330

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3331

free(adat);

3332

free(ai);

3333

return;

3334

}

3335

}

3336

3337

if( nx != Xlen || ny != Ylen ) {

3338

printf( "Vectors must match matrix.\n" );

3339

for( i=0; i < nx; i++ )

3340

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3341

free(adat);

3342

free(ai);

3343

return;

3344

}

3345

setup_array_2d_d( &arg3, adat, nx, ny );

3346

arg4 = nx;

3347

arg5 = ny;

3348

for( i=0; i < nx; i++ ) {

3349

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3350

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3351

}

3352

3353

3602

for( i=0; i < nx; i++ )

3603

{

3604

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3605

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3606

3607

if (ny == -1)

3608

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3609

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3610

printf( "Misshapen a array.\n" );

3611

for( j=0; j <= i; j++ )

3612

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3354

3613

free(adat);

3355

3614

free(ai);

3356

3357

}

3358

arg6 = (PLINT)jarg6;

3359

{

3360

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3361

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3362

setup_array_1d_d( &arg7, jxdata, arg8);

3363

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3364

}

3365

plmeshc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);

3366

3367

{

3368

free(arg1);

3369

}

3370

{

3371

free(arg2);

3372

}

3373

{

3374

free(arg3[0]);

3375

free(arg3);

3376

}

3377

{

3378

free(arg7);

3379

}

3615

return;

3616

}

3617

}

3618

3619

if( nx != Xlen || ny != Ylen ) {

3620

printf( "Vectors must match matrix.\n" );

3621

for( i=0; i < nx; i++ )

3622

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3623

free(adat);

3624

free(ai);

3625

return;

3626

}

3627

setup_array_2d_d( &arg3, adat, nx, ny );

3628

arg4 = nx;

3629

arg5 = ny;

3630

for( i=0; i < nx; i++ ) {

3631

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3632

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3633

}

3634

3635

3636

free(adat);

3637

free(ai);

3638

3639

}

3640

arg6 = (PLINT)jarg6;

3641

{

3642

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3643

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3644

setup_array_1d_d( &arg7, jxdata, arg8);

3645

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3646

}

3647

plmeshc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);

3648

3649

{

3650

free(arg1);

3651

}

3652

{

3653

free(arg2);

3654

}

3655

{

3656

free(arg3[0]);

3657

free(arg3);

3658

}

3659

{

3660

free(arg7);

3661

}

3380

3662

}

3381

3663

3382

3664

3383

3665

#define _doc_plmkstrm "Create a new stream and makes it the default."

3384

3666

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmkstrm(JNIEnv *jenv, jclass jcls, jintArray jarg1) {

3385

PLINT *arg1 = (PLINT *) 0 ;

3386

PLINT temp1 ;

3387

3388

(void)jenv;

3389

(void)jcls;

3390

{

3391

if (!jarg1) {

3392

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3393

return ;

3394

}

3395

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

3396

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3397

return ;

3398

}

3399

arg1 = &temp1;

3400

}

3401

plmkstrm(arg1);

3402

3403

{

3404

jint jvalue = (jint)temp1;

3405

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

3406

}

3667

PLINT *arg1 = (PLINT *) 0 ;

3668

PLINT temp1 ;

3669

3670

(void)jenv;

3671

(void)jcls;

3672

{

3673

if (!jarg1) {

3674

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

3675

return ;

3676

}

3677

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

3678

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

3679

return ;

3680

}

3681

arg1 = &temp1;

3682

}

3683

plmkstrm(arg1);

3684

3685

{

3686

jint jvalue = (jint)temp1;

3687

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

3688

}

3689

3407

3690

}

3408

3691

3409

3692

3410

3693

#define _doc_plmtex "Print \"text\" at specified position relative to viewport."

3411

3694

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plmtex(JNIEnv *jenv, jclass jcls, jstring jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jstring jarg5) {

3412

char *arg1 ;

3413

PLFLT arg2 ;

3414

PLFLT arg3 ;

3415

PLFLT arg4 ;

3416

char *arg5 ;

3417

3418

(void)jenv;

3419

(void)jcls;

3420

{

3421

arg1 = 0;

3422

if (jarg1) {

3423

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

3424

if (!arg1) return ;

3425

}

3426

}

3427

arg2 = (PLFLT)jarg2;

3428

arg3 = (PLFLT)jarg3;

3429

arg4 = (PLFLT)jarg4;

3430

{

3431

arg5 = 0;

3432

if (jarg5) {

3433

arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);

3434

if (!arg5) return ;

3435

}

3436

}

3437

plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);

3438

3439

{

3440

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

3441

}

3442

{

3443

if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, arg5);

3444

}

3695

char *arg1 = (char *) 0 ;

3696

PLFLT arg2 ;

3697

PLFLT arg3 ;

3698

PLFLT arg4 ;

3699

char *arg5 = (char *) 0 ;

3700

3701

(void)jenv;

3702

(void)jcls;

3703

arg1 = 0;

3704

if (jarg1) {

3705

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

3706

if (!arg1) return ;

3707

}

3708

arg2 = (PLFLT)jarg2;

3709

arg3 = (PLFLT)jarg3;

3710

arg4 = (PLFLT)jarg4;

3711

arg5 = 0;

3712

if (jarg5) {

3713

arg5 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg5, 0);

3714

if (!arg5) return ;

3715

}

3716

plmtex((char const *)arg1,arg2,arg3,arg4,(char const *)arg5);

3717

3718

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

3719

if (arg5) (*jenv)->ReleaseStringUTFChars(jenv, jarg5, arg5);

3445

3720

}

3446

3721

3447

3722

3448

3723

#define _doc_plot3d "Plot a 3-d representation of the function z[x][y]."

3449

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jint jarg7) {

3450

PLFLT *arg1 = (PLFLT *) 0 ;

3451

PLFLT *arg2 = (PLFLT *) 0 ;

3452

PLFLT **arg3 = (PLFLT **) 0 ;

3453

PLINT arg4 ;

3454

PLINT arg5 ;

3455

PLINT arg6 ;

3456

PLINT arg7 ;

3724

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jboolean jarg7) {

3725

PLFLT *arg1 = (PLFLT *) 0 ;

3726

PLFLT *arg2 = (PLFLT *) 0 ;

3727

PLFLT **arg3 = (PLFLT **) 0 ;

3728

PLINT arg4 ;

3729

PLINT arg5 ;

3730

PLINT arg6 ;

3731

PLBOOL arg7 ;

3732

3733

(void)jenv;

3734

(void)jcls;

3735

{

3736

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3737

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3738

setup_array_1d_d( &arg1, jxdata, Xlen);

3739

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3740

}

3741

{

3742

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3743

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3744

setup_array_1d_d( &arg2, jydata, Ylen);

3745

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3746

}

3747

{

3748

jdouble **adat;

3749

jobject *ai;

3750

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3751

int ny = -1;

3752

int i, j;

3753

ai = (jobject *) malloc( nx * sizeof(jobject) );

3754

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3457

3755

3458

(void)jenv;

3459

(void)jcls;

3460

{

3461

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3462

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3463

setup_array_1d_d( &arg1, jxdata, Xlen);

3464

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3465

}

3466

{

3467

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3468

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3469

setup_array_1d_d( &arg2, jydata, Ylen);

3470

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3471

}

3472

{

3473

jdouble **adat;

3474

jobject *ai;

3475

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3476

int ny = -1;

3477

int i, j;

3478

ai = (jobject *) malloc( nx * sizeof(jobject) );

3479

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3480

3481

for( i=0; i < nx; i++ )

3482

{

3483

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3484

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3485

3486

if (ny == -1)

3487

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3488

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3489

printf( "Misshapen a array.\n" );

3490

for( j=0; j <= i; j++ )

3491

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3492

free(adat);

3493

free(ai);

3494

return;

3495

}

3496

}

3497

3498

if( nx != Xlen || ny != Ylen ) {

3499

printf( "Vectors must match matrix.\n" );

3500

for( i=0; i < nx; i++ )

3501

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3502

free(adat);

3503

free(ai);

3504

return;

3505

}

3506

setup_array_2d_d( &arg3, adat, nx, ny );

3507

arg4 = nx;

3508

arg5 = ny;

3509

for( i=0; i < nx; i++ ) {

3510

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3511

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3512

}

3513

3514

3756

for( i=0; i < nx; i++ )

3757

{

3758

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3759

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3760

3761

if (ny == -1)

3762

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3763

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3764

printf( "Misshapen a array.\n" );

3765

for( j=0; j <= i; j++ )

3766

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3515

3767

free(adat);

3516

3768

free(ai);

3517

3518

}

3519

arg6 = (PLINT)jarg6;

3520

arg7 = (PLINT)jarg7;

3521

plot3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7);

3522

3523

{

3524

free(arg1);

3525

}

3526

{

3527

free(arg2);

3528

}

3529

{

3530

free(arg3[0]);

3531

free(arg3);

3532

}

3769

return;

3770

}

3771

}

3772

3773

if( nx != Xlen || ny != Ylen ) {

3774

printf( "Vectors must match matrix.\n" );

3775

for( i=0; i < nx; i++ )

3776

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3777

free(adat);

3778

free(ai);

3779

return;

3780

}

3781

setup_array_2d_d( &arg3, adat, nx, ny );

3782

arg4 = nx;

3783

arg5 = ny;

3784

for( i=0; i < nx; i++ ) {

3785

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3786

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3787

}

3788

3789

3790

free(adat);

3791

free(ai);

3792

3793

}

3794

arg6 = (PLINT)jarg6;

3795

arg7 = jarg7 ? 1 : 0;

3796

plot3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7);

3797

3798

{

3799

free(arg1);

3800

}

3801

{

3802

free(arg2);

3803

}

3804

{

3805

free(arg3[0]);

3806

free(arg3);

3807

}

3533

3808

}

3534

3809

3535

3810

3536

3811

#define _doc_plot3dc "Plot a 3-d contoured representation of the function z[x][y]."

3537

3812

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3dc(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {

3538

PLFLT *arg1 = (PLFLT *) 0 ;

3539

PLFLT *arg2 = (PLFLT *) 0 ;

3540

PLFLT **arg3 = (PLFLT **) 0 ;

3541

PLINT arg4 ;

3542

PLINT arg5 ;

3543

PLINT arg6 ;

3544

PLFLT *arg7 = (PLFLT *) 0 ;

3545

PLINT arg8 ;

3813

PLFLT *arg1 = (PLFLT *) 0 ;

3814

PLFLT *arg2 = (PLFLT *) 0 ;

3815

PLFLT **arg3 = (PLFLT **) 0 ;

3816

PLINT arg4 ;

3817

PLINT arg5 ;

3818

PLINT arg6 ;

3819

PLFLT *arg7 = (PLFLT *) 0 ;

3820

PLINT arg8 ;

3821

3822

(void)jenv;

3823

(void)jcls;

3824

{

3825

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3826

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3827

setup_array_1d_d( &arg1, jxdata, Xlen);

3828

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3829

}

3830

{

3831

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3832

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3833

setup_array_1d_d( &arg2, jydata, Ylen);

3834

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3835

}

3836

{

3837

jdouble **adat;

3838

jobject *ai;

3839

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3840

int ny = -1;

3841

int i, j;

3842

ai = (jobject *) malloc( nx * sizeof(jobject) );

3843

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3546

3844

3547

(void)jenv;

3548

(void)jcls;

3549

{

3550

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3551

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3552

setup_array_1d_d( &arg1, jxdata, Xlen);

3553

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3554

}

3555

{

3556

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3557

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3558

setup_array_1d_d( &arg2, jydata, Ylen);

3559

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3560

}

3561

{

3562

jdouble **adat;

3563

jobject *ai;

3564

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3565

int ny = -1;

3566

int i, j;

3567

ai = (jobject *) malloc( nx * sizeof(jobject) );

3568

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3569

3570

for( i=0; i < nx; i++ )

3571

{

3572

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3573

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3574

3575

if (ny == -1)

3576

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3577

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3578

printf( "Misshapen a array.\n" );

3579

for( j=0; j <= i; j++ )

3580

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3581

free(adat);

3582

free(ai);

3583

return;

3584

}

3585

}

3586

3587

if( nx != Xlen || ny != Ylen ) {

3588

printf( "Vectors must match matrix.\n" );

3589

for( i=0; i < nx; i++ )

3590

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3591

free(adat);

3592

free(ai);

3593

return;

3594

}

3595

setup_array_2d_d( &arg3, adat, nx, ny );

3596

arg4 = nx;

3597

arg5 = ny;

3598

for( i=0; i < nx; i++ ) {

3599

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3600

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3601

}

3602

3603

3845

for( i=0; i < nx; i++ )

3846

{

3847

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3848

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3849

3850

if (ny == -1)

3851

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3852

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3853

printf( "Misshapen a array.\n" );

3854

for( j=0; j <= i; j++ )

3855

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3604

3856

free(adat);

3605

3857

free(ai);

3606

3607

}

3608

arg6 = (PLINT)jarg6;

3609

{

3610

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3611

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3612

setup_array_1d_d( &arg7, jxdata, arg8);

3613

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3614

}

3615

plot3dc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);

3616

3617

{

3618

free(arg1);

3619

}

3620

{

3621

free(arg2);

3622

}

3623

{

3624

free(arg3[0]);

3625

free(arg3);

3626

}

3627

{

3628

free(arg7);

3629

}

3858

return;

3859

}

3860

}

3861

3862

if( nx != Xlen || ny != Ylen ) {

3863

printf( "Vectors must match matrix.\n" );

3864

for( i=0; i < nx; i++ )

3865

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3866

free(adat);

3867

free(ai);

3868

return;

3869

}

3870

setup_array_2d_d( &arg3, adat, nx, ny );

3871

arg4 = nx;

3872

arg5 = ny;

3873

for( i=0; i < nx; i++ ) {

3874

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3875

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3876

}

3877

3878

3879

free(adat);

3880

free(ai);

3881

3882

}

3883

arg6 = (PLINT)jarg6;

3884

{

3885

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3886

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3887

setup_array_1d_d( &arg7, jxdata, arg8);

3888

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3889

}

3890

plot3dc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);

3891

3892

{

3893

free(arg1);

3894

}

3895

{

3896

free(arg2);

3897

}

3898

{

3899

free(arg3[0]);

3900

free(arg3);

3901

}

3902

{

3903

free(arg7);

3904

}

3630

3905

}

3631

3906

3632

3907

3633

3908

#define _doc_plot3dcl "Plot a 3-d contoured representation of the function z[x][y] with limits on the y index."

3634

3909

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plot3dcl(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7, jint jarg9, jintArray jarg10, jintArray jarg12) {

3635

PLFLT *arg1 = (PLFLT *) 0 ;

3636

PLFLT *arg2 = (PLFLT *) 0 ;

3637

PLFLT **arg3 = (PLFLT **) 0 ;

3638

PLINT arg4 ;

3639

PLINT arg5 ;

3640

PLINT arg6 ;

3641

PLFLT *arg7 = (PLFLT *) 0 ;

3642

PLINT arg8 ;

3643

PLINT arg9 ;

3644

PLINT arg10 ;

3645

PLINT *arg11 = (PLINT *) 0 ;

3646

PLINT *arg12 = (PLINT *) 0 ;

3910

PLFLT *arg1 = (PLFLT *) 0 ;

3911

PLFLT *arg2 = (PLFLT *) 0 ;

3912

PLFLT **arg3 = (PLFLT **) 0 ;

3913

PLINT arg4 ;

3914

PLINT arg5 ;

3915

PLINT arg6 ;

3916

PLFLT *arg7 = (PLFLT *) 0 ;

3917

PLINT arg8 ;

3918

PLINT arg9 ;

3919

PLINT arg10 ;

3920

PLINT *arg11 = (PLINT *) 0 ;

3921

PLINT *arg12 = (PLINT *) 0 ;

3922

3923

(void)jenv;

3924

(void)jcls;

3925

{

3926

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3927

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3928

setup_array_1d_d( &arg1, jxdata, Xlen);

3929

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3930

}

3931

{

3932

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3933

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3934

setup_array_1d_d( &arg2, jydata, Ylen);

3935

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3936

}

3937

{

3938

jdouble **adat;

3939

jobject *ai;

3940

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3941

int ny = -1;

3942

int i, j;

3943

ai = (jobject *) malloc( nx * sizeof(jobject) );

3944

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3647

3945

3648

(void)jenv;

3649

(void)jcls;

3650

{

3651

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3652

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3653

setup_array_1d_d( &arg1, jxdata, Xlen);

3654

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3655

}

3656

{

3657

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3658

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3659

setup_array_1d_d( &arg2, jydata, Ylen);

3660

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3661

}

3662

{

3663

jdouble **adat;

3664

jobject *ai;

3665

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3666

int ny = -1;

3667

int i, j;

3668

ai = (jobject *) malloc( nx * sizeof(jobject) );

3669

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3670

3671

for( i=0; i < nx; i++ )

3672

{

3673

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3674

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3675

3676

if (ny == -1)

3677

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3678

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3679

printf( "Misshapen a array.\n" );

3680

for( j=0; j <= i; j++ )

3681

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3682

free(adat);

3683

free(ai);

3684

return;

3685

}

3686

}

3687

3688

if( nx != Xlen || ny != Ylen ) {

3689

printf( "Vectors must match matrix.\n" );

3690

for( i=0; i < nx; i++ )

3691

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3692

free(adat);

3693

free(ai);

3694

return;

3695

}

3696

setup_array_2d_d( &arg3, adat, nx, ny );

3697

arg4 = nx;

3698

arg5 = ny;

3699

for( i=0; i < nx; i++ ) {

3700

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3701

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3702

}

3703

3704

3946

for( i=0; i < nx; i++ )

3947

{

3948

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3949

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3950

3951

if (ny == -1)

3952

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3953

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3954

printf( "Misshapen a array.\n" );

3955

for( j=0; j <= i; j++ )

3956

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3705

3957

free(adat);

3706

3958

free(ai);

3707

3708

}

3709

arg6 = (PLINT)jarg6;

3710

{

3711

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3712

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3713

setup_array_1d_d( &arg7, jxdata, arg8);

3714

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3715

}

3716

arg9 = (PLINT)jarg9;

3717

{

3718

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg10, 0 );

3719

arg10 = (*jenv)->GetArrayLength( jenv, jarg10);

3720

Alen = arg10;

3721

setup_array_1d_i( &arg11, jxdata, Alen);

3722

/* Could find no easy way to do this as part of freearg so I modified

3723

* the previous function so it ALWAYS mallocs and copies so that

3724

* the java array can be released immediately. */

3725

(*jenv)->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );

3726

}

3727

{

3728

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg12, 0 );

3729

if((*jenv)->GetArrayLength( jenv, jarg12 ) != Alen) {

3730

printf("Vectors must be same length.\n");

3731

return;

3732

}

3733

setup_array_1d_i( &arg12, jydata, Alen);

3734

(*jenv)->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );

3735

}

3736

plot3dcl(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);

3737

3738

{

3739

free(arg1);

3740

}

3741

{

3742

free(arg2);

3743

}

3744

{

3745

free(arg3[0]);

3746

free(arg3);

3747

}

3748

{

3749

free(arg7);

3750

}

3751

{

3752

free(arg11);

3753

}

3754

{

3755

free(arg12);

3756

}

3959

return;

3960

}

3961

}

3962

3963

if( nx != Xlen || ny != Ylen ) {

3964

printf( "Vectors must match matrix.\n" );

3965

for( i=0; i < nx; i++ )

3966

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3967

free(adat);

3968

free(ai);

3969

return;

3970

}

3971

setup_array_2d_d( &arg3, adat, nx, ny );

3972

arg4 = nx;

3973

arg5 = ny;

3974

for( i=0; i < nx; i++ ) {

3975

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3976

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3977

}

3978

3979

3980

free(adat);

3981

free(ai);

3982

3983

}

3984

arg6 = (PLINT)jarg6;

3985

{

3986

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3987

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3988

setup_array_1d_d( &arg7, jxdata, arg8);

3989

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3990

}

3991

arg9 = (PLINT)jarg9;

3992

{

3993

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg10, 0 );

3994

arg10 = (*jenv)->GetArrayLength( jenv, jarg10);

3995

Alen = arg10;

3996

setup_array_1d_i( &arg11, jxdata, Alen);

3997

/* Could find no easy way to do this as part of freearg so I modified

3998

* the previous function so it ALWAYS mallocs and copies so that

3999

* the java array can be released immediately. */

4000

(*jenv)->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );

4001

}

4002

{

4003

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg12, 0 );

4004

if((*jenv)->GetArrayLength( jenv, jarg12 ) != Alen) {

4005

printf("Vectors must be same length.\n");

4006

return;

4007

}

4008

setup_array_1d_i( &arg12, jydata, Alen);

4009

(*jenv)->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );

4010

}

4011

plot3dcl(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);

4012

4013

{

4014

free(arg1);

4015

}

4016

{

4017

free(arg2);

4018

}

4019

{

4020

free(arg3[0]);

4021

free(arg3);

4022

}

4023

{

4024

free(arg7);

4025

}

4026

{

4027

free(arg11);

4028

}

4029

{

4030

free(arg12);

4031

}

3757

4032

}

3758

4033

3759

4034

3760

4035

#define _doc_plsurf3d "Plot a 3-d contoured surface representation of the function z[x][y]."

3761

4036

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsurf3d(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7) {

3762

PLFLT *arg1 = (PLFLT *) 0 ;

3763

PLFLT *arg2 = (PLFLT *) 0 ;

3764

PLFLT **arg3 = (PLFLT **) 0 ;

3765

PLINT arg4 ;

3766

PLINT arg5 ;

3767

PLINT arg6 ;

3768

PLFLT *arg7 = (PLFLT *) 0 ;

3769

PLINT arg8 ;

4037

PLFLT *arg1 = (PLFLT *) 0 ;

4038

PLFLT *arg2 = (PLFLT *) 0 ;

4039

PLFLT **arg3 = (PLFLT **) 0 ;

4040

PLINT arg4 ;

4041

PLINT arg5 ;

4042

PLINT arg6 ;

4043

PLFLT *arg7 = (PLFLT *) 0 ;

4044

PLINT arg8 ;

4045

4046

(void)jenv;

4047

(void)jcls;

4048

{

4049

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4050

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

4051

setup_array_1d_d( &arg1, jxdata, Xlen);

4052

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4053

}

4054

{

4055

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

4056

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

4057

setup_array_1d_d( &arg2, jydata, Ylen);

4058

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

4059

}

4060

{

4061

jdouble **adat;

4062

jobject *ai;

4063

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

4064

int ny = -1;

4065

int i, j;

4066

ai = (jobject *) malloc( nx * sizeof(jobject) );

4067

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3770

4068

3771

(void)jenv;

3772

(void)jcls;

3773

{

3774

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3775

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3776

setup_array_1d_d( &arg1, jxdata, Xlen);

3777

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3778

}

3779

{

3780

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3781

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3782

setup_array_1d_d( &arg2, jydata, Ylen);

3783

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3784

}

3785

{

3786

jdouble **adat;

3787

jobject *ai;

3788

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3789

int ny = -1;

3790

int i, j;

3791

ai = (jobject *) malloc( nx * sizeof(jobject) );

3792

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3793

3794

for( i=0; i < nx; i++ )

3795

{

3796

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3797

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3798

3799

if (ny == -1)

3800

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3801

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3802

printf( "Misshapen a array.\n" );

3803

for( j=0; j <= i; j++ )

3804

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3805

free(adat);

3806

free(ai);

3807

return;

3808

}

3809

}

3810

3811

if( nx != Xlen || ny != Ylen ) {

3812

printf( "Vectors must match matrix.\n" );

3813

for( i=0; i < nx; i++ )

3814

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3815

free(adat);

3816

free(ai);

3817

return;

3818

}

3819

setup_array_2d_d( &arg3, adat, nx, ny );

3820

arg4 = nx;

3821

arg5 = ny;

3822

for( i=0; i < nx; i++ ) {

3823

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3824

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3825

}

3826

3827

4069

for( i=0; i < nx; i++ )

4070

{

4071

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

4072

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

4073

4074

if (ny == -1)

4075

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

4076

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

4077

printf( "Misshapen a array.\n" );

4078

for( j=0; j <= i; j++ )

4079

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3828

4080

free(adat);

3829

4081

free(ai);

3830

3831

}

3832

arg6 = (PLINT)jarg6;

3833

{

3834

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3835

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3836

setup_array_1d_d( &arg7, jxdata, arg8);

3837

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3838

}

3839

plsurf3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);

3840

3841

{

3842

free(arg1);

3843

}

3844

{

3845

free(arg2);

3846

}

3847

{

3848

free(arg3[0]);

3849

free(arg3);

3850

}

3851

{

3852

free(arg7);

3853

}

4082

return;

4083

}

4084

}

4085

4086

if( nx != Xlen || ny != Ylen ) {

4087

printf( "Vectors must match matrix.\n" );

4088

for( i=0; i < nx; i++ )

4089

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4090

free(adat);

4091

free(ai);

4092

return;

4093

}

4094

setup_array_2d_d( &arg3, adat, nx, ny );

4095

arg4 = nx;

4096

arg5 = ny;

4097

for( i=0; i < nx; i++ ) {

4098

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4099

(*jenv)->DeleteLocalRef(jenv, ai[i]);

4100

}

4101

4102

4103

free(adat);

4104

free(ai);

4105

4106

}

4107

arg6 = (PLINT)jarg6;

4108

{

4109

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

4110

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

4111

setup_array_1d_d( &arg7, jxdata, arg8);

4112

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

4113

}

4114

plsurf3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);

4115

4116

{

4117

free(arg1);

4118

}

4119

{

4120

free(arg2);

4121

}

4122

{

4123

free(arg3[0]);

4124

free(arg3);

4125

}

4126

{

4127

free(arg7);

4128

}

3854

4129

}

3855

4130

3856

4131

3857

4132

#define _doc_plsurf3dl "Plot a 3-d contoured surface representation of the function z[x][y] with limits on the y index."

3858

4133

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsurf3dl(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jobjectArray jarg3, jint jarg6, jdoubleArray jarg7, jint jarg9, jintArray jarg10, jintArray jarg12) {

3859

PLFLT *arg1 = (PLFLT *) 0 ;

3860

PLFLT *arg2 = (PLFLT *) 0 ;

3861

PLFLT **arg3 = (PLFLT **) 0 ;

3862

PLINT arg4 ;

3863

PLINT arg5 ;

3864

PLINT arg6 ;

3865

PLFLT *arg7 = (PLFLT *) 0 ;

3866

PLINT arg8 ;

3867

PLINT arg9 ;

3868

PLINT arg10 ;

3869

PLINT *arg11 = (PLINT *) 0 ;

3870

PLINT *arg12 = (PLINT *) 0 ;

4134

PLFLT *arg1 = (PLFLT *) 0 ;

4135

PLFLT *arg2 = (PLFLT *) 0 ;

4136

PLFLT **arg3 = (PLFLT **) 0 ;

4137

PLINT arg4 ;

4138

PLINT arg5 ;

4139

PLINT arg6 ;

4140

PLFLT *arg7 = (PLFLT *) 0 ;

4141

PLINT arg8 ;

4142

PLINT arg9 ;

4143

PLINT arg10 ;

4144

PLINT *arg11 = (PLINT *) 0 ;

4145

PLINT *arg12 = (PLINT *) 0 ;

4146

4147

(void)jenv;

4148

(void)jcls;

4149

{

4150

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4151

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

4152

setup_array_1d_d( &arg1, jxdata, Xlen);

4153

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4154

}

4155

{

4156

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

4157

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

4158

setup_array_1d_d( &arg2, jydata, Ylen);

4159

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

4160

}

4161

{

4162

jdouble **adat;

4163

jobject *ai;

4164

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

4165

int ny = -1;

4166

int i, j;

4167

ai = (jobject *) malloc( nx * sizeof(jobject) );

4168

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3871

4169

3872

(void)jenv;

3873

(void)jcls;

3874

{

3875

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

3876

Xlen = (*jenv)->GetArrayLength( jenv, jarg1);

3877

setup_array_1d_d( &arg1, jxdata, Xlen);

3878

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

3879

}

3880

{

3881

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

3882

Ylen = (*jenv)->GetArrayLength( jenv, jarg2);

3883

setup_array_1d_d( &arg2, jydata, Ylen);

3884

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

3885

}

3886

{

3887

jdouble **adat;

3888

jobject *ai;

3889

int nx = (*jenv)->GetArrayLength( jenv, jarg3 );

3890

int ny = -1;

3891

int i, j;

3892

ai = (jobject *) malloc( nx * sizeof(jobject) );

3893

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

3894

3895

for( i=0; i < nx; i++ )

3896

{

3897

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

3898

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

3899

3900

if (ny == -1)

3901

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

3902

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

3903

printf( "Misshapen a array.\n" );

3904

for( j=0; j <= i; j++ )

3905

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3906

free(adat);

3907

free(ai);

3908

return;

3909

}

3910

}

3911

3912

if( nx != Xlen || ny != Ylen ) {

3913

printf( "Vectors must match matrix.\n" );

3914

for( i=0; i < nx; i++ )

3915

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3916

free(adat);

3917

free(ai);

3918

return;

3919

}

3920

setup_array_2d_d( &arg3, adat, nx, ny );

3921

arg4 = nx;

3922

arg5 = ny;

3923

for( i=0; i < nx; i++ ) {

3924

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

3925

(*jenv)->DeleteLocalRef(jenv, ai[i]);

3926

}

3927

3928

4170

for( i=0; i < nx; i++ )

4171

{

4172

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg3, i );

4173

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

4174

4175

if (ny == -1)

4176

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

4177

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

4178

printf( "Misshapen a array.\n" );

4179

for( j=0; j <= i; j++ )

4180

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

3929

4181

free(adat);

3930

4182

free(ai);

3931

3932

}

3933

arg6 = (PLINT)jarg6;

3934

{

3935

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

3936

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

3937

setup_array_1d_d( &arg7, jxdata, arg8);

3938

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

3939

}

3940

arg9 = (PLINT)jarg9;

3941

{

3942

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg10, 0 );

3943

arg10 = (*jenv)->GetArrayLength( jenv, jarg10);

3944

Alen = arg10;

3945

setup_array_1d_i( &arg11, jxdata, Alen);

3946

/* Could find no easy way to do this as part of freearg so I modified

3947

* the previous function so it ALWAYS mallocs and copies so that

3948

* the java array can be released immediately. */

3949

(*jenv)->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );

3950

}

3951

{

3952

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg12, 0 );

3953

if((*jenv)->GetArrayLength( jenv, jarg12 ) != Alen) {

3954

printf("Vectors must be same length.\n");

3955

return;

3956

}

3957

setup_array_1d_i( &arg12, jydata, Alen);

3958

(*jenv)->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );

3959

}

3960

plsurf3dl(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);

3961

3962

{

3963

free(arg1);

3964

}

3965

{

3966

free(arg2);

3967

}

3968

{

3969

free(arg3[0]);

3970

free(arg3);

3971

}

3972

{

3973

free(arg7);

3974

}

3975

{

3976

free(arg11);

3977

}

3978

{

3979

free(arg12);

3980

}

4183

return;

4184

}

4185

}

4186

4187

if( nx != Xlen || ny != Ylen ) {

4188

printf( "Vectors must match matrix.\n" );

4189

for( i=0; i < nx; i++ )

4190

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4191

free(adat);

4192

free(ai);

4193

return;

4194

}

4195

setup_array_2d_d( &arg3, adat, nx, ny );

4196

arg4 = nx;

4197

arg5 = ny;

4198

for( i=0; i < nx; i++ ) {

4199

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4200

(*jenv)->DeleteLocalRef(jenv, ai[i]);

4201

}

4202

4203

4204

free(adat);

4205

free(ai);

4206

4207

}

4208

arg6 = (PLINT)jarg6;

4209

{

4210

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg7, 0 );

4211

arg8 = (*jenv)->GetArrayLength( jenv, jarg7 );

4212

setup_array_1d_d( &arg7, jxdata, arg8);

4213

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg7, jxdata, 0 );

4214

}

4215

arg9 = (PLINT)jarg9;

4216

{

4217

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg10, 0 );

4218

arg10 = (*jenv)->GetArrayLength( jenv, jarg10);

4219

Alen = arg10;

4220

setup_array_1d_i( &arg11, jxdata, Alen);

4221

/* Could find no easy way to do this as part of freearg so I modified

4222

* the previous function so it ALWAYS mallocs and copies so that

4223

* the java array can be released immediately. */

4224

(*jenv)->ReleaseIntArrayElements( jenv, jarg10, jxdata, 0 );

4225

}

4226

{

4227

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg12, 0 );

4228

if((*jenv)->GetArrayLength( jenv, jarg12 ) != Alen) {

4229

printf("Vectors must be same length.\n");

4230

return;

4231

}

4232

setup_array_1d_i( &arg12, jydata, Alen);

4233

(*jenv)->ReleaseIntArrayElements( jenv, jarg12, jydata, 0 );

4234

}

4235

plsurf3dl(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);

4236

4237

{

4238

free(arg1);

4239

}

4240

{

4241

free(arg2);

4242

}

4243

{

4244

free(arg3[0]);

4245

free(arg3);

4246

}

4247

{

4248

free(arg7);

4249

}

4250

{

4251

free(arg11);

4252

}

4253

{

4254

free(arg12);

4255

}

4256

}

4257

4258

4259

#define _doc_plparseopts "Process options list using current options info."

4260

JNIEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plparseopts(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg3) {

4261

jint jresult = 0 ;

4262

int *arg1 = (int *) 0 ;

4263

char **arg2 = (char **) 0 ;

4264

PLINT arg3 ;

4265

PLINT result;

4266

jint size1 ;

4267

4268

(void)jenv;

4269

(void)jcls;

4270

{

4271

int i = 0;

4272

size1 = (*jenv)->GetArrayLength(jenv, jarg1);

4273

arg1 = &size1;

4274

arg2 = (char **) malloc((size1+1)*sizeof(char *));

4275

/* make a copy of each string */

4276

for (i = 0; i<size1; i++) {

4277

jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, jarg1, i);

4278

const char * c_string = (char *) (*jenv)->GetStringUTFChars(jenv, j_string, 0);

4279

/* Commented out version straight from swig documentation, but I think

4280

* it is wrong.

4281

* arg2[i] = malloc(strlen((c_string)+1)*sizeof(const char *)); */

4282

arg2[i] = malloc((strlen(c_string)+1)*sizeof(const char *));

4283

strcpy(arg2[i], c_string);

4284

(*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);

4285

(*jenv)->DeleteLocalRef(jenv, j_string);

4286

}

4287

arg2[i] = 0;

4288

}

4289

arg3 = (PLINT)jarg3;

4290

result = (PLINT)plparseopts(arg1,arg2,arg3);

4291

4292

jresult = (jint)result;

4293

{

4294

int i;

4295

/* Commented out version straight from swig documentation, but I think

4296

* it is wrong.

4297

* for (i=0; i<size1-1; i++) */

4298

for (i=0; i<size1; i++)

4299

free(arg2[i]);

4300

free(arg2);

4301

}

4302

return jresult;

3981

4303

}

3982

4304

3983

4305

3984

4306

#define _doc_plpat "Set fill pattern directly."

3985

4307

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpat(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg3) {

3986

PLINT arg1 ;

3987

PLINT *arg2 = (PLINT *) 0 ;

3988

PLINT *arg3 = (PLINT *) 0 ;

3989

3990

(void)jenv;

3991

(void)jcls;

3992

{

3993

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

3994

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

3995

Alen = arg1;

3996

setup_array_1d_i( &arg2, jxdata, Alen);

3997

/* Could find no easy way to do this as part of freearg so I modified

3998

* the previous function so it ALWAYS mallocs and copies so that

3999

* the java array can be released immediately. */

4000

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );

4001

}

4002

{

4003

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

4004

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4005

printf("Vectors must be same length.\n");

4006

return;

4007

}

4008

setup_array_1d_i( &arg3, jydata, Alen);

4009

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

4010

}

4011

plpat(arg1,arg2,arg3);

4012

4013

{

4014

free(arg2);

4015

}

4016

{

4017

free(arg3);

4018

}

4308

PLINT arg1 ;

4309

PLINT *arg2 = (PLINT *) 0 ;

4310

PLINT *arg3 = (PLINT *) 0 ;

4311

4312

(void)jenv;

4313

(void)jcls;

4314

{

4315

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

4316

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4317

Alen = arg1;

4318

setup_array_1d_i( &arg2, jxdata, Alen);

4319

/* Could find no easy way to do this as part of freearg so I modified

4320

* the previous function so it ALWAYS mallocs and copies so that

4321

* the java array can be released immediately. */

4322

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );

4323

}

4324

{

4325

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

4326

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4327

printf("Vectors must be same length.\n");

4328

return;

4329

}

4330

setup_array_1d_i( &arg3, jydata, Alen);

4331

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

4332

}

4333

plpat(arg1,arg2,arg3);

4334

4335

{

4336

free(arg2);

4337

}

4338

{

4339

free(arg3);

4340

}

4019

4341

}

4020

4342

4021

4343

4022

4344

#define _doc_plpoin "Plot array y against x for n points using ASCII code \"code\"."

4023

4345

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoin(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {

4024

PLINT arg1 ;

4025

PLFLT *arg2 = (PLFLT *) 0 ;

4026

PLFLT *arg3 = (PLFLT *) 0 ;

4027

PLINT arg4 ;

4028

4029

(void)jenv;

4030

(void)jcls;

4031

{

4032

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4033

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4034

Alen = arg1;

4035

setup_array_1d_d( &arg2, jxdata, Alen );

4036

/* Could find no easy way to do this as part of freearg so I modified

4037

* the previous function so it ALWAYS mallocs and copies so that

4038

* the java array can be released immediately. */

4039

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4040

}

4041

{

4042

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

4043

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4044

printf("Vectors must be same length.\n");

4045

return;

4046

}

4047

setup_array_1d_d( &arg3, jydata, Alen );

4048

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

4049

}

4050

arg4 = (PLINT)jarg4;

4051

plpoin(arg1,arg2,arg3,arg4);

4052

4053

{

4054

free(arg2);

4055

}

4056

{

4057

free(arg3);

4058

}

4346

PLINT arg1 ;

4347

PLFLT *arg2 = (PLFLT *) 0 ;

4348

PLFLT *arg3 = (PLFLT *) 0 ;

4349

PLINT arg4 ;

4350

4351

(void)jenv;

4352

(void)jcls;

4353

{

4354

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4355

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4356

Alen = arg1;

4357

setup_array_1d_d( &arg2, jxdata, Alen );

4358

/* Could find no easy way to do this as part of freearg so I modified

4359

* the previous function so it ALWAYS mallocs and copies so that

4360

* the java array can be released immediately. */

4361

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4362

}

4363

{

4364

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

4365

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4366

printf("Vectors must be same length.\n");

4367

return;

4368

}

4369

setup_array_1d_d( &arg3, jydata, Alen );

4370

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

4371

}

4372

arg4 = (PLINT)jarg4;

4373

plpoin(arg1,arg2,arg3,arg4);

4374

4375

{

4376

free(arg2);

4377

}

4378

{

4379

free(arg3);

4380

}

4059

4381

}

4060

4382

4061

4383

4062

4384

#define _doc_plpoin3 "Draw a series of points in 3 space."

4063

4385

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoin3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jint jarg5) {

4064

PLINT arg1 ;

4065

PLFLT *arg2 = (PLFLT *) 0 ;

4066

PLFLT *arg3 = (PLFLT *) 0 ;

4067

PLFLT *arg4 = (PLFLT *) 0 ;

4068

PLINT arg5 ;

4069

4070

(void)jenv;

4071

(void)jcls;

4072

{

4073

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4074

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4075

Alen = arg1;

4076

setup_array_1d_d( &arg2, jxdata, Alen );

4077

/* Could find no easy way to do this as part of freearg so I modified

4078

* the previous function so it ALWAYS mallocs and copies so that

4079

* the java array can be released immediately. */

4080

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4081

}

4082

{

4083

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

4084

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4085

printf("Vectors must be same length.\n");

4086

return;

4087

}

4088

setup_array_1d_d( &arg3, jydata, Alen );

4089

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

4090

}

4091

{

4092

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

4093

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

4094

printf("Vectors must be same length.\n");

4095

return;

4096

}

4097

setup_array_1d_d( &arg4, jydata, Alen );

4098

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

4099

}

4100

arg5 = (PLINT)jarg5;

4101

plpoin3(arg1,arg2,arg3,arg4,arg5);

4102

4103

{

4104

free(arg2);

4105

}

4106

{

4107

free(arg3);

4108

}

4109

{

4110

free(arg4);

4111

}

4386

PLINT arg1 ;

4387

PLFLT *arg2 = (PLFLT *) 0 ;

4388

PLFLT *arg3 = (PLFLT *) 0 ;

4389

PLFLT *arg4 = (PLFLT *) 0 ;

4390

PLINT arg5 ;

4391

4392

(void)jenv;

4393

(void)jcls;

4394

{

4395

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4396

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4397

Alen = arg1;

4398

setup_array_1d_d( &arg2, jxdata, Alen );

4399

/* Could find no easy way to do this as part of freearg so I modified

4400

* the previous function so it ALWAYS mallocs and copies so that

4401

* the java array can be released immediately. */

4402

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4403

}

4404

{

4405

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

4406

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4407

printf("Vectors must be same length.\n");

4408

return;

4409

}

4410

setup_array_1d_d( &arg3, jydata, Alen );

4411

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

4412

}

4413

{

4414

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

4415

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

4416

printf("Vectors must be same length.\n");

4417

return;

4418

}

4419

setup_array_1d_d( &arg4, jydata, Alen );

4420

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

4421

}

4422

arg5 = (PLINT)jarg5;

4423

plpoin3(arg1,arg2,arg3,arg4,arg5);

4424

4425

{

4426

free(arg2);

4427

}

4428

{

4429

free(arg3);

4430

}

4431

{

4432

free(arg4);

4433

}

4112

4434

}

4113

4435

4114

4436

4115

4437

#define _doc_plpoly3 "Draw a polygon in 3 space. "

4116

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoly3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jintArray jarg5, jint jarg6) {

4117

PLINT arg1 ;

4118

PLFLT *arg2 = (PLFLT *) 0 ;

4119

PLFLT *arg3 = (PLFLT *) 0 ;

4120

PLFLT *arg4 = (PLFLT *) 0 ;

4121

PLINT *arg5 = (PLINT *) 0 ;

4122

PLINT arg6 ;

4123

4124

(void)jenv;

4125

(void)jcls;

4126

{

4127

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4128

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4129

Alen = arg1;

4130

setup_array_1d_d( &arg2, jxdata, Alen );

4131

/* Could find no easy way to do this as part of freearg so I modified

4132

* the previous function so it ALWAYS mallocs and copies so that

4133

* the java array can be released immediately. */

4134

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4135

}

4136

{

4137

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

4138

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4139

printf("Vectors must be same length.\n");

4140

return;

4141

}

4142

setup_array_1d_d( &arg3, jydata, Alen );

4143

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

4144

}

4145

{

4146

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

4147

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

4148

printf("Vectors must be same length.\n");

4149

return;

4150

}

4151

setup_array_1d_d( &arg4, jydata, Alen );

4152

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

4153

}

4154

{

4155

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg5, 0 );

4156

if((*jenv)->GetArrayLength( jenv, jarg5 ) < Alen-1) {

4157

printf("Vector must be at least length of others minus 1.\n");

4158

return;

4159

}

4160

setup_array_1d_i( &arg5, jydata, Alen);

4161

(*jenv)->ReleaseIntArrayElements( jenv, jarg5, jydata, 0 );

4162

}

4163

arg6 = (PLINT)jarg6;

4164

plpoly3(arg1,arg2,arg3,arg4,arg5,arg6);

4165

4166

{

4167

free(arg2);

4168

}

4169

{

4170

free(arg3);

4171

}

4172

{

4173

free(arg4);

4174

}

4175

{

4176

free(arg5);

4177

}

4438

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpoly3(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jdoubleArray jarg4, jbooleanArray jarg5, jboolean jarg6) {

4439

PLINT arg1 ;

4440

PLFLT *arg2 = (PLFLT *) 0 ;

4441

PLFLT *arg3 = (PLFLT *) 0 ;

4442

PLFLT *arg4 = (PLFLT *) 0 ;

4443

PLBOOL *arg5 = (PLBOOL *) 0 ;

4444

PLBOOL arg6 ;

4445

4446

(void)jenv;

4447

(void)jcls;

4448

{

4449

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

4450

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

4451

Alen = arg1;

4452

setup_array_1d_d( &arg2, jxdata, Alen );

4453

/* Could find no easy way to do this as part of freearg so I modified

4454

* the previous function so it ALWAYS mallocs and copies so that

4455

* the java array can be released immediately. */

4456

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

4457

}

4458

{

4459

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

4460

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4461

printf("Vectors must be same length.\n");

4462

return;

4463

}

4464

setup_array_1d_d( &arg3, jydata, Alen );

4465

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

4466

}

4467

{

4468

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

4469

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

4470

printf("Vectors must be same length.\n");

4471

return;

4472

}

4473

setup_array_1d_d( &arg4, jydata, Alen );

4474

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

4475

}

4476

{

4477

jboolean *jydata = (*jenv)->GetBooleanArrayElements( jenv, jarg5, 0 );

4478

if((*jenv)->GetArrayLength( jenv, jarg5 ) < Alen-1) {

4479

printf("Vector must be at least length of others minus 1.\n");

4480

return;

4481

}

4482

setup_array_1d_b( &arg5, jydata, Alen);

4483

(*jenv)->ReleaseBooleanArrayElements( jenv, jarg5, jydata, 0 );

4484

}

4485

arg6 = jarg6 ? 1 : 0;

4486

plpoly3(arg1,arg2,arg3,arg4,arg5,arg6);

4487

4488

{

4489

free(arg2);

4490

}

4491

{

4492

free(arg3);

4493

}

4494

{

4495

free(arg4);

4496

}

4497

{

4498

free(arg5);

4499

}

4178

4500

}

4179

4501

4180

4502

4181

4503

#define _doc_plprec "Set the floating point precision (in number of places) in numeric labels."

4182

4504

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plprec(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

4183

PLINT arg1 ;

4184

PLINT arg2 ;

4185

4186

(void)jenv;

4187

(void)jcls;

4188

arg1 = (PLINT)jarg1;

4189

arg2 = (PLINT)jarg2;

4190

plprec(arg1,arg2);

4191

4505

PLINT arg1 ;

4506

PLINT arg2 ;

4507

4508

(void)jenv;

4509

(void)jcls;

4510

arg1 = (PLINT)jarg1;

4511

arg2 = (PLINT)jarg2;

4512

plprec(arg1,arg2);

4513

4192

4514

}

4193

4515

4194

4516

4195

4517

#define _doc_plpsty "Set fill pattern, using one of the predefined patterns."

4196

4518

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plpsty(JNIEnv *jenv, jclass jcls, jint jarg1) {

4197

PLINT arg1 ;

4198

4199

(void)jenv;

4200

(void)jcls;

4201

arg1 = (PLINT)jarg1;

4202

plpsty(arg1);

4203

4519

PLINT arg1 ;

4520

4521

(void)jenv;

4522

(void)jcls;

4523

arg1 = (PLINT)jarg1;

4524

plpsty(arg1);

4525

4204

4526

}

4205

4527

4206

4528

4207

4529

#define _doc_plptex "Print \"text\" at world cooordinate (x,y)."

4208

4530

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plptex(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jstring jarg6) {

4209

PLFLT arg1 ;

4210

PLFLT arg2 ;

4211

PLFLT arg3 ;

4212

PLFLT arg4 ;

4213

PLFLT arg5 ;

4214

char *arg6 ;

4215

4216

(void)jenv;

4217

(void)jcls;

4218

arg1 = (PLFLT)jarg1;

4219

arg2 = (PLFLT)jarg2;

4220

arg3 = (PLFLT)jarg3;

4221

arg4 = (PLFLT)jarg4;

4222

arg5 = (PLFLT)jarg5;

4223

{

4224

arg6 = 0;

4225

if (jarg6) {

4226

arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);

4227

if (!arg6) return ;

4228

}

4229

}

4230

plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);

4231

4232

{

4233

if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, arg6);

4234

}

4531

PLFLT arg1 ;

4532

PLFLT arg2 ;

4533

PLFLT arg3 ;

4534

PLFLT arg4 ;

4535

PLFLT arg5 ;

4536

char *arg6 = (char *) 0 ;

4537

4538

(void)jenv;

4539

(void)jcls;

4540

arg1 = (PLFLT)jarg1;

4541

arg2 = (PLFLT)jarg2;

4542

arg3 = (PLFLT)jarg3;

4543

arg4 = (PLFLT)jarg4;

4544

arg5 = (PLFLT)jarg5;

4545

arg6 = 0;

4546

if (jarg6) {

4547

arg6 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg6, 0);

4548

if (!arg6) return ;

4549

}

4550

plptex(arg1,arg2,arg3,arg4,arg5,(char const *)arg6);

4551

4552

if (arg6) (*jenv)->ReleaseStringUTFChars(jenv, jarg6, arg6);

4235

4553

}

4236

4554

4237

4555

4238

4556

#define _doc_plreplot "Replay contents of plot buffer to current device/file."

4239

4557

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plreplot(JNIEnv *jenv, jclass jcls) {

4240

(void)jenv;

4241

(void)jcls;

4242

plreplot();

4243

4558

(void)jenv;

4559

(void)jcls;

4560

plreplot();

4561

4562

}

4563

4564

4565

#define _doc_plrgbhls "Transform from RGB to HLS form of colours"

4566

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plrgbhls(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6) {

4567

PLFLT arg1 ;

4568

PLFLT arg2 ;

4569

PLFLT arg3 ;

4570

PLFLT *arg4 = (PLFLT *) 0 ;

4571

PLFLT *arg5 = (PLFLT *) 0 ;

4572

PLFLT *arg6 = (PLFLT *) 0 ;

4573

PLFLT temp4 ;

4574

PLFLT temp5 ;

4575

PLFLT temp6 ;

4576

4577

(void)jenv;

4578

(void)jcls;

4579

arg1 = (PLFLT)jarg1;

4580

arg2 = (PLFLT)jarg2;

4581

arg3 = (PLFLT)jarg3;

4582

{

4583

if (!jarg4) {

4584

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

4585

return ;

4586

}

4587

if ((*jenv)->GetArrayLength(jenv, jarg4) == 0) {

4588

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

4589

return ;

4590

}

4591

arg4 = &temp4;

4592

}

4593

{

4594

if (!jarg5) {

4595

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

4596

return ;

4597

}

4598

if ((*jenv)->GetArrayLength(jenv, jarg5) == 0) {

4599

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

4600

return ;

4601

}

4602

arg5 = &temp5;

4603

}

4604

{

4605

if (!jarg6) {

4606

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

4607

return ;

4608

}

4609

if ((*jenv)->GetArrayLength(jenv, jarg6) == 0) {

4610

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

4611

return ;

4612

}

4613

arg6 = &temp6;

4614

}

4615

plrgbhls(arg1,arg2,arg3,arg4,arg5,arg6);

4616

4617

{

4618

jdouble jvalue = (jdouble)temp4;

4619

(*jenv)->SetDoubleArrayRegion(jenv, jarg4, 0, 1, &jvalue);

4620

}

4621

{

4622

jdouble jvalue = (jdouble)temp5;

4623

(*jenv)->SetDoubleArrayRegion(jenv, jarg5, 0, 1, &jvalue);

4624

}

4625

{

4626

jdouble jvalue = (jdouble)temp6;

4627

(*jenv)->SetDoubleArrayRegion(jenv, jarg6, 0, 1, &jvalue);

4628

}

4629

4630

4631

4244

4632

}

4245

4633

4246

4634

4247

4635

#define _doc_plschr "Set character height."

4248

4636

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plschr(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {

4249

PLFLT arg1 ;

4250

PLFLT arg2 ;

4251

4252

(void)jenv;

4253

(void)jcls;

4254

arg1 = (PLFLT)jarg1;

4255

arg2 = (PLFLT)jarg2;

4256

plschr(arg1,arg2);

4257

4637

PLFLT arg1 ;

4638

PLFLT arg2 ;

4639

4640

(void)jenv;

4641

(void)jcls;

4642

arg1 = (PLFLT)jarg1;

4643

arg2 = (PLFLT)jarg2;

4644

plschr(arg1,arg2);

4645

4258

4646

}

4259

4647

4260

4648

4261

4649

#define _doc_plscmap0 "Set color map 0 colors by 8 bit RGB values."

4262

4650

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {

4263

PLINT *arg1 = (PLINT *) 0 ;

4264

PLINT *arg2 = (PLINT *) 0 ;

4265

PLINT *arg3 = (PLINT *) 0 ;

4266

PLINT arg4 ;

4267

4268

(void)jenv;

4269

(void)jcls;

4270

{

4271

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

4272

Alen = (*jenv)->GetArrayLength( jenv, jarg1);

4273

setup_array_1d_i( &arg1, jydata, Alen);

4274

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );

4275

}

4276

{

4277

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg2, 0 );

4278

if((*jenv)->GetArrayLength( jenv, jarg2 ) != Alen) {

4279

printf("Vectors must be same length.\n");

4280

return;

4281

}

4282

setup_array_1d_i( &arg2, jydata, Alen);

4283

(*jenv)->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );

4284

}

4285

{

4286

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

4287

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4288

printf("Vectors must be same length.\n");

4289

return;

4290

}

4291

setup_array_1d_i( &arg3, jydata, Alen);

4292

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

4293

}

4294

plscmap0(arg1,arg2,arg3,arg4);

4295

4296

{

4297

free(arg1);

4298

}

4299

{

4300

free(arg2);

4301

}

4302

{

4303

free(arg3);

4304

}

4651

PLINT *arg1 = (PLINT *) 0 ;

4652

PLINT *arg2 = (PLINT *) 0 ;

4653

PLINT *arg3 = (PLINT *) 0 ;

4654

PLINT arg4 ;

4655

4656

(void)jenv;

4657

(void)jcls;

4658

{

4659

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

4660

Alen = (*jenv)->GetArrayLength( jenv, jarg1);

4661

setup_array_1d_i( &arg1, jydata, Alen);

4662

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );

4663

}

4664

{

4665

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg2, 0 );

4666

if((*jenv)->GetArrayLength( jenv, jarg2 ) != Alen) {

4667

printf("Vectors must be same length.\n");

4668

return;

4669

}

4670

setup_array_1d_i( &arg2, jydata, Alen);

4671

(*jenv)->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );

4672

}

4673

{

4674

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

4675

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4676

printf("Vectors must be same length.\n");

4677

return;

4678

}

4679

arg4 = (*jenv)->GetArrayLength( jenv, jarg3 );

4680

setup_array_1d_i( &arg3, jydata, Alen);

4681

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

4682

}

4683

plscmap0(arg1,arg2,arg3,arg4);

4684

4685

{

4686

free(arg1);

4687

}

4688

{

4689

free(arg2);

4690

}

4691

{

4692

free(arg3);

4693

}

4305

4694

}

4306

4695

4307

4696

4308

4697

#define _doc_plscmap0n "Set number of colors in cmap 0."

4309

4698

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap0n(JNIEnv *jenv, jclass jcls, jint jarg1) {

4310

PLINT arg1 ;

4311

4312

(void)jenv;

4313

(void)jcls;

4314

arg1 = (PLINT)jarg1;

4315

plscmap0n(arg1);

4316

4699

PLINT arg1 ;

4700

4701

(void)jenv;

4702

(void)jcls;

4703

arg1 = (PLINT)jarg1;

4704

plscmap0n(arg1);

4705

4317

4706

}

4318

4707

4319

4708

4320

4709

#define _doc_plscmap1 "Set color map 1 colors by 8 bit RGB values."

4321

4710

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg2, jintArray jarg3) {

4322

PLINT *arg1 = (PLINT *) 0 ;

4323

PLINT *arg2 = (PLINT *) 0 ;

4324

PLINT *arg3 = (PLINT *) 0 ;

4325

PLINT arg4 ;

4326

4327

(void)jenv;

4328

(void)jcls;

4329

{

4330

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

4331

Alen = (*jenv)->GetArrayLength( jenv, jarg1);

4332

setup_array_1d_i( &arg1, jydata, Alen);

4333

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );

4334

}

4335

{

4336

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg2, 0 );

4337

if((*jenv)->GetArrayLength( jenv, jarg2 ) != Alen) {

4338

printf("Vectors must be same length.\n");

4339

return;

4340

}

4341

setup_array_1d_i( &arg2, jydata, Alen);

4342

(*jenv)->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );

4343

}

4344

{

4345

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

4346

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4347

printf("Vectors must be same length.\n");

4348

return;

4349

}

4350

setup_array_1d_i( &arg3, jydata, Alen);

4351

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

4352

}

4353

plscmap1(arg1,arg2,arg3,arg4);

4354

4355

{

4356

free(arg1);

4357

}

4358

{

4359

free(arg2);

4360

}

4361

{

4362

free(arg3);

4363

}

4711

PLINT *arg1 = (PLINT *) 0 ;

4712

PLINT *arg2 = (PLINT *) 0 ;

4713

PLINT *arg3 = (PLINT *) 0 ;

4714

PLINT arg4 ;

4715

4716

(void)jenv;

4717

(void)jcls;

4718

{

4719

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

4720

Alen = (*jenv)->GetArrayLength( jenv, jarg1);

4721

setup_array_1d_i( &arg1, jydata, Alen);

4722

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jydata, 0 );

4723

}

4724

{

4725

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg2, 0 );

4726

if((*jenv)->GetArrayLength( jenv, jarg2 ) != Alen) {

4727

printf("Vectors must be same length.\n");

4728

return;

4729

}

4730

setup_array_1d_i( &arg2, jydata, Alen);

4731

(*jenv)->ReleaseIntArrayElements( jenv, jarg2, jydata, 0 );

4732

}

4733

{

4734

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

4735

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

4736

printf("Vectors must be same length.\n");

4737

return;

4738

}

4739

arg4 = (*jenv)->GetArrayLength( jenv, jarg3 );

4740

setup_array_1d_i( &arg3, jydata, Alen);

4741

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

4742

}

4743

plscmap1(arg1,arg2,arg3,arg4);

4744

4745

{

4746

free(arg1);

4747

}

4748

{

4749

free(arg2);

4750

}

4751

{

4752

free(arg3);

4753

}

4364

4754

}

4365

4755

4366

4756

4367

4757

#define _doc_plscmap1l "Set color map 1 colors using a piece-wise linear relationship between intensity [0,1] (cmap 1 index) and position in HLS or RGB color space."

4368

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1l(JNIEnv *jenv, jclass jcls, jint jarg1, jdoubleArray jarg2, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jintArray jarg7) {

4369

PLINT arg1 ;

4370

PLINT arg2 ;

4371

PLFLT *arg3 = (PLFLT *) 0 ;

4372

PLFLT *arg4 = (PLFLT *) 0 ;

4373

PLFLT *arg5 = (PLFLT *) 0 ;

4374

PLFLT *arg6 = (PLFLT *) 0 ;

4375

PLINT *arg7 = (PLINT *) 0 ;

4376

4377

(void)jenv;

4378

(void)jcls;

4379

arg1 = (PLINT)jarg1;

4380

{

4381

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

4382

arg2 = (*jenv)->GetArrayLength( jenv, jarg2);

4383

Alen = arg2;

4384

setup_array_1d_d( &arg3, jxdata, Alen );

4385

/* Could find no easy way to do this as part of freearg so I modified

4386

* the previous function so it ALWAYS mallocs and copies so that

4387

* the java array can be released immediately. */

4388

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jxdata, 0 );

4389

}

4390

{

4391

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

4392

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

4393

printf("Vectors must be same length.\n");

4394

return;

4395

}

4396

setup_array_1d_d( &arg4, jydata, Alen );

4397

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

4398

}

4399

{

4400

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg5, 0 );

4401

if((*jenv)->GetArrayLength( jenv, jarg5 ) != Alen) {

4402

printf("Vectors must be same length.\n");

4403

return;

4404

}

4405

setup_array_1d_d( &arg5, jydata, Alen );

4406

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg5, jydata, 0 );

4407

}

4408

{

4409

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg6, 0 );

4410

if((*jenv)->GetArrayLength( jenv, jarg6 ) != Alen) {

4411

printf("Vectors must be same length.\n");

4412

return;

4413

}

4414

setup_array_1d_d( &arg6, jydata, Alen );

4415

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg6, jydata, 0 );

4416

}

4417

{

4418

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg7, 0 );

4419

if((*jenv)->GetArrayLength( jenv, jarg7 ) < Alen-1) {

4420

printf("Vector must be at least length of others minus 1.\n");

4421

return;

4422

}

4423

setup_array_1d_i( &arg7, jydata, Alen);

4424

(*jenv)->ReleaseIntArrayElements( jenv, jarg7, jydata, 0 );

4425

}

4426

plscmap1l(arg1,arg2,arg3,arg4,arg5,arg6,arg7);

4427

4428

{

4429

free(arg3);

4430

}

4431

{

4432

free(arg4);

4433

}

4434

{

4435

free(arg5);

4436

}

4437

{

4438

free(arg6);

4439

}

4440

{

4441

free(arg7);

4442

}

4758

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1l(JNIEnv *jenv, jclass jcls, jboolean jarg1, jdoubleArray jarg2, jdoubleArray jarg4, jdoubleArray jarg5, jdoubleArray jarg6, jbooleanArray jarg7) {

4759

PLBOOL arg1 ;

4760

PLINT arg2 ;

4761

PLFLT *arg3 = (PLFLT *) 0 ;

4762

PLFLT *arg4 = (PLFLT *) 0 ;

4763

PLFLT *arg5 = (PLFLT *) 0 ;

4764

PLFLT *arg6 = (PLFLT *) 0 ;

4765

PLBOOL *arg7 = (PLBOOL *) 0 ;

4766

4767

(void)jenv;

4768

(void)jcls;

4769

arg1 = jarg1 ? 1 : 0;

4770

{

4771

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

4772

arg2 = (*jenv)->GetArrayLength( jenv, jarg2);

4773

Alen = arg2;

4774

setup_array_1d_d( &arg3, jxdata, Alen );

4775

/* Could find no easy way to do this as part of freearg so I modified

4776

* the previous function so it ALWAYS mallocs and copies so that

4777

* the java array can be released immediately. */

4778

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jxdata, 0 );

4779

}

4780

{

4781

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg4, 0 );

4782

if((*jenv)->GetArrayLength( jenv, jarg4 ) != Alen) {

4783

printf("Vectors must be same length.\n");

4784

return;

4785

}

4786

setup_array_1d_d( &arg4, jydata, Alen );

4787

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg4, jydata, 0 );

4788

}

4789

{

4790

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg5, 0 );

4791

if((*jenv)->GetArrayLength( jenv, jarg5 ) != Alen) {

4792

printf("Vectors must be same length.\n");

4793

return;

4794

}

4795

setup_array_1d_d( &arg5, jydata, Alen );

4796

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg5, jydata, 0 );

4797

}

4798

{

4799

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg6, 0 );

4800

if((*jenv)->GetArrayLength( jenv, jarg6 ) != Alen) {

4801

printf("Vectors must be same length.\n");

4802

return;

4803

}

4804

setup_array_1d_d( &arg6, jydata, Alen );

4805

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg6, jydata, 0 );

4806

}

4807

{

4808

jboolean *jydata = (*jenv)->GetBooleanArrayElements( jenv, jarg7, 0 );

4809

if((*jenv)->GetArrayLength( jenv, jarg7 ) < Alen-1) {

4810

printf("Vector must be at least length of others minus 1.\n");

4811

return;

4812

}

4813

setup_array_1d_b( &arg7, jydata, Alen);

4814

(*jenv)->ReleaseBooleanArrayElements( jenv, jarg7, jydata, 0 );

4815

}

4816

plscmap1l(arg1,arg2,arg3,arg4,arg5,arg6,arg7);

4817

4818

{

4819

free(arg3);

4820

}

4821

{

4822

free(arg4);

4823

}

4824

{

4825

free(arg5);

4826

}

4827

{

4828

free(arg6);

4829

}

4830

{

4831

free(arg7);

4832

}

4443

4833

}

4444

4834

4445

4835

4446

4836

#define _doc_plscmap1n "Set number of colors in cmap 1."

4447

4837

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscmap1n(JNIEnv *jenv, jclass jcls, jint jarg1) {

4448

PLINT arg1 ;

4449

4450

(void)jenv;

4451

(void)jcls;

4452

arg1 = (PLINT)jarg1;

4453

plscmap1n(arg1);

4454

4838

PLINT arg1 ;

4839

4840

(void)jenv;

4841

(void)jcls;

4842

arg1 = (PLINT)jarg1;

4843

plscmap1n(arg1);

4844

4455

4845

}

4456

4846

4457

4847

4458

4848

#define _doc_plscol0 "Set 8-bit RGB value in cmap 0."

4459

4849

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscol0(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4) {

4460

PLINT arg1 ;

4461

PLINT arg2 ;

4462

PLINT arg3 ;

4463

PLINT arg4 ;

4464

4465

(void)jenv;

4466

(void)jcls;

4467

arg1 = (PLINT)jarg1;

4468

arg2 = (PLINT)jarg2;

4469

arg3 = (PLINT)jarg3;

4470

arg4 = (PLINT)jarg4;

4471

plscol0(arg1,arg2,arg3,arg4);

4472

4850

PLINT arg1 ;

4851

PLINT arg2 ;

4852

PLINT arg3 ;

4853

PLINT arg4 ;

4854

4855

(void)jenv;

4856

(void)jcls;

4857

arg1 = (PLINT)jarg1;

4858

arg2 = (PLINT)jarg2;

4859

arg3 = (PLINT)jarg3;

4860

arg4 = (PLINT)jarg4;

4861

plscol0(arg1,arg2,arg3,arg4);

4862

4473

4863

}

4474

4864

4475

4865

4476

4866

#define _doc_plscolbg "Set the background color using 8-bit RGB value."

4477

4867

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolbg(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {

4478

PLINT arg1 ;

4479

PLINT arg2 ;

4480

PLINT arg3 ;

4481

4482

(void)jenv;

4483

(void)jcls;

4484

arg1 = (PLINT)jarg1;

4485

arg2 = (PLINT)jarg2;

4486

arg3 = (PLINT)jarg3;

4487

plscolbg(arg1,arg2,arg3);

4488

4868

PLINT arg1 ;

4869

PLINT arg2 ;

4870

PLINT arg3 ;

4871

4872

(void)jenv;

4873

(void)jcls;

4874

arg1 = (PLINT)jarg1;

4875

arg2 = (PLINT)jarg2;

4876

arg3 = (PLINT)jarg3;

4877

plscolbg(arg1,arg2,arg3);

4878

4489

4879

}

4490

4880

4491

4881

4492

4882

#define _doc_plscolor "Globally turn color output on/off."

4493

4883

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscolor(JNIEnv *jenv, jclass jcls, jint jarg1) {

4494

PLINT arg1 ;

4495

4496

(void)jenv;

4497

(void)jcls;

4498

arg1 = (PLINT)jarg1;

4499

plscolor(arg1);

4500

4884

PLINT arg1 ;

4885

4886

(void)jenv;

4887

(void)jcls;

4888

arg1 = (PLINT)jarg1;

4889

plscolor(arg1);

4890

4501

4891

}

4502

4892

4503

4893

4504

4894

#define _doc_plscompression "Set the compression level."

4505

4895

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plscompression(JNIEnv *jenv, jclass jcls, jint jarg1) {

4506

PLINT arg1 ;

4507

4508

(void)jenv;

4509

(void)jcls;

4510

arg1 = (PLINT)jarg1;

4511

plscompression(arg1);

4512

4896

PLINT arg1 ;

4897

4898

(void)jenv;

4899

(void)jcls;

4900

arg1 = (PLINT)jarg1;

4901

plscompression(arg1);

4902

4513

4903

}

4514

4904

4515

4905

4516

4906

#define _doc_plsdev "Set the device (keyword) name."

4517

4907

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdev(JNIEnv *jenv, jclass jcls, jstring jarg1) {

4518

char *arg1 ;

4519

4520

(void)jenv;

4521

(void)jcls;

4522

{

4523

arg1 = 0;

4524

if (jarg1) {

4525

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

4526

if (!arg1) return ;

4527

}

4528

}

4529

plsdev((char const *)arg1);

4530

4531

{

4532

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

4533

}

4908

char *arg1 = (char *) 0 ;

4909

4910

(void)jenv;

4911

(void)jcls;

4912

arg1 = 0;

4913

if (jarg1) {

4914

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

4915

if (!arg1) return ;

4916

}

4917

plsdev((char const *)arg1);

4918

4919

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

4534

4920

}

4535

4921

4536

4922

4537

4923

#define _doc_plsdidev "Set window into device space using margin, aspect ratio, and justification."

4538

4924

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdidev(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

4539

PLFLT arg1 ;

4540

PLFLT arg2 ;

4541

PLFLT arg3 ;

4542

PLFLT arg4 ;

4543

4544

(void)jenv;

4545

(void)jcls;

4546

arg1 = (PLFLT)jarg1;

4547

arg2 = (PLFLT)jarg2;

4548

arg3 = (PLFLT)jarg3;

4549

arg4 = (PLFLT)jarg4;

4550

plsdidev(arg1,arg2,arg3,arg4);

4551

4925

PLFLT arg1 ;

4926

PLFLT arg2 ;

4927

PLFLT arg3 ;

4928

PLFLT arg4 ;

4929

4930

(void)jenv;

4931

(void)jcls;

4932

arg1 = (PLFLT)jarg1;

4933

arg2 = (PLFLT)jarg2;

4934

arg3 = (PLFLT)jarg3;

4935

arg4 = (PLFLT)jarg4;

4936

plsdidev(arg1,arg2,arg3,arg4);

4937

4552

4938

}

4553

4939

4554

4940

4555

4941

#define _doc_plsdimap "Set up transformation from metafile coordinates."

4556

4942

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdimap(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3, jint jarg4, jdouble jarg5, jdouble jarg6) {

4557

PLINT arg1 ;

4558

PLINT arg2 ;

4559

PLINT arg3 ;

4560

PLINT arg4 ;

4561

PLFLT arg5 ;

4562

PLFLT arg6 ;

4563

4564

(void)jenv;

4565

(void)jcls;

4566

arg1 = (PLINT)jarg1;

4567

arg2 = (PLINT)jarg2;

4568

arg3 = (PLINT)jarg3;

4569

arg4 = (PLINT)jarg4;

4570

arg5 = (PLFLT)jarg5;

4571

arg6 = (PLFLT)jarg6;

4572

plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);

4573

4943

PLINT arg1 ;

4944

PLINT arg2 ;

4945

PLINT arg3 ;

4946

PLINT arg4 ;

4947

PLFLT arg5 ;

4948

PLFLT arg6 ;

4949

4950

(void)jenv;

4951

(void)jcls;

4952

arg1 = (PLINT)jarg1;

4953

arg2 = (PLINT)jarg2;

4954

arg3 = (PLINT)jarg3;

4955

arg4 = (PLINT)jarg4;

4956

arg5 = (PLFLT)jarg5;

4957

arg6 = (PLFLT)jarg6;

4958

plsdimap(arg1,arg2,arg3,arg4,arg5,arg6);

4959

4574

4960

}

4575

4961

4576

4962

4577

4963

#define _doc_plsdiori "Set plot orientation, specifying rotation in units of pi/2."

4578

4964

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiori(JNIEnv *jenv, jclass jcls, jdouble jarg1) {

4579

PLFLT arg1 ;

4580

4581

(void)jenv;

4582

(void)jcls;

4583

arg1 = (PLFLT)jarg1;

4584

plsdiori(arg1);

4585

4965

PLFLT arg1 ;

4966

4967

(void)jenv;

4968

(void)jcls;

4969

arg1 = (PLFLT)jarg1;

4970

plsdiori(arg1);

4971

4586

4972

}

4587

4973

4588

4974

4589

4975

#define _doc_plsdiplt "Set window into plot space."

4590

4976

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiplt(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

4591

PLFLT arg1 ;

4592

PLFLT arg2 ;

4593

PLFLT arg3 ;

4594

PLFLT arg4 ;

4595

4596

(void)jenv;

4597

(void)jcls;

4598

arg1 = (PLFLT)jarg1;

4599

arg2 = (PLFLT)jarg2;

4600

arg3 = (PLFLT)jarg3;

4601

arg4 = (PLFLT)jarg4;

4602

plsdiplt(arg1,arg2,arg3,arg4);

4603

4977

PLFLT arg1 ;

4978

PLFLT arg2 ;

4979

PLFLT arg3 ;

4980

PLFLT arg4 ;

4981

4982

(void)jenv;

4983

(void)jcls;

4984

arg1 = (PLFLT)jarg1;

4985

arg2 = (PLFLT)jarg2;

4986

arg3 = (PLFLT)jarg3;

4987

arg4 = (PLFLT)jarg4;

4988

plsdiplt(arg1,arg2,arg3,arg4);

4989

4604

4990

}

4605

4991

4606

4992

4607

4993

#define _doc_plsdiplz "Set window into plot space incrementally (zoom)."

4608

4994

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsdiplz(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

4609

PLFLT arg1 ;

4610

PLFLT arg2 ;

4611

PLFLT arg3 ;

4612

PLFLT arg4 ;

4613

4614

(void)jenv;

4615

(void)jcls;

4616

arg1 = (PLFLT)jarg1;

4617

arg2 = (PLFLT)jarg2;

4618

arg3 = (PLFLT)jarg3;

4619

arg4 = (PLFLT)jarg4;

4620

plsdiplz(arg1,arg2,arg3,arg4);

4621

4995

PLFLT arg1 ;

4996

PLFLT arg2 ;

4997

PLFLT arg3 ;

4998

PLFLT arg4 ;

4999

5000

(void)jenv;

5001

(void)jcls;

5002

arg1 = (PLFLT)jarg1;

5003

arg2 = (PLFLT)jarg2;

5004

arg3 = (PLFLT)jarg3;

5005

arg4 = (PLFLT)jarg4;

5006

plsdiplz(arg1,arg2,arg3,arg4);

5007

4622

5008

}

4623

5009

4624

5010

4625

5011

#define _doc_plsesc "Set the escape character for text strings."

4626

5012

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsesc(JNIEnv *jenv, jclass jcls, jchar jarg1) {

4627

char arg1 ;

4628

4629

(void)jenv;

4630

(void)jcls;

4631

arg1 = (char)jarg1;

4632

plsesc(arg1);

4633

5013

char arg1 ;

5014

5015

(void)jenv;

5016

(void)jcls;

5017

arg1 = (char)jarg1;

5018

plsesc(arg1);

5019

4634

5020

}

4635

5021

4636

5022

4637

5023

#define _doc_plsetopt "Process input strings, treating them as an option and argument pair. The first is for the external API, the second the work routine declared here for backward compatibilty."

4638

5024

JNIEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plsetopt(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {

4639

jint jresult = 0 ;

4640

char *arg1 ;

4641

char *arg2 ;

4642

PLINT result;

4643

4644

(void)jenv;

4645

(void)jcls;

4646

{

4647

arg1 = 0;

4648

if (jarg1) {

4649

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

4650

if (!arg1) return 0;

4651

}

4652

}

4653

{

4654

arg2 = 0;

4655

if (jarg2) {

4656

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

4657

if (!arg2) return 0;

4658

}

4659

}

4660

result = (PLINT)plsetopt(arg1,arg2);

4661

4662

jresult = (jint)result;

4663

{

4664

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

4665

}

4666

{

4667

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

4668

}

4669

return jresult;

5025

jint jresult = 0 ;

5026

char *arg1 = (char *) 0 ;

5027

char *arg2 = (char *) 0 ;

5028

PLINT result;

5029

5030

(void)jenv;

5031

(void)jcls;

5032

arg1 = 0;

5033

if (jarg1) {

5034

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

5035

if (!arg1) return 0;

5036

}

5037

arg2 = 0;

5038

if (jarg2) {

5039

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

5040

if (!arg2) return 0;

5041

}

5042

result = (PLINT)plsetopt(arg1,arg2);

5043

5044

jresult = (jint)result;

5045

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

5046

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

5047

return jresult;

4670

5048

}

4671

5049

4672

5050

4673

5051

#define _doc_plsfam "Set family file parameters."

4674

5052

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfam(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jint jarg3) {

4675

PLINT arg1 ;

4676

PLINT arg2 ;

4677

PLINT arg3 ;

4678

4679

(void)jenv;

4680

(void)jcls;

4681

arg1 = (PLINT)jarg1;

4682

arg2 = (PLINT)jarg2;

4683

arg3 = (PLINT)jarg3;

4684

plsfam(arg1,arg2,arg3);

4685

5053

PLINT arg1 ;

5054

PLINT arg2 ;

5055

PLINT arg3 ;

5056

5057

(void)jenv;

5058

(void)jcls;

5059

arg1 = (PLINT)jarg1;

5060

arg2 = (PLINT)jarg2;

5061

arg3 = (PLINT)jarg3;

5062

plsfam(arg1,arg2,arg3);

5063

5064

}

5065

5066

5067

#define _doc_plsfci "Set FCI (font characterization integer)."

5068

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfci(JNIEnv *jenv, jclass jcls, jlong jarg1) {

5069

PLUNICODE arg1 ;

5070

5071

(void)jenv;

5072

(void)jcls;

5073

arg1 = (PLUNICODE)jarg1;

5074

plsfci(arg1);

5075

4686

5076

}

4687

5077

4688

5078

4689

5079

#define _doc_plsfnam "Set the output file name."

4690

5080

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsfnam(JNIEnv *jenv, jclass jcls, jstring jarg1) {

4691

char *arg1 ;

4692

4693

(void)jenv;

4694

(void)jcls;

4695

{

4696

arg1 = 0;

4697

if (jarg1) {

4698

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

4699

if (!arg1) return ;

4700

}

4701

}

4702

plsfnam((char const *)arg1);

4703

4704

{

4705

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

4706

}

5081

char *arg1 = (char *) 0 ;

5082

5083

(void)jenv;

5084

(void)jcls;

5085

arg1 = 0;

5086

if (jarg1) {

5087

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

5088

if (!arg1) return ;

5089

}

5090

plsfnam((char const *)arg1);

5091

5092

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

4707

5093

}

4708

5094

4709

5095

4710

5096

#define _doc_plshades "Shade regions with continuous range of colours."

4711

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshades(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdoubleArray jarg9, jint jarg11, jint jarg12, jint jarg13, jint jarg15, jobjectArray jarg16, jobjectArray jarg17) {

4712

PLFLT **arg1 = (PLFLT **) 0 ;

4713

PLINT arg2 ;

4714

PLINT arg3 ;

4715

defined_func arg4 ;

4716

PLFLT arg5 ;

4717

PLFLT arg6 ;

4718

PLFLT arg7 ;

4719

PLFLT arg8 ;

4720

PLFLT *arg9 = (PLFLT *) 0 ;

4721

PLINT arg10 ;

4722

PLINT arg11 ;

4723

PLINT arg12 ;

4724

PLINT arg13 ;

4725

fill_func arg14 ;

4726

PLINT arg15 ;

4727

pltr_func arg16 ;

4728

PLPointer arg17 = (PLPointer) 0 ;

4729

4730

(void)jenv;

4731

(void)jcls;

4732

{

4733

arg4 = NULL;

4734

}

4735

{

4736

arg14 = plfill;

4737

}

4738

{

4739

jdouble **adat;

4740

jobject *ai;

4741

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

4742

int ny = -1;

4743

int i, j;

4744

ai = (jobject *) malloc( nx * sizeof(jobject) );

4745

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

4746

4747

for( i=0; i < nx; i++ )

4748

{

4749

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

4750

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

4751

4752

if (ny == -1)

4753

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

4754

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

4755

printf( "Misshapen a array.\n" );

4756

for( j=0; j <= i; j++ )

4757

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

4758

free(adat);

4759

free(ai);

4760

return;

4761

}

4762

}

4763

4764

Xlen = nx;

4765

Ylen = ny;

4766

setup_array_2d_d( &arg1, adat, nx, ny );

4767

arg2 = nx;

4768

arg3 = ny;

4769

for( i=0; i < nx; i++ ) {

4770

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4771

(*jenv)->DeleteLocalRef(jenv, ai[i]);

4772

}

4773

4774

free(adat);

4775

free(ai);

4776

4777

}

4778

arg5 = (PLFLT)jarg5;

4779

arg6 = (PLFLT)jarg6;

4780

arg7 = (PLFLT)jarg7;

4781

arg8 = (PLFLT)jarg8;

4782

{

4783

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg9, 0 );

4784

arg10 = (*jenv)->GetArrayLength( jenv, jarg9 );

4785

setup_array_1d_d( &arg9, jxdata, arg10);

4786

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg9, jxdata, 0 );

4787

}

4788

arg11 = (PLINT)jarg11;

4789

arg12 = (PLINT)jarg12;

4790

arg13 = (PLINT)jarg13;

4791

arg15 = (PLINT)jarg15;

4792

{

4793

jdouble **adat;

4794

jobject *ai;

4795

int nx = (*jenv)->GetArrayLength( jenv, jarg16 );

4796

int ny = -1;

4797

int i, j;

4798

ai = (jobject *) malloc( nx * sizeof(jobject) );

4799

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

4800

4801

for( i=0; i < nx; i++ )

4802

{

4803

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg16, i );

4804

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

4805

4806

if (ny == -1)

4807

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

4808

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

4809

printf( "Misshapen a array.\n" );

4810

for( j=0; j <= i; j++ )

4811

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

4812

free(adat);

4813

free(ai);

4814

return;

4815

}

4816

}

4817

4818

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

4819

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

4820

printf( "X vector or matrix must match matrix dimensions.\n" );

4821

for( i=0; i < nx; i++ )

4822

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4823

free(adat);

4824

free(ai);

4825

return;

4826

}

4827

/* Store whether second dimension is unity. */

4828

Alen = ny;

4829

setup_array_2d_d( &xg, adat, nx, ny );

4830

for( i=0; i < nx; i++ ) {

4831

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4832

(*jenv)->DeleteLocalRef(jenv, ai[i]);

4833

}

4834

4835

free(adat);

4836

free(ai);

4837

arg16 = pltr2;

4838

4839

}

4840

{

4841

jdouble **adat;

4842

jobject *ai;

4843

int nx = (*jenv)->GetArrayLength( jenv, jarg17 );

4844

int ny = -1;

4845

int i, j;

4846

PLcGrid2 cgrid;

4847

ai = (jobject *) malloc( nx * sizeof(jobject) );

4848

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

4849

4850

for( i=0; i < nx; i++ )

4851

{

4852

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg17, i );

4853

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

4854

4855

if (ny == -1)

4856

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

4857

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

4858

printf( "Misshapen a array.\n" );

4859

for( j=0; j <= i; j++ )

4860

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

4861

free(adat);

4862

free(ai);

4863

return;

4864

}

4865

}

4866

4867

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

4868

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

4869

Xlen, nx, Ylen, Alen, ny );

4870

printf( "Y vector or matrix must match matrix dimensions.\n" );

4871

for( i=0; i < nx; i++ )

4872

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4873

free(adat);

4874

free(ai);

4875

return;

4876

}

4877

setup_array_2d_d( &yg, adat, nx, ny );

4878

for( i=0; i < nx; i++ ) {

4879

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4880

(*jenv)->DeleteLocalRef(jenv, ai[i]);

4881

}

4882

4883

free(adat);

4884

free(ai);

4885

cgrid.xg = xg;

4886

cgrid.yg = yg;

4887

cgrid.nx = nx;

4888

cgrid.ny = ny;

4889

arg17 = &cgrid;

4890

4891

}

4892

plshades(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);

4893

4894

{

4895

free(arg1[0]);

4896

free(arg1);

4897

}

4898

{

4899

free(arg9);

4900

}

4901

{

4902

free(xg[0]);

4903

free(xg);

4904

}

4905

{

4906

free(yg[0]);

4907

free(yg);

4908

}

5097

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshades(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdoubleArray jarg9, jint jarg11, jint jarg12, jint jarg13, jboolean jarg15, jobjectArray jarg16, jobjectArray jarg17) {

5098

PLFLT **arg1 = (PLFLT **) 0 ;

5099

PLINT arg2 ;

5100

PLINT arg3 ;

5101

defined_func arg4 ;

5102

PLFLT arg5 ;

5103

PLFLT arg6 ;

5104

PLFLT arg7 ;

5105

PLFLT arg8 ;

5106

PLFLT *arg9 = (PLFLT *) 0 ;

5107

PLINT arg10 ;

5108

PLINT arg11 ;

5109

PLINT arg12 ;

5110

PLINT arg13 ;

5111

fill_func arg14 ;

5112

PLBOOL arg15 ;

5113

pltr_func arg16 ;

5114

PLPointer arg17 = (PLPointer) 0 ;

5115

5116

(void)jenv;

5117

(void)jcls;

5118

{

5119

arg4 = NULL;

5120

}

5121

{

5122

arg14 = plfill;

5123

}

5124

{

5125

jdouble **adat;

5126

jobject *ai;

5127

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

5128

int ny = -1;

5129

int i, j;

5130

ai = (jobject *) malloc( nx * sizeof(jobject) );

5131

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5132

5133

for( i=0; i < nx; i++ )

5134

{

5135

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

5136

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5137

5138

if (ny == -1)

5139

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5140

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5141

printf( "Misshapen a array.\n" );

5142

for( j=0; j <= i; j++ )

5143

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5144

free(adat);

5145

free(ai);

5146

return;

5147

}

5148

}

5149

5150

Xlen = nx;

5151

Ylen = ny;

5152

setup_array_2d_d( &arg1, adat, nx, ny );

5153

arg2 = nx;

5154

arg3 = ny;

5155

for( i=0; i < nx; i++ ) {

5156

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5157

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5158

}

5159

5160

free(adat);

5161

free(ai);

5162

5163

}

5164

arg5 = (PLFLT)jarg5;

5165

arg6 = (PLFLT)jarg6;

5166

arg7 = (PLFLT)jarg7;

5167

arg8 = (PLFLT)jarg8;

5168

{

5169

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg9, 0 );

5170

arg10 = (*jenv)->GetArrayLength( jenv, jarg9 );

5171

setup_array_1d_d( &arg9, jxdata, arg10);

5172

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg9, jxdata, 0 );

5173

}

5174

arg11 = (PLINT)jarg11;

5175

arg12 = (PLINT)jarg12;

5176

arg13 = (PLINT)jarg13;

5177

arg15 = jarg15 ? 1 : 0;

5178

{

5179

jdouble **adat;

5180

jobject *ai;

5181

int nx = (*jenv)->GetArrayLength( jenv, jarg16 );

5182

int ny = -1;

5183

int i, j;

5184

ai = (jobject *) malloc( nx * sizeof(jobject) );

5185

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5186

5187

for( i=0; i < nx; i++ )

5188

{

5189

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg16, i );

5190

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5191

5192

if (ny == -1)

5193

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5194

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5195

printf( "Misshapen a array.\n" );

5196

for( j=0; j <= i; j++ )

5197

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5198

free(adat);

5199

free(ai);

5200

return;

5201

}

5202

}

5203

5204

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

5205

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

5206

printf( "X vector or matrix must match matrix dimensions.\n" );

5207

for( i=0; i < nx; i++ )

5208

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5209

free(adat);

5210

free(ai);

5211

return;

5212

}

5213

/* Store whether second dimension is unity. */

5214

Alen = ny;

5215

setup_array_2d_d( &xg, adat, nx, ny );

5216

for( i=0; i < nx; i++ ) {

5217

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5218

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5219

}

5220

5221

free(adat);

5222

free(ai);

5223

arg16 = pltr2;

5224

5225

}

5226

{

5227

jdouble **adat;

5228

jobject *ai;

5229

int nx = (*jenv)->GetArrayLength( jenv, jarg17 );

5230

int ny = -1;

5231

int i, j;

5232

PLcGrid2 cgrid;

5233

ai = (jobject *) malloc( nx * sizeof(jobject) );

5234

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5235

5236

for( i=0; i < nx; i++ )

5237

{

5238

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg17, i );

5239

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5240

5241

if (ny == -1)

5242

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5243

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5244

printf( "Misshapen a array.\n" );

5245

for( j=0; j <= i; j++ )

5246

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5247

free(adat);

5248

free(ai);

5249

return;

5250

}

5251

}

5252

5253

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

5254

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

5255

Xlen, nx, Ylen, Alen, ny );

5256

printf( "Y vector or matrix must match matrix dimensions.\n" );

5257

for( i=0; i < nx; i++ )

5258

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5259

free(adat);

5260

free(ai);

5261

return;

5262

}

5263

setup_array_2d_d( &yg, adat, nx, ny );

5264

for( i=0; i < nx; i++ ) {

5265

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5266

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5267

}

5268

5269

free(adat);

5270

free(ai);

5271

cgrid.xg = xg;

5272

cgrid.yg = yg;

5273

cgrid.nx = nx;

5274

cgrid.ny = ny;

5275

arg17 = &cgrid;

5276

5277

}

5278

plshades(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17);

5279

5280

{

5281

free(arg1[0]);

5282

free(arg1);

5283

}

5284

{

5285

free(arg9);

5286

}

5287

{

5288

free(xg[0]);

5289

free(xg);

5290

}

5291

{

5292

free(yg[0]);

5293

free(yg);

5294

}

4909

5295

}

4910

5296

4911

5297

4912

5298

#define _doc_plshade "Shade region with discrete colour, pattern fill."

4913

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshade(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jint jarg11, jdouble jarg12, jint jarg13, jint jarg14, jint jarg15, jint jarg16, jint jarg17, jint jarg19, jobjectArray jarg20, jobjectArray jarg21) {

4914

PLFLT **arg1 = (PLFLT **) 0 ;

4915

PLINT arg2 ;

4916

PLINT arg3 ;

4917

defined_func arg4 ;

4918

PLFLT arg5 ;

4919

PLFLT arg6 ;

4920

PLFLT arg7 ;

4921

PLFLT arg8 ;

4922

PLFLT arg9 ;

4923

PLFLT arg10 ;

4924

PLINT arg11 ;

4925

PLFLT arg12 ;

4926

PLINT arg13 ;

4927

PLINT arg14 ;

4928

PLINT arg15 ;

4929

PLINT arg16 ;

4930

PLINT arg17 ;

4931

fill_func arg18 ;

4932

PLINT arg19 ;

4933

pltr_func arg20 ;

4934

PLPointer arg21 = (PLPointer) 0 ;

4935

4936

(void)jenv;

4937

(void)jcls;

4938

{

4939

arg4 = NULL;

4940

}

4941

{

4942

arg18 = plfill;

4943

}

4944

{

4945

jdouble **adat;

4946

jobject *ai;

4947

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

4948

int ny = -1;

4949

int i, j;

4950

ai = (jobject *) malloc( nx * sizeof(jobject) );

4951

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

4952

4953

for( i=0; i < nx; i++ )

4954

{

4955

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

4956

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

4957

4958

if (ny == -1)

4959

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

4960

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

4961

printf( "Misshapen a array.\n" );

4962

for( j=0; j <= i; j++ )

4963

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

4964

free(adat);

4965

free(ai);

4966

return;

4967

}

4968

}

4969

4970

Xlen = nx;

4971

Ylen = ny;

4972

setup_array_2d_d( &arg1, adat, nx, ny );

4973

arg2 = nx;

4974

arg3 = ny;

4975

for( i=0; i < nx; i++ ) {

4976

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

4977

(*jenv)->DeleteLocalRef(jenv, ai[i]);

4978

}

4979

4980

free(adat);

4981

free(ai);

4982

4983

}

4984

arg5 = (PLFLT)jarg5;

4985

arg6 = (PLFLT)jarg6;

4986

arg7 = (PLFLT)jarg7;

4987

arg8 = (PLFLT)jarg8;

4988

arg9 = (PLFLT)jarg9;

4989

arg10 = (PLFLT)jarg10;

4990

arg11 = (PLINT)jarg11;

4991

arg12 = (PLFLT)jarg12;

4992

arg13 = (PLINT)jarg13;

4993

arg14 = (PLINT)jarg14;

4994

arg15 = (PLINT)jarg15;

4995

arg16 = (PLINT)jarg16;

4996

arg17 = (PLINT)jarg17;

4997

arg19 = (PLINT)jarg19;

4998

{

4999

jdouble **adat;

5000

jobject *ai;

5001

int nx = (*jenv)->GetArrayLength( jenv, jarg20 );

5002

int ny = -1;

5003

int i, j;

5004

ai = (jobject *) malloc( nx * sizeof(jobject) );

5005

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5006

5007

for( i=0; i < nx; i++ )

5008

{

5009

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg20, i );

5010

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5011

5012

if (ny == -1)

5013

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5014

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5015

printf( "Misshapen a array.\n" );

5016

for( j=0; j <= i; j++ )

5017

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5018

free(adat);

5019

free(ai);

5020

return;

5021

}

5022

}

5023

5024

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

5025

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

5026

printf( "X vector or matrix must match matrix dimensions.\n" );

5027

for( i=0; i < nx; i++ )

5028

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5029

free(adat);

5030

free(ai);

5031

return;

5032

}

5033

/* Store whether second dimension is unity. */

5034

Alen = ny;

5035

setup_array_2d_d( &xg, adat, nx, ny );

5036

for( i=0; i < nx; i++ ) {

5037

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5038

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5039

}

5040

5041

free(adat);

5042

free(ai);

5043

arg20 = pltr2;

5044

5045

}

5046

{

5047

jdouble **adat;

5048

jobject *ai;

5049

int nx = (*jenv)->GetArrayLength( jenv, jarg21 );

5050

int ny = -1;

5051

int i, j;

5052

PLcGrid2 cgrid;

5053

ai = (jobject *) malloc( nx * sizeof(jobject) );

5054

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5055

5056

for( i=0; i < nx; i++ )

5057

{

5058

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg21, i );

5059

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5060

5061

if (ny == -1)

5062

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5063

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5064

printf( "Misshapen a array.\n" );

5065

for( j=0; j <= i; j++ )

5066

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5067

free(adat);

5068

free(ai);

5069

return;

5070

}

5071

}

5072

5073

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

5074

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

5075

Xlen, nx, Ylen, Alen, ny );

5076

printf( "Y vector or matrix must match matrix dimensions.\n" );

5077

for( i=0; i < nx; i++ )

5078

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5079

free(adat);

5080

free(ai);

5081

return;

5082

}

5083

setup_array_2d_d( &yg, adat, nx, ny );

5084

for( i=0; i < nx; i++ ) {

5085

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5086

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5087

}

5088

5089

free(adat);

5090

free(ai);

5091

cgrid.xg = xg;

5092

cgrid.yg = yg;

5093

cgrid.nx = nx;

5094

cgrid.ny = ny;

5095

arg21 = &cgrid;

5096

5097

}

5098

plshade(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);

5099

5100

{

5101

free(arg1[0]);

5102

free(arg1);

5103

}

5104

{

5105

free(xg[0]);

5106

free(xg);

5107

}

5108

{

5109

free(yg[0]);

5110

free(yg);

5111

}

5299

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plshade(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jint jarg11, jdouble jarg12, jint jarg13, jint jarg14, jint jarg15, jint jarg16, jint jarg17, jboolean jarg19, jobjectArray jarg20, jobjectArray jarg21) {

5300

PLFLT **arg1 = (PLFLT **) 0 ;

5301

PLINT arg2 ;

5302

PLINT arg3 ;

5303

defined_func arg4 ;

5304

PLFLT arg5 ;

5305

PLFLT arg6 ;

5306

PLFLT arg7 ;

5307

PLFLT arg8 ;

5308

PLFLT arg9 ;

5309

PLFLT arg10 ;

5310

PLINT arg11 ;

5311

PLFLT arg12 ;

5312

PLINT arg13 ;

5313

PLINT arg14 ;

5314

PLINT arg15 ;

5315

PLINT arg16 ;

5316

PLINT arg17 ;

5317

fill_func arg18 ;

5318

PLBOOL arg19 ;

5319

pltr_func arg20 ;

5320

PLPointer arg21 = (PLPointer) 0 ;

5321

5322

(void)jenv;

5323

(void)jcls;

5324

{

5325

arg4 = NULL;

5326

}

5327

{

5328

arg18 = plfill;

5329

}

5330

{

5331

jdouble **adat;

5332

jobject *ai;

5333

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

5334

int ny = -1;

5335

int i, j;

5336

ai = (jobject *) malloc( nx * sizeof(jobject) );

5337

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5338

5339

for( i=0; i < nx; i++ )

5340

{

5341

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

5342

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5343

5344

if (ny == -1)

5345

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5346

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5347

printf( "Misshapen a array.\n" );

5348

for( j=0; j <= i; j++ )

5349

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5350

free(adat);

5351

free(ai);

5352

return;

5353

}

5354

}

5355

5356

Xlen = nx;

5357

Ylen = ny;

5358

setup_array_2d_d( &arg1, adat, nx, ny );

5359

arg2 = nx;

5360

arg3 = ny;

5361

for( i=0; i < nx; i++ ) {

5362

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5363

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5364

}

5365

5366

free(adat);

5367

free(ai);

5368

5369

}

5370

arg5 = (PLFLT)jarg5;

5371

arg6 = (PLFLT)jarg6;

5372

arg7 = (PLFLT)jarg7;

5373

arg8 = (PLFLT)jarg8;

5374

arg9 = (PLFLT)jarg9;

5375

arg10 = (PLFLT)jarg10;

5376

arg11 = (PLINT)jarg11;

5377

arg12 = (PLFLT)jarg12;

5378

arg13 = (PLINT)jarg13;

5379

arg14 = (PLINT)jarg14;

5380

arg15 = (PLINT)jarg15;

5381

arg16 = (PLINT)jarg16;

5382

arg17 = (PLINT)jarg17;

5383

arg19 = jarg19 ? 1 : 0;

5384

{

5385

jdouble **adat;

5386

jobject *ai;

5387

int nx = (*jenv)->GetArrayLength( jenv, jarg20 );

5388

int ny = -1;

5389

int i, j;

5390

ai = (jobject *) malloc( nx * sizeof(jobject) );

5391

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5392

5393

for( i=0; i < nx; i++ )

5394

{

5395

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg20, i );

5396

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5397

5398

if (ny == -1)

5399

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5400

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5401

printf( "Misshapen a array.\n" );

5402

for( j=0; j <= i; j++ )

5403

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5404

free(adat);

5405

free(ai);

5406

return;

5407

}

5408

}

5409

5410

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

5411

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

5412

printf( "X vector or matrix must match matrix dimensions.\n" );

5413

for( i=0; i < nx; i++ )

5414

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5415

free(adat);

5416

free(ai);

5417

return;

5418

}

5419

/* Store whether second dimension is unity. */

5420

Alen = ny;

5421

setup_array_2d_d( &xg, adat, nx, ny );

5422

for( i=0; i < nx; i++ ) {

5423

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5424

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5425

}

5426

5427

free(adat);

5428

free(ai);

5429

arg20 = pltr2;

5430

5431

}

5432

{

5433

jdouble **adat;

5434

jobject *ai;

5435

int nx = (*jenv)->GetArrayLength( jenv, jarg21 );

5436

int ny = -1;

5437

int i, j;

5438

PLcGrid2 cgrid;

5439

ai = (jobject *) malloc( nx * sizeof(jobject) );

5440

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5441

5442

for( i=0; i < nx; i++ )

5443

{

5444

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg21, i );

5445

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5446

5447

if (ny == -1)

5448

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5449

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5450

printf( "Misshapen a array.\n" );

5451

for( j=0; j <= i; j++ )

5452

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5453

free(adat);

5454

free(ai);

5455

return;

5456

}

5457

}

5458

5459

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

5460

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

5461

Xlen, nx, Ylen, Alen, ny );

5462

printf( "Y vector or matrix must match matrix dimensions.\n" );

5463

for( i=0; i < nx; i++ )

5464

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5465

free(adat);

5466

free(ai);

5467

return;

5468

}

5469

setup_array_2d_d( &yg, adat, nx, ny );

5470

for( i=0; i < nx; i++ ) {

5471

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5472

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5473

}

5474

5475

free(adat);

5476

free(ai);

5477

cgrid.xg = xg;

5478

cgrid.yg = yg;

5479

cgrid.nx = nx;

5480

cgrid.ny = ny;

5481

arg21 = &cgrid;

5482

5483

}

5484

plshade(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20,arg21);

5485

5486

{

5487

free(arg1[0]);

5488

free(arg1);

5489

}

5490

{

5491

free(xg[0]);

5492

free(xg);

5493

}

5494

{

5495

free(yg[0]);

5496

free(yg);

5497

}

5112

5498

}

5113

5499

5114

5500

5115

5501

#define _doc_plsmaj "Set up lengths of major tick marks."

5116

5502

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsmaj(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {

5117

PLFLT arg1 ;

5118

PLFLT arg2 ;

5119

5120

(void)jenv;

5121

(void)jcls;

5122

arg1 = (PLFLT)jarg1;

5123

arg2 = (PLFLT)jarg2;

5124

plsmaj(arg1,arg2);

5125

5503

PLFLT arg1 ;

5504

PLFLT arg2 ;

5505

5506

(void)jenv;

5507

(void)jcls;

5508

arg1 = (PLFLT)jarg1;

5509

arg2 = (PLFLT)jarg2;

5510

plsmaj(arg1,arg2);

5511

5126

5512

}

5127

5513

5128

5514

5129

5515

#define _doc_plsmin "Set up lengths of minor tick marks."

5130

5516

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsmin(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {

5131

PLFLT arg1 ;

5132

PLFLT arg2 ;

5133

5134

(void)jenv;

5135

(void)jcls;

5136

arg1 = (PLFLT)jarg1;

5137

arg2 = (PLFLT)jarg2;

5138

plsmin(arg1,arg2);

5139

5517

PLFLT arg1 ;

5518

PLFLT arg2 ;

5519

5520

(void)jenv;

5521

(void)jcls;

5522

arg1 = (PLFLT)jarg1;

5523

arg2 = (PLFLT)jarg2;

5524

plsmin(arg1,arg2);

5525

5140

5526

}

5141

5527

5142

5528

5143

5529

#define _doc_plsori "Set orientation. Must be done before calling plinit."

5144

5530

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsori(JNIEnv *jenv, jclass jcls, jint jarg1) {

5145

PLINT arg1 ;

5146

5147

(void)jenv;

5148

(void)jcls;

5149

arg1 = (PLINT)jarg1;

5150

plsori(arg1);

5151

5531

PLINT arg1 ;

5532

5533

(void)jenv;

5534

(void)jcls;

5535

arg1 = (PLINT)jarg1;

5536

plsori(arg1);

5537

5152

5538

}

5153

5539

5154

5540

5155

5541

#define _doc_plspage "Set output device parameters. Usually ignored by the driver."

5156

5542

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspage(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jint jarg3, jint jarg4, jint jarg5, jint jarg6) {

5157

PLFLT arg1 ;

5158

PLFLT arg2 ;

5159

PLINT arg3 ;

5160

PLINT arg4 ;

5161

PLINT arg5 ;

5162

PLINT arg6 ;

5163

5164

(void)jenv;

5165

(void)jcls;

5166

arg1 = (PLFLT)jarg1;

5167

arg2 = (PLFLT)jarg2;

5168

arg3 = (PLINT)jarg3;

5169

arg4 = (PLINT)jarg4;

5170

arg5 = (PLINT)jarg5;

5171

arg6 = (PLINT)jarg6;

5172

plspage(arg1,arg2,arg3,arg4,arg5,arg6);

5173

5543

PLFLT arg1 ;

5544

PLFLT arg2 ;

5545

PLINT arg3 ;

5546

PLINT arg4 ;

5547

PLINT arg5 ;

5548

PLINT arg6 ;

5549

5550

(void)jenv;

5551

(void)jcls;

5552

arg1 = (PLFLT)jarg1;

5553

arg2 = (PLFLT)jarg2;

5554

arg3 = (PLINT)jarg3;

5555

arg4 = (PLINT)jarg4;

5556

arg5 = (PLINT)jarg5;

5557

arg6 = (PLINT)jarg6;

5558

plspage(arg1,arg2,arg3,arg4,arg5,arg6);

5559

5174

5560

}

5175

5561

5176

5562

5177

5563

#define _doc_plspause "Set the pause (on end-of-page) status."

5178

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspause(JNIEnv *jenv, jclass jcls, jint jarg1) {

5179

PLINT arg1 ;

5180

5181

(void)jenv;

5182

(void)jcls;

5183

arg1 = (PLINT)jarg1;

5184

plspause(arg1);

5185

5564

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plspause(JNIEnv *jenv, jclass jcls, jboolean jarg1) {

5565

PLBOOL arg1 ;

5566

5567

(void)jenv;

5568

(void)jcls;

5569

arg1 = jarg1 ? 1 : 0;

5570

plspause(arg1);

5571

5186

5572

}

5187

5573

5188

5574

5189

5575

#define _doc_plsstrm "Set stream number."

5190

5576

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsstrm(JNIEnv *jenv, jclass jcls, jint jarg1) {

5191

PLINT arg1 ;

5192

5193

(void)jenv;

5194

(void)jcls;

5195

arg1 = (PLINT)jarg1;

5196

plsstrm(arg1);

5197

5577

PLINT arg1 ;

5578

5579

(void)jenv;

5580

(void)jcls;

5581

arg1 = (PLINT)jarg1;

5582

plsstrm(arg1);

5583

5198

5584

}

5199

5585

5200

5586

5201

5587

#define _doc_plssub "Set the number of subwindows in x and y."

5202

5588

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plssub(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

5203

PLINT arg1 ;

5204

PLINT arg2 ;

5205

5206

(void)jenv;

5207

(void)jcls;

5208

arg1 = (PLINT)jarg1;

5209

arg2 = (PLINT)jarg2;

5210

plssub(arg1,arg2);

5211

5589

PLINT arg1 ;

5590

PLINT arg2 ;

5591

5592

(void)jenv;

5593

(void)jcls;

5594

arg1 = (PLINT)jarg1;

5595

arg2 = (PLINT)jarg2;

5596

plssub(arg1,arg2);

5597

5212

5598

}

5213

5599

5214

5600

5215

5601

#define _doc_plssym "Set symbol height."

5216

5602

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plssym(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2) {

5217

PLFLT arg1 ;

5218

PLFLT arg2 ;

5219

5220

(void)jenv;

5221

(void)jcls;

5222

arg1 = (PLFLT)jarg1;

5223

arg2 = (PLFLT)jarg2;

5224

plssym(arg1,arg2);

5225

5603

PLFLT arg1 ;

5604

PLFLT arg2 ;

5605

5606

(void)jenv;

5607

(void)jcls;

5608

arg1 = (PLFLT)jarg1;

5609

arg2 = (PLFLT)jarg2;

5610

plssym(arg1,arg2);

5611

5226

5612

}

5227

5613

5228

5614

5229

5615

#define _doc_plstar "Initialize PLplot, passing in the windows/page settings."

5230

5616

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstar(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

5231

PLINT arg1 ;

5232

PLINT arg2 ;

5233

5234

(void)jenv;

5235

(void)jcls;

5236

arg1 = (PLINT)jarg1;

5237

arg2 = (PLINT)jarg2;

5238

plstar(arg1,arg2);

5239

5617

PLINT arg1 ;

5618

PLINT arg2 ;

5619

5620

(void)jenv;

5621

(void)jcls;

5622

arg1 = (PLINT)jarg1;

5623

arg2 = (PLINT)jarg2;

5624

plstar(arg1,arg2);

5625

5240

5626

}

5241

5627

5242

5628

5243

5629

#define _doc_plstart "Initialize PLplot, passing the device name and windows/page settings."

5244

5630

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstart(JNIEnv *jenv, jclass jcls, jstring jarg1, jint jarg2, jint jarg3) {

5245

char *arg1 ;

5246

PLINT arg2 ;

5247

PLINT arg3 ;

5248

5249

(void)jenv;

5250

(void)jcls;

5251

{

5252

arg1 = 0;

5253

if (jarg1) {

5254

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

5255

if (!arg1) return ;

5256

}

5257

}

5258

arg2 = (PLINT)jarg2;

5259

arg3 = (PLINT)jarg3;

5260

plstart((char const *)arg1,arg2,arg3);

5261

5262

{

5263

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

5264

}

5631

char *arg1 = (char *) 0 ;

5632

PLINT arg2 ;

5633

PLINT arg3 ;

5634

5635

(void)jenv;

5636

(void)jcls;

5637

arg1 = 0;

5638

if (jarg1) {

5639

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

5640

if (!arg1) return ;

5641

}

5642

arg2 = (PLINT)jarg2;

5643

arg3 = (PLINT)jarg3;

5644

plstart((char const *)arg1,arg2,arg3);

5645

5646

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

5265

5647

}

5266

5648

5267

5649

5268

5650

#define _doc_plstripa "Add a point to a stripchart. "

5269

5651

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripa(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2, jdouble jarg3, jdouble jarg4) {

5270

PLINT arg1 ;

5271

PLINT arg2 ;

5272

PLFLT arg3 ;

5273

PLFLT arg4 ;

5274

5275

(void)jenv;

5276

(void)jcls;

5277

arg1 = (PLINT)jarg1;

5278

arg2 = (PLINT)jarg2;

5279

arg3 = (PLFLT)jarg3;

5280

arg4 = (PLFLT)jarg4;

5281

plstripa(arg1,arg2,arg3,arg4);

5282

5652

PLINT arg1 ;

5653

PLINT arg2 ;

5654

PLFLT arg3 ;

5655

PLFLT arg4 ;

5656

5657

(void)jenv;

5658

(void)jcls;

5659

arg1 = (PLINT)jarg1;

5660

arg2 = (PLINT)jarg2;

5661

arg3 = (PLFLT)jarg3;

5662

arg4 = (PLFLT)jarg4;

5663

plstripa(arg1,arg2,arg3,arg4);

5664

5283

5665

}

5284

5666

5285

5667

5286

5668

#define _doc_plstripc "Create 1d stripchart."

5287

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripc(JNIEnv *jenv, jclass jcls, jintArray jarg1, jstring jarg2, jstring jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jint jarg11, jint jarg12, jint jarg13, jint jarg14, jintArray jarg15, jintArray jarg16, jlong jarg17, jstring jarg18, jstring jarg19, jstring jarg20) {

5288

PLINT *arg1 = (PLINT *) 0 ;

5289

char *arg2 ;

5290

char *arg3 ;

5291

PLFLT arg4 ;

5292

PLFLT arg5 ;

5293

PLFLT arg6 ;

5294

PLFLT arg7 ;

5295

PLFLT arg8 ;

5296

PLFLT arg9 ;

5297

PLFLT arg10 ;

5298

PLINT arg11 ;

5299

PLINT arg12 ;

5300

PLINT arg13 ;

5301

PLINT arg14 ;

5302

PLINT *arg15 = (PLINT *) 0 ;

5303

PLINT *arg16 = (PLINT *) 0 ;

5304

char **arg17 ;

5305

char *arg18 ;

5306

char *arg19 ;

5307

char *arg20 ;

5308

PLINT temp1 ;

5309

5310

(void)jenv;

5311

(void)jcls;

5312

{

5313

if (!jarg1) {

5314

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

5315

return ;

5316

}

5317

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

5318

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

5319

return ;

5320

}

5321

arg1 = &temp1;

5322

}

5323

{

5324

arg2 = 0;

5325

if (jarg2) {

5326

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

5327

if (!arg2) return ;

5328

}

5329

}

5330

{

5331

arg3 = 0;

5332

if (jarg3) {

5333

arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);

5334

if (!arg3) return ;

5335

}

5336

}

5337

arg4 = (PLFLT)jarg4;

5338

arg5 = (PLFLT)jarg5;

5339

arg6 = (PLFLT)jarg6;

5340

arg7 = (PLFLT)jarg7;

5341

arg8 = (PLFLT)jarg8;

5342

arg9 = (PLFLT)jarg9;

5343

arg10 = (PLFLT)jarg10;

5344

arg11 = (PLINT)jarg11;

5345

arg12 = (PLINT)jarg12;

5346

arg13 = (PLINT)jarg13;

5347

arg14 = (PLINT)jarg14;

5348

{

5349

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg15, 0 );

5350

Alen = (*jenv)->GetArrayLength( jenv, jarg15);

5351

setup_array_1d_i( &arg15, jydata, Alen);

5352

(*jenv)->ReleaseIntArrayElements( jenv, jarg15, jydata, 0 );

5353

}

5354

{

5355

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg16, 0 );

5356

if((*jenv)->GetArrayLength( jenv, jarg16 ) != Alen) {

5357

printf("Vectors must be same length.\n");

5358

return;

5359

}

5360

setup_array_1d_i( &arg16, jydata, Alen);

5361

(*jenv)->ReleaseIntArrayElements( jenv, jarg16, jydata, 0 );

5362

}

5363

arg17 = *(char ***)&jarg17;

5364

{

5365

arg18 = 0;

5366

if (jarg18) {

5367

arg18 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg18, 0);

5368

if (!arg18) return ;

5369

}

5370

}

5371

{

5372

arg19 = 0;

5373

if (jarg19) {

5374

arg19 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg19, 0);

5375

if (!arg19) return ;

5376

}

5377

}

5378

{

5379

arg20 = 0;

5380

if (jarg20) {

5381

arg20 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg20, 0);

5382

if (!arg20) return ;

5383

}

5384

}

5385

plstripc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);

5386

5387

{

5388

jint jvalue = (jint)temp1;

5389

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

5390

}

5391

{

5392

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

5393

}

5394

{

5395

if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, arg3);

5396

}

5397

{

5398

free(arg15);

5399

}

5400

{

5401

free(arg16);

5402

}

5403

{

5404

if (arg18) (*jenv)->ReleaseStringUTFChars(jenv, jarg18, arg18);

5405

}

5406

{

5407

if (arg19) (*jenv)->ReleaseStringUTFChars(jenv, jarg19, arg19);

5408

}

5409

{

5410

if (arg20) (*jenv)->ReleaseStringUTFChars(jenv, jarg20, arg20);

5411

}

5669

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripc(JNIEnv *jenv, jclass jcls, jintArray jarg1, jstring jarg2, jstring jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jboolean jarg11, jboolean jarg12, jint jarg13, jint jarg14, jintArray jarg15, jintArray jarg16, jlong jarg17, jstring jarg18, jstring jarg19, jstring jarg20) {

5670

PLINT *arg1 = (PLINT *) 0 ;

5671

char *arg2 = (char *) 0 ;

5672

char *arg3 = (char *) 0 ;

5673

PLFLT arg4 ;

5674

PLFLT arg5 ;

5675

PLFLT arg6 ;

5676

PLFLT arg7 ;

5677

PLFLT arg8 ;

5678

PLFLT arg9 ;

5679

PLFLT arg10 ;

5680

PLBOOL arg11 ;

5681

PLBOOL arg12 ;

5682

PLINT arg13 ;

5683

PLINT arg14 ;

5684

PLINT *arg15 = (PLINT *) 0 ;

5685

PLINT *arg16 = (PLINT *) 0 ;

5686

char **arg17 ;

5687

char *arg18 = (char *) 0 ;

5688

char *arg19 = (char *) 0 ;

5689

char *arg20 = (char *) 0 ;

5690

PLINT temp1 ;

5691

5692

(void)jenv;

5693

(void)jcls;

5694

{

5695

if (!jarg1) {

5696

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

5697

return ;

5698

}

5699

if ((*jenv)->GetArrayLength(jenv, jarg1) == 0) {

5700

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

5701

return ;

5702

}

5703

arg1 = &temp1;

5704

}

5705

arg2 = 0;

5706

if (jarg2) {

5707

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

5708

if (!arg2) return ;

5709

}

5710

arg3 = 0;

5711

if (jarg3) {

5712

arg3 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg3, 0);

5713

if (!arg3) return ;

5714

}

5715

arg4 = (PLFLT)jarg4;

5716

arg5 = (PLFLT)jarg5;

5717

arg6 = (PLFLT)jarg6;

5718

arg7 = (PLFLT)jarg7;

5719

arg8 = (PLFLT)jarg8;

5720

arg9 = (PLFLT)jarg9;

5721

arg10 = (PLFLT)jarg10;

5722

arg11 = jarg11 ? 1 : 0;

5723

arg12 = jarg12 ? 1 : 0;

5724

arg13 = (PLINT)jarg13;

5725

arg14 = (PLINT)jarg14;

5726

{

5727

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg15, 0 );

5728

Alen = (*jenv)->GetArrayLength( jenv, jarg15);

5729

setup_array_1d_i( &arg15, jydata, Alen);

5730

(*jenv)->ReleaseIntArrayElements( jenv, jarg15, jydata, 0 );

5731

}

5732

{

5733

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg16, 0 );

5734

if((*jenv)->GetArrayLength( jenv, jarg16 ) != Alen) {

5735

printf("Vectors must be same length.\n");

5736

return;

5737

}

5738

setup_array_1d_i( &arg16, jydata, Alen);

5739

(*jenv)->ReleaseIntArrayElements( jenv, jarg16, jydata, 0 );

5740

}

5741

arg17 = *(char ***)(void *)&jarg17;

5742

arg18 = 0;

5743

if (jarg18) {

5744

arg18 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg18, 0);

5745

if (!arg18) return ;

5746

}

5747

arg19 = 0;

5748

if (jarg19) {

5749

arg19 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg19, 0);

5750

if (!arg19) return ;

5751

}

5752

arg20 = 0;

5753

if (jarg20) {

5754

arg20 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg20, 0);

5755

if (!arg20) return ;

5756

}

5757

plstripc(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17,arg18,arg19,arg20);

5758

5759

{

5760

jint jvalue = (jint)temp1;

5761

(*jenv)->SetIntArrayRegion(jenv, jarg1, 0, 1, &jvalue);

5762

}

5763

5764

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

5765

if (arg3) (*jenv)->ReleaseStringUTFChars(jenv, jarg3, arg3);

5766

{

5767

free(arg15);

5768

}

5769

{

5770

free(arg16);

5771

}

5772

5773

if (arg18) (*jenv)->ReleaseStringUTFChars(jenv, jarg18, arg18);

5774

if (arg19) (*jenv)->ReleaseStringUTFChars(jenv, jarg19, arg19);

5775

if (arg20) (*jenv)->ReleaseStringUTFChars(jenv, jarg20, arg20);

5412

5776

}

5413

5777

5414

5778

5415

5779

#define _doc_plstripd "Deletes and releases memory used by a stripchart. "

5416

5780

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstripd(JNIEnv *jenv, jclass jcls, jint jarg1) {

5417

PLINT arg1 ;

5418

5419

(void)jenv;

5420

(void)jcls;

5421

arg1 = (PLINT)jarg1;

5422

plstripd(arg1);

5423

5781

PLINT arg1 ;

5782

5783

(void)jenv;

5784

(void)jcls;

5785

arg1 = (PLINT)jarg1;

5786

plstripd(arg1);

5787

5424

5788

}

5425

5789

5426

5790

5427

5791

#define _doc_plstyl "Set up a new line style."

5428

5792

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plstyl(JNIEnv *jenv, jclass jcls, jintArray jarg1, jintArray jarg3) {

5429

PLINT arg1 ;

5430

PLINT *arg2 = (PLINT *) 0 ;

5431

PLINT *arg3 = (PLINT *) 0 ;

5432

5433

(void)jenv;

5434

(void)jcls;

5435

{

5436

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

5437

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

5438

Alen = arg1;

5439

setup_array_1d_i( &arg2, jxdata, Alen);

5440

/* Could find no easy way to do this as part of freearg so I modified

5441

* the previous function so it ALWAYS mallocs and copies so that

5442

* the java array can be released immediately. */

5443

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );

5444

}

5445

{

5446

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

5447

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

5448

printf("Vectors must be same length.\n");

5449

return;

5450

}

5451

setup_array_1d_i( &arg3, jydata, Alen);

5452

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

5453

}

5454

plstyl(arg1,arg2,arg3);

5455

5456

{

5457

free(arg2);

5458

}

5459

{

5460

free(arg3);

5461

}

5793

PLINT arg1 ;

5794

PLINT *arg2 = (PLINT *) 0 ;

5795

PLINT *arg3 = (PLINT *) 0 ;

5796

5797

(void)jenv;

5798

(void)jcls;

5799

{

5800

jint *jxdata = (*jenv)->GetIntArrayElements( jenv, jarg1, 0 );

5801

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

5802

Alen = arg1;

5803

setup_array_1d_i( &arg2, jxdata, Alen);

5804

/* Could find no easy way to do this as part of freearg so I modified

5805

* the previous function so it ALWAYS mallocs and copies so that

5806

* the java array can be released immediately. */

5807

(*jenv)->ReleaseIntArrayElements( jenv, jarg1, jxdata, 0 );

5808

}

5809

{

5810

jint *jydata = (*jenv)->GetIntArrayElements( jenv, jarg3, 0 );

5811

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

5812

printf("Vectors must be same length.\n");

5813

return;

5814

}

5815

setup_array_1d_i( &arg3, jydata, Alen);

5816

(*jenv)->ReleaseIntArrayElements( jenv, jarg3, jydata, 0 );

5817

}

5818

plstyl(arg1,arg2,arg3);

5819

5820

{

5821

free(arg2);

5822

}

5823

{

5824

free(arg3);

5825

}

5462

5826

}

5463

5827

5464

5828

5465

5829

#define _doc_plsvect "Set vector arrow style."

5466

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvect(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jint jarg3, jint jarg4) {

5467

PLFLT *arg1 = (PLFLT *) 0 ;

5468

PLFLT *arg2 = (PLFLT *) 0 ;

5469

PLINT arg3 ;

5470

PLINT arg4 ;

5471

5472

(void)jenv;

5473

(void)jcls;

5474

{

5475

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

5476

Alen = (*jenv)->GetArrayLength( jenv, jarg1 );

5477

setup_array_1d_d( &arg1, jxdata, Alen);

5478

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

5479

}

5480

{

5481

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

5482

if((*jenv)->GetArrayLength( jenv, jarg2 ) != Alen) {

5483

printf("Vectors must be same length.\n");

5484

return;

5485

}

5486

setup_array_1d_d( &arg2, jydata, Alen );

5487

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

5488

}

5489

arg3 = (PLINT)jarg3;

5490

arg4 = (PLINT)jarg4;

5491

plsvect(arg1,arg2,arg3,arg4);

5492

5493

{

5494

free(arg1);

5495

}

5496

{

5497

free(arg2);

5498

}

5830

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvect(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg2, jboolean jarg4) {

5831

PLFLT *arg1 = (PLFLT *) 0 ;

5832

PLFLT *arg2 = (PLFLT *) 0 ;

5833

PLINT arg3 ;

5834

PLBOOL arg4 ;

5835

5836

(void)jenv;

5837

(void)jcls;

5838

{

5839

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

5840

Alen = (*jenv)->GetArrayLength( jenv, jarg1 );

5841

setup_array_1d_d( &arg1, jxdata, Alen);

5842

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

5843

}

5844

{

5845

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg2, 0 );

5846

arg3 = (*jenv)->GetArrayLength( jenv, jarg2 );

5847

if((*jenv)->GetArrayLength( jenv, jarg2 ) != Alen) {

5848

printf("Vectors must be same length.\n");

5849

return;

5850

}

5851

setup_array_1d_d( &arg2, jydata, Alen );

5852

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg2, jydata, 0 );

5853

}

5854

arg4 = jarg4 ? 1 : 0;

5855

plsvect(arg1,arg2,arg3,arg4);

5856

5857

{

5858

free(arg1);

5859

}

5860

{

5861

free(arg2);

5862

}

5499

5863

}

5500

5864

5501

5865

5502

5866

#define _doc_plsvpa "Set the edges of the viewport to the specified absolute coordinates."

5503

5867

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsvpa(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

5504

PLFLT arg1 ;

5505

PLFLT arg2 ;

5506

PLFLT arg3 ;

5507

PLFLT arg4 ;

5508

5509

(void)jenv;

5510

(void)jcls;

5511

arg1 = (PLFLT)jarg1;

5512

arg2 = (PLFLT)jarg2;

5513

arg3 = (PLFLT)jarg3;

5514

arg4 = (PLFLT)jarg4;

5515

plsvpa(arg1,arg2,arg3,arg4);

5516

5868

PLFLT arg1 ;

5869

PLFLT arg2 ;

5870

PLFLT arg3 ;

5871

PLFLT arg4 ;

5872

5873

(void)jenv;

5874

(void)jcls;

5875

arg1 = (PLFLT)jarg1;

5876

arg2 = (PLFLT)jarg2;

5877

arg3 = (PLFLT)jarg3;

5878

arg4 = (PLFLT)jarg4;

5879

plsvpa(arg1,arg2,arg3,arg4);

5880

5517

5881

}

5518

5882

5519

5883

5520

5884

#define _doc_plsxax "Set x axis labeling parameters."

5521

5885

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsxax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

5522

PLINT arg1 ;

5523

PLINT arg2 ;

5524

5525

(void)jenv;

5526

(void)jcls;

5527

arg1 = (PLINT)jarg1;

5528

arg2 = (PLINT)jarg2;

5529

plsxax(arg1,arg2);

5530

5886

PLINT arg1 ;

5887

PLINT arg2 ;

5888

5889

(void)jenv;

5890

(void)jcls;

5891

arg1 = (PLINT)jarg1;

5892

arg2 = (PLINT)jarg2;

5893

plsxax(arg1,arg2);

5894

5531

5895

}

5532

5896

5533

5897

5534

5898

#define _doc_plsyax "Set y axis labeling parameters."

5535

5899

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsyax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

5536

PLINT arg1 ;

5537

PLINT arg2 ;

5538

5539

(void)jenv;

5540

(void)jcls;

5541

arg1 = (PLINT)jarg1;

5542

arg2 = (PLINT)jarg2;

5543

plsyax(arg1,arg2);

5544

5900

PLINT arg1 ;

5901

PLINT arg2 ;

5902

5903

(void)jenv;

5904

(void)jcls;

5905

arg1 = (PLINT)jarg1;

5906

arg2 = (PLINT)jarg2;

5907

plsyax(arg1,arg2);

5908

5545

5909

}

5546

5910

5547

5911

5548

5912

#define _doc_plsym "Plot array y against x for n points using Hershey symbol \"code\""

5549

5913

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plsym(JNIEnv *jenv, jclass jcls, jdoubleArray jarg1, jdoubleArray jarg3, jint jarg4) {

5550

PLINT arg1 ;

5551

PLFLT *arg2 = (PLFLT *) 0 ;

5552

PLFLT *arg3 = (PLFLT *) 0 ;

5553

PLINT arg4 ;

5554

5555

(void)jenv;

5556

(void)jcls;

5557

{

5558

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

5559

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

5560

Alen = arg1;

5561

setup_array_1d_d( &arg2, jxdata, Alen );

5562

/* Could find no easy way to do this as part of freearg so I modified

5563

* the previous function so it ALWAYS mallocs and copies so that

5564

* the java array can be released immediately. */

5565

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

5566

}

5567

{

5568

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

5569

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

5570

printf("Vectors must be same length.\n");

5571

return;

5572

}

5573

setup_array_1d_d( &arg3, jydata, Alen );

5574

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

5575

}

5576

arg4 = (PLINT)jarg4;

5577

plsym(arg1,arg2,arg3,arg4);

5578

5579

{

5580

free(arg2);

5581

}

5582

{

5583

free(arg3);

5584

}

5914

PLINT arg1 ;

5915

PLFLT *arg2 = (PLFLT *) 0 ;

5916

PLFLT *arg3 = (PLFLT *) 0 ;

5917

PLINT arg4 ;

5918

5919

(void)jenv;

5920

(void)jcls;

5921

{

5922

jdouble *jxdata = (*jenv)->GetDoubleArrayElements( jenv, jarg1, 0 );

5923

arg1 = (*jenv)->GetArrayLength( jenv, jarg1);

5924

Alen = arg1;

5925

setup_array_1d_d( &arg2, jxdata, Alen );

5926

/* Could find no easy way to do this as part of freearg so I modified

5927

* the previous function so it ALWAYS mallocs and copies so that

5928

* the java array can be released immediately. */

5929

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg1, jxdata, 0 );

5930

}

5931

{

5932

jdouble *jydata = (*jenv)->GetDoubleArrayElements( jenv, jarg3, 0 );

5933

if((*jenv)->GetArrayLength( jenv, jarg3 ) != Alen) {

5934

printf("Vectors must be same length.\n");

5935

return;

5936

}

5937

setup_array_1d_d( &arg3, jydata, Alen );

5938

(*jenv)->ReleaseDoubleArrayElements( jenv, jarg3, jydata, 0 );

5939

}

5940

arg4 = (PLINT)jarg4;

5941

plsym(arg1,arg2,arg3,arg4);

5942

5943

{

5944

free(arg2);

5945

}

5946

{

5947

free(arg3);

5948

}

5585

5949

}

5586

5950

5587

5951

5588

5952

#define _doc_plszax "Set z axis labeling parameters"

5589

5953

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plszax(JNIEnv *jenv, jclass jcls, jint jarg1, jint jarg2) {

5590

PLINT arg1 ;

5591

PLINT arg2 ;

5592

5593

(void)jenv;

5594

(void)jcls;

5595

arg1 = (PLINT)jarg1;

5596

arg2 = (PLINT)jarg2;

5597

plszax(arg1,arg2);

5598

5954

PLINT arg1 ;

5955

PLINT arg2 ;

5956

5957

(void)jenv;

5958

(void)jcls;

5959

arg1 = (PLINT)jarg1;

5960

arg2 = (PLINT)jarg2;

5961

plszax(arg1,arg2);

5962

5599

5963

}

5600

5964

5601

5965

5602

5966

#define _doc_pltext "Switch to text screen."

5603

5967

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_pltext(JNIEnv *jenv, jclass jcls) {

5604

(void)jenv;

5605

(void)jcls;

5606

pltext();

5607

5968

(void)jenv;

5969

(void)jcls;

5970

pltext();

5971

5608

5972

}

5609

5973

5610

5974

5611

5975

#define _doc_plvasp "Sets the edges of the viewport with the given aspect ratio, leaving room for labels."

5612

5976

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvasp(JNIEnv *jenv, jclass jcls, jdouble jarg1) {

5613

PLFLT arg1 ;

5614

5615

(void)jenv;

5616

(void)jcls;

5617

arg1 = (PLFLT)jarg1;

5618

plvasp(arg1);

5619

5977

PLFLT arg1 ;

5978

5979

(void)jenv;

5980

(void)jcls;

5981

arg1 = (PLFLT)jarg1;

5982

plvasp(arg1);

5983

5620

5984

}

5621

5985

5622

5986

5623

5987

#define _doc_plvect "Plot vectors."

5624

5988

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvect(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jobjectArray jarg2, jdouble jarg5, jobjectArray jarg6, jobjectArray jarg7) {

5625

PLFLT **arg1 = (PLFLT **) 0 ;

5626

PLFLT **arg2 = (PLFLT **) 0 ;

5627

PLINT arg3 ;

5628

PLINT arg4 ;

5629

PLFLT arg5 ;

5630

pltr_func arg6 ;

5631

PLPointer arg7 = (PLPointer) 0 ;

5632

5633

(void)jenv;

5634

(void)jcls;

5635

{

5636

jdouble **adat;

5637

jobject *ai;

5638

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

5639

int ny = -1;

5640

int i, j;

5641

ai = (jobject *) malloc( nx * sizeof(jobject) );

5642

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5643

5644

for( i=0; i < nx; i++ )

5645

{

5646

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

5647

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5648

5649

if (ny == -1)

5650

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5651

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5652

printf( "Misshapen a array.\n" );

5653

for( j=0; j <= i; j++ )

5654

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5655

free(adat);

5656

free(ai);

5657

return;

5658

}

5659

}

5660

5661

Xlen = nx;

5662

Ylen = ny;

5663

setup_array_2d_d( &arg1, adat, nx, ny );

5664

for( i=0; i < nx; i++ ) {

5665

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5666

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5667

}

5668

5669

free(adat);

5670

free(ai);

5671

5672

}

5673

{

5674

jdouble **adat;

5675

jobject *ai;

5676

int nx = (*jenv)->GetArrayLength( jenv, jarg2 );

5677

int ny = -1;

5678

int i, j;

5679

ai = (jobject *) malloc( nx * sizeof(jobject) );

5680

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5681

5682

for( i=0; i < nx; i++ )

5683

{

5684

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg2, i );

5685

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5686

5687

if (ny == -1)

5688

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5689

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5690

printf( "Misshapen a array.\n" );

5691

for( j=0; j <= i; j++ )

5692

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5693

free(adat);

5694

free(ai);

5695

return;

5696

}

5697

}

5698

5699

if( nx != Xlen || ny != Ylen ) {

5700

printf( "Vectors must match matrix.\n" );

5701

for( i=0; i < nx; i++ )

5702

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5703

free(adat);

5704

free(ai);

5705

return;

5706

}

5707

setup_array_2d_d( &arg2, adat, nx, ny );

5708

arg3 = nx;

5709

arg4 = ny;

5710

for( i=0; i < nx; i++ ) {

5711

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5712

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5713

}

5714

5715

5716

free(adat);

5717

free(ai);

5718

5719

}

5720

arg5 = (PLFLT)jarg5;

5721

{

5722

jdouble **adat;

5723

jobject *ai;

5724

int nx = (*jenv)->GetArrayLength( jenv, jarg6 );

5725

int ny = -1;

5726

int i, j;

5727

ai = (jobject *) malloc( nx * sizeof(jobject) );

5728

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5729

5730

for( i=0; i < nx; i++ )

5731

{

5732

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg6, i );

5733

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5734

5735

if (ny == -1)

5736

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5737

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5738

printf( "Misshapen a array.\n" );

5739

for( j=0; j <= i; j++ )

5740

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5741

free(adat);

5742

free(ai);

5743

return;

5744

}

5745

}

5746

5747

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

5748

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

5749

printf( "X vector or matrix must match matrix dimensions.\n" );

5750

for( i=0; i < nx; i++ )

5751

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5752

free(adat);

5753

free(ai);

5754

return;

5755

}

5756

/* Store whether second dimension is unity. */

5757

Alen = ny;

5758

setup_array_2d_d( &xg, adat, nx, ny );

5759

for( i=0; i < nx; i++ ) {

5760

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5761

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5762

}

5763

5764

free(adat);

5765

free(ai);

5766

arg6 = pltr2;

5767

5768

}

5769

{

5770

jdouble **adat;

5771

jobject *ai;

5772

int nx = (*jenv)->GetArrayLength( jenv, jarg7 );

5773

int ny = -1;

5774

int i, j;

5775

PLcGrid2 cgrid;

5776

ai = (jobject *) malloc( nx * sizeof(jobject) );

5777

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

5778

5779

for( i=0; i < nx; i++ )

5780

{

5781

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg7, i );

5782

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

5783

5784

if (ny == -1)

5785

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

5786

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

5787

printf( "Misshapen a array.\n" );

5788

for( j=0; j <= i; j++ )

5789

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

5790

free(adat);

5791

free(ai);

5792

return;

5793

}

5794

}

5795

5796

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

5797

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

5798

Xlen, nx, Ylen, Alen, ny );

5799

printf( "Y vector or matrix must match matrix dimensions.\n" );

5800

for( i=0; i < nx; i++ )

5801

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5802

free(adat);

5803

free(ai);

5804

return;

5805

}

5806

setup_array_2d_d( &yg, adat, nx, ny );

5807

for( i=0; i < nx; i++ ) {

5808

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

5809

(*jenv)->DeleteLocalRef(jenv, ai[i]);

5810

}

5811

5812

free(adat);

5813

free(ai);

5814

cgrid.xg = xg;

5815

cgrid.yg = yg;

5816

cgrid.nx = nx;

5817

cgrid.ny = ny;

5818

arg7 = &cgrid;

5819

5820

}

5821

plvect(arg1,arg2,arg3,arg4,arg5,arg6,arg7);

5822

5823

{

5824

free(arg1[0]);

5825

free(arg1);

5826

}

5827

{

5828

free(arg2[0]);

5829

free(arg2);

5830

}

5831

{

5832

free(xg[0]);

5833

free(xg);

5834

}

5835

{

5836

free(yg[0]);

5837

free(yg);

5838

}

5989

PLFLT **arg1 = (PLFLT **) 0 ;

5990

PLFLT **arg2 = (PLFLT **) 0 ;

5991

PLINT arg3 ;

5992

PLINT arg4 ;

5993

PLFLT arg5 ;

5994

pltr_func arg6 ;

5995

PLPointer arg7 = (PLPointer) 0 ;

5996

5997

(void)jenv;

5998

(void)jcls;

5999

{

6000

jdouble **adat;

6001

jobject *ai;

6002

int nx = (*jenv)->GetArrayLength( jenv, jarg1 );

6003

int ny = -1;

6004

int i, j;

6005

ai = (jobject *) malloc( nx * sizeof(jobject) );

6006

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

6007

6008

for( i=0; i < nx; i++ )

6009

{

6010

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg1, i );

6011

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

6012

6013

if (ny == -1)

6014

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

6015

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

6016

printf( "Misshapen a array.\n" );

6017

for( j=0; j <= i; j++ )

6018

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

6019

free(adat);

6020

free(ai);

6021

return;

6022

}

6023

}

6024

6025

Xlen = nx;

6026

Ylen = ny;

6027

setup_array_2d_d( &arg1, adat, nx, ny );

6028

for( i=0; i < nx; i++ ) {

6029

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6030

(*jenv)->DeleteLocalRef(jenv, ai[i]);

6031

}

6032

6033

free(adat);

6034

free(ai);

6035

6036

}

6037

{

6038

jdouble **adat;

6039

jobject *ai;

6040

int nx = (*jenv)->GetArrayLength( jenv, jarg2 );

6041

int ny = -1;

6042

int i, j;

6043

ai = (jobject *) malloc( nx * sizeof(jobject) );

6044

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

6045

6046

for( i=0; i < nx; i++ )

6047

{

6048

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg2, i );

6049

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

6050

6051

if (ny == -1)

6052

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

6053

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

6054

printf( "Misshapen a array.\n" );

6055

for( j=0; j <= i; j++ )

6056

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

6057

free(adat);

6058

free(ai);

6059

return;

6060

}

6061

}

6062

6063

if( nx != Xlen || ny != Ylen ) {

6064

printf( "Vectors must match matrix.\n" );

6065

for( i=0; i < nx; i++ )

6066

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6067

free(adat);

6068

free(ai);

6069

return;

6070

}

6071

setup_array_2d_d( &arg2, adat, nx, ny );

6072

arg3 = nx;

6073

arg4 = ny;

6074

for( i=0; i < nx; i++ ) {

6075

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6076

(*jenv)->DeleteLocalRef(jenv, ai[i]);

6077

}

6078

6079

6080

free(adat);

6081

free(ai);

6082

6083

}

6084

arg5 = (PLFLT)jarg5;

6085

{

6086

jdouble **adat;

6087

jobject *ai;

6088

int nx = (*jenv)->GetArrayLength( jenv, jarg6 );

6089

int ny = -1;

6090

int i, j;

6091

ai = (jobject *) malloc( nx * sizeof(jobject) );

6092

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

6093

6094

for( i=0; i < nx; i++ )

6095

{

6096

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg6, i );

6097

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

6098

6099

if (ny == -1)

6100

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

6101

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

6102

printf( "Misshapen a array.\n" );

6103

for( j=0; j <= i; j++ )

6104

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

6105

free(adat);

6106

free(ai);

6107

return;

6108

}

6109

}

6110

6111

if( !((nx == Xlen && ny == Ylen) || (nx == Xlen && ny == 1))) {

6112

printf( "Xlen = %d, nx = %d, Ylen = %d, ny = %d\n", Xlen, nx, Ylen, ny );

6113

printf( "X vector or matrix must match matrix dimensions.\n" );

6114

for( i=0; i < nx; i++ )

6115

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6116

free(adat);

6117

free(ai);

6118

return;

6119

}

6120

/* Store whether second dimension is unity. */

6121

Alen = ny;

6122

setup_array_2d_d( &xg, adat, nx, ny );

6123

for( i=0; i < nx; i++ ) {

6124

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6125

(*jenv)->DeleteLocalRef(jenv, ai[i]);

6126

}

6127

6128

free(adat);

6129

free(ai);

6130

arg6 = pltr2;

6131

6132

}

6133

{

6134

jdouble **adat;

6135

jobject *ai;

6136

int nx = (*jenv)->GetArrayLength( jenv, jarg7 );

6137

int ny = -1;

6138

int i, j;

6139

PLcGrid2 cgrid;

6140

ai = (jobject *) malloc( nx * sizeof(jobject) );

6141

adat = (jdouble **) malloc( nx * sizeof(jdouble *) );

6142

6143

for( i=0; i < nx; i++ )

6144

{

6145

ai[i] = (*jenv)->GetObjectArrayElement( jenv, jarg7, i );

6146

adat[i] = (*jenv)->GetDoubleArrayElements( jenv, ai[i], 0 );

6147

6148

if (ny == -1)

6149

ny = (*jenv)->GetArrayLength( jenv, ai[i] );

6150

else if (ny != (*jenv)->GetArrayLength( jenv, ai[i] )) {

6151

printf( "Misshapen a array.\n" );

6152

for( j=0; j <= i; j++ )

6153

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[j], adat[j], 0 );

6154

free(adat);

6155

free(ai);

6156

return;

6157

}

6158

}

6159

6160

if( !((nx == Xlen && ny == Ylen) || (nx == Ylen && ny == 1 && ny == Alen))) {

6161

printf( "Xlen = %d, nx = %d, Ylen = %d, Alen = %d, ny = %d\n",

6162

Xlen, nx, Ylen, Alen, ny );

6163

printf( "Y vector or matrix must match matrix dimensions.\n" );

6164

for( i=0; i < nx; i++ )

6165

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6166

free(adat);

6167

free(ai);

6168

return;

6169

}

6170

setup_array_2d_d( &yg, adat, nx, ny );

6171

for( i=0; i < nx; i++ ) {

6172

(*jenv)->ReleaseDoubleArrayElements( jenv, ai[i], adat[i], 0 );

6173

(*jenv)->DeleteLocalRef(jenv, ai[i]);

6174

}

6175

6176

free(adat);

6177

free(ai);

6178

cgrid.xg = xg;

6179

cgrid.yg = yg;

6180

cgrid.nx = nx;

6181

cgrid.ny = ny;

6182

arg7 = &cgrid;

6183

6184

}

6185

plvect(arg1,arg2,arg3,arg4,arg5,arg6,arg7);

6186

6187

{

6188

free(arg1[0]);

6189

free(arg1);

6190

}

6191

{

6192

free(arg2[0]);

6193

free(arg2);

6194

}

6195

{

6196

free(xg[0]);

6197

free(xg);

6198

}

6199

{

6200

free(yg[0]);

6201

free(yg);

6202

}

5839

6203

}

5840

6204

5841

6205

5842

6206

#define _doc_plvpas "Create the largest viewport of the specified aspect ratio that fits within the specified normalized subpage coordinates."

5843

6207

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvpas(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5) {

5844

PLFLT arg1 ;

5845

PLFLT arg2 ;

5846

PLFLT arg3 ;

5847

PLFLT arg4 ;

5848

PLFLT arg5 ;

5849

5850

(void)jenv;

5851

(void)jcls;

5852

arg1 = (PLFLT)jarg1;

5853

arg2 = (PLFLT)jarg2;

5854

arg3 = (PLFLT)jarg3;

5855

arg4 = (PLFLT)jarg4;

5856

arg5 = (PLFLT)jarg5;

5857

plvpas(arg1,arg2,arg3,arg4,arg5);

5858

6208

PLFLT arg1 ;

6209

PLFLT arg2 ;

6210

PLFLT arg3 ;

6211

PLFLT arg4 ;

6212

PLFLT arg5 ;

6213

6214

(void)jenv;

6215

(void)jcls;

6216

arg1 = (PLFLT)jarg1;

6217

arg2 = (PLFLT)jarg2;

6218

arg3 = (PLFLT)jarg3;

6219

arg4 = (PLFLT)jarg4;

6220

arg5 = (PLFLT)jarg5;

6221

plvpas(arg1,arg2,arg3,arg4,arg5);

6222

5859

6223

}

5860

6224

5861

6225

5862

6226

#define _doc_plvpor "Create a viewport with the specified normalized subpage coordinates."

5863

6227

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvpor(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

5864

PLFLT arg1 ;

5865

PLFLT arg2 ;

5866

PLFLT arg3 ;

5867

PLFLT arg4 ;

5868

5869

(void)jenv;

5870

(void)jcls;

5871

arg1 = (PLFLT)jarg1;

5872

arg2 = (PLFLT)jarg2;

5873

arg3 = (PLFLT)jarg3;

5874

arg4 = (PLFLT)jarg4;

5875

plvpor(arg1,arg2,arg3,arg4);

5876

6228

PLFLT arg1 ;

6229

PLFLT arg2 ;

6230

PLFLT arg3 ;

6231

PLFLT arg4 ;

6232

6233

(void)jenv;

6234

(void)jcls;

6235

arg1 = (PLFLT)jarg1;

6236

arg2 = (PLFLT)jarg2;

6237

arg3 = (PLFLT)jarg3;

6238

arg4 = (PLFLT)jarg4;

6239

plvpor(arg1,arg2,arg3,arg4);

6240

5877

6241

}

5878

6242

5879

6243

5880

6244

#define _doc_plvsta "Define a \"standard\" viewport with seven character heights for the left margin and four character heights everywhere else."

5881

6245

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plvsta(JNIEnv *jenv, jclass jcls) {

5882

(void)jenv;

5883

(void)jcls;

5884

plvsta();

5885

6246

(void)jenv;

6247

(void)jcls;

6248

plvsta();

6249

5886

6250

}

5887

6251

5888

6252

5889

6253

#define _doc_plw3d "Set up a window for three-dimensional plotting."

5890

6254

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plw3d(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4, jdouble jarg5, jdouble jarg6, jdouble jarg7, jdouble jarg8, jdouble jarg9, jdouble jarg10, jdouble jarg11) {

5891

PLFLT arg1 ;

5892

PLFLT arg2 ;

5893

PLFLT arg3 ;

5894

PLFLT arg4 ;

5895

PLFLT arg5 ;

5896

PLFLT arg6 ;

5897

PLFLT arg7 ;

5898

PLFLT arg8 ;

5899

PLFLT arg9 ;

5900

PLFLT arg10 ;

5901

PLFLT arg11 ;

5902

5903

(void)jenv;

5904

(void)jcls;

5905

arg1 = (PLFLT)jarg1;

5906

arg2 = (PLFLT)jarg2;

5907

arg3 = (PLFLT)jarg3;

5908

arg4 = (PLFLT)jarg4;

5909

arg5 = (PLFLT)jarg5;

5910

arg6 = (PLFLT)jarg6;

5911

arg7 = (PLFLT)jarg7;

5912

arg8 = (PLFLT)jarg8;

5913

arg9 = (PLFLT)jarg9;

5914

arg10 = (PLFLT)jarg10;

5915

arg11 = (PLFLT)jarg11;

5916

plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);

5917

6255

PLFLT arg1 ;

6256

PLFLT arg2 ;

6257

PLFLT arg3 ;

6258

PLFLT arg4 ;

6259

PLFLT arg5 ;

6260

PLFLT arg6 ;

6261

PLFLT arg7 ;

6262

PLFLT arg8 ;

6263

PLFLT arg9 ;

6264

PLFLT arg10 ;

6265

PLFLT arg11 ;

6266

6267

(void)jenv;

6268

(void)jcls;

6269

arg1 = (PLFLT)jarg1;

6270

arg2 = (PLFLT)jarg2;

6271

arg3 = (PLFLT)jarg3;

6272

arg4 = (PLFLT)jarg4;

6273

arg5 = (PLFLT)jarg5;

6274

arg6 = (PLFLT)jarg6;

6275

arg7 = (PLFLT)jarg7;

6276

arg8 = (PLFLT)jarg8;

6277

arg9 = (PLFLT)jarg9;

6278

arg10 = (PLFLT)jarg10;

6279

arg11 = (PLFLT)jarg11;

6280

plw3d(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);

6281

5918

6282

}

5919

6283

5920

6284

5921

6285

#define _doc_plwid "Set pen width."

5922

6286

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plwid(JNIEnv *jenv, jclass jcls, jint jarg1) {

5923

PLINT arg1 ;

5924

5925

(void)jenv;

5926

(void)jcls;

5927

arg1 = (PLINT)jarg1;

5928

plwid(arg1);

5929

6287

PLINT arg1 ;

6288

6289

(void)jenv;

6290

(void)jcls;

6291

arg1 = (PLINT)jarg1;

6292

plwid(arg1);

6293

5930

6294

}

5931

6295

5932

6296

5933

6297

#define _doc_plwind "Set up world coordinates of the viewport boundaries (2d plots)."

5934

6298

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plwind(JNIEnv *jenv, jclass jcls, jdouble jarg1, jdouble jarg2, jdouble jarg3, jdouble jarg4) {

5935

PLFLT arg1 ;

5936

PLFLT arg2 ;

5937

PLFLT arg3 ;

5938

PLFLT arg4 ;

5939

5940

(void)jenv;

5941

(void)jcls;

5942

arg1 = (PLFLT)jarg1;

5943

arg2 = (PLFLT)jarg2;

5944

arg3 = (PLFLT)jarg3;

5945

arg4 = (PLFLT)jarg4;

5946

plwind(arg1,arg2,arg3,arg4);

5947

6299

PLFLT arg1 ;

6300

PLFLT arg2 ;

6301

PLFLT arg3 ;

6302

PLFLT arg4 ;

6303

6304

(void)jenv;

6305

(void)jcls;

6306

arg1 = (PLFLT)jarg1;

6307

arg2 = (PLFLT)jarg2;

6308

arg3 = (PLFLT)jarg3;

6309

arg4 = (PLFLT)jarg4;

6310

plwind(arg1,arg2,arg3,arg4);

6311

5948

6312

}

5949

6313

5950

6314

5951

6315

#define _doc_plxormod "Set xor mode; mode = 1-enter, 0-leave, status = 0 if not interactive device."

5952

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plxormod(JNIEnv *jenv, jclass jcls, jint jarg1, jintArray jarg2) {

5953

PLINT arg1 ;

5954

PLINT *arg2 = (PLINT *) 0 ;

5955

PLINT temp2 ;

5956

5957

(void)jenv;

5958

(void)jcls;

5959

arg1 = (PLINT)jarg1;

5960

{

5961

if (!jarg2) {

5962

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

5963

return ;

5964

}

5965

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

5966

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

5967

return ;

5968

}

5969

arg2 = &temp2;

5970

}

5971

plxormod(arg1,arg2);

5972

5973

{

5974

jint jvalue = (jint)temp2;

5975

(*jenv)->SetIntArrayRegion(jenv, jarg2, 0, 1, &jvalue);

5976

}

6316

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plxormod(JNIEnv *jenv, jclass jcls, jboolean jarg1, jbooleanArray jarg2) {

6317

PLBOOL arg1 ;

6318

PLBOOL *arg2 = (PLBOOL *) 0 ;

6319

PLBOOL temp2 ;

6320

6321

(void)jenv;

6322

(void)jcls;

6323

arg1 = jarg1 ? 1 : 0;

6324

{

6325

if (!jarg2) {

6326

SWIG_JavaThrowException(jenv, SWIG_JavaNullPointerException, "array null");

6327

return ;

6328

}

6329

if ((*jenv)->GetArrayLength(jenv, jarg2) == 0) {

6330

SWIG_JavaThrowException(jenv, SWIG_JavaIndexOutOfBoundsException, "Array must contain at least 1 element");

6331

return ;

6332

}

6333

arg2 = &temp2;

6334

}

6335

plxormod(arg1,arg2);

6336

6337

{

6338

jboolean jvalue = (jboolean)temp2;

6339

(*jenv)->SetBooleanArrayRegion(jenv, jarg2, 0, 1, &jvalue);

6340

}

6341

5977

6342

}

5978

6343

5979

6344

5980

6345

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plClearOpts(JNIEnv *jenv, jclass jcls) {

5981

(void)jenv;

5982

(void)jcls;

5983

plClearOpts();

5984

6346

(void)jenv;

6347

(void)jcls;

6348

plClearOpts();

6349

5985

6350

}

5986

6351

5987

6352

5988

6353

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plResetOpts(JNIEnv *jenv, jclass jcls) {

5989

(void)jenv;

5990

(void)jcls;

5991

plResetOpts();

5992

6354

(void)jenv;

6355

(void)jcls;

6356

plResetOpts();

6357

5993

6358

}

5994

6359

5995

6360

5996

6361

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plSetUsage(JNIEnv *jenv, jclass jcls, jstring jarg1, jstring jarg2) {

5997

char *arg1 ;

5998

char *arg2 ;

5999

6000

(void)jenv;

6001

(void)jcls;

6002

{

6003

arg1 = 0;

6004

if (jarg1) {

6005

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

6006

if (!arg1) return ;

6007

}

6008

}

6009

{

6010

arg2 = 0;

6011

if (jarg2) {

6012

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

6013

if (!arg2) return ;

6014

}

6015

}

6016

plSetUsage(arg1,arg2);

6017

6018

{

6019

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

6020

}

6021

{

6022

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

6023

}

6024

}

6025

6026

6027

JNIEXPORT jint JNICALL Java_plplot_core_plplotjavacJNI_plParseOpts(JNIEnv *jenv, jclass jcls, jobjectArray jarg1, jint jarg3) {

6028

jint jresult = 0 ;

6029

PLINT *arg1 = (PLINT *) 0 ;

6030

char **arg2 = (char **) 0 ;

6031

PLINT arg3 ;

6032

PLINT result;

6033

jint size1 ;

6034

6035

(void)jenv;

6036

(void)jcls;

6037

{

6038

int i = 0;

6039

size1 = (*jenv)->GetArrayLength(jenv, jarg1);

6040

arg1 = &size1;

6041

arg2 = (char **) malloc((size1+1)*sizeof(char *));

6042

/* make a copy of each string */

6043

for (i = 0; i<size1; i++) {

6044

jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, jarg1, i);

6045

const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);

6046

/* Commented out version straight from swig documentation, but I think

6047

* it is wrong.

6048

* arg2[i] = malloc(strlen((c_string)+1)*sizeof(const char *)); */

6049

arg2[i] = malloc((strlen(c_string)+1)*sizeof(const char *));

6050

strcpy(arg2[i], c_string);

6051

(*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);

6052

(*jenv)->DeleteLocalRef(jenv, j_string);

6053

}

6054

arg2[i] = 0;

6055

}

6056

arg3 = (PLINT)jarg3;

6057

result = (PLINT)plParseOpts(arg1,arg2,arg3);

6058

6059

jresult = (jint)result;

6060

{

6061

int i;

6062

/* Commented out version straight from swig documentation, but I think

6063

* it is wrong.

6064

* for (i=0; i<size1-1; i++) */

6065

for (i=0; i<size1; i++)

6066

free(arg2[i]);

6067

free(arg2);

6068

}

6069

return jresult;

6362

char *arg1 = (char *) 0 ;

6363

char *arg2 = (char *) 0 ;

6364

6365

(void)jenv;

6366

(void)jcls;

6367

arg1 = 0;

6368

if (jarg1) {

6369

arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);

6370

if (!arg1) return ;

6371

}

6372

arg2 = 0;

6373

if (jarg2) {

6374

arg2 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg2, 0);

6375

if (!arg2) return ;

6376

}

6377

plSetUsage(arg1,arg2);

6378

6379

if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, arg1);

6380

if (arg2) (*jenv)->ReleaseStringUTFChars(jenv, jarg2, arg2);

6070

6381

}

6071

6382

6072

6383

6073

6384

JNIEXPORT void JNICALL Java_plplot_core_plplotjavacJNI_plOptUsage(JNIEnv *jenv, jclass jcls) {

6074

(void)jenv;

6075

(void)jcls;

6076

plOptUsage();

6077

6385

(void)jenv;

6386

(void)jcls;

6387

plOptUsage();

6388

6078

6389

}

6079

6390

6080

6391

Older »