src/java/net_cp_jlibical_ICalProperty_cxx.cpp

   1 /* -*- Mode: C -*- */
   2 /*======================================================================
   3  FILE: net_cp_jlibical_ICalProperty_cxx.cpp
   4  CREATOR: gnorman 1/10/02
   5  (C) COPYRIGHT 2002, Critical Path
   6 ======================================================================*/
   7
   8 #ifndef NET_CP_JLIBICAL_ICALPROPERTY_CXX_H
   9 #include "net_cp_jlibical_ICalProperty_cxx.h"
  10 #endif
  11
  12 #ifndef JLIBICAL_CONSTS_CXX_H
  13 #include "jlibical_consts_cxx.h"
  14 #endif
  15
  16 #ifndef JLIBICAL_UTILS_CXX_H
  17 #include "jlibical_utils_cxx.h"
  18 #endif
  19
  20 #ifndef ICALPROPERTY_CXX_H
  21 #include "icalproperty_cxx.h"
  22 #endif
  23
  24 /*
  25  * Class:     net_cp_jlibical_ICalProperty
  26  * Method:    as_ical_string
  27  * Signature: ()Ljava/lang/String;
  28  */
  29 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_as_1ical_1string
  30   (JNIEnv *env, jobject jobj)
  31 {
  32         jstring result = NULL;
  33         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
  34
  35         if (cObj != NULL)
  36         {
  37                 char* icalStr = cObj->as_ical_string();
  38
  39                 if (icalStr == NULL)
  40                 {
  41                         icalStr = "";
  42                 }
  43
  44                 result = env->NewStringUTF(icalStr);
  45         }
  46
  47         return(result);
  48 }
  49
  50 /*
  51  * Class:     net_cp_jlibical_ICalProperty
  52  * Method:    isa
  53  * Signature: ()I
  54  */
  55 JNIEXPORT jint JNICALL Java_net_cp_jlibical_ICalProperty_isa
  56   (JNIEnv *env, jobject jobj)
  57 {
  58         jint result = 0;
  59         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
  60
  61         if (cObj != NULL)
  62         {
  63                 result = cObj->isa();
  64         }
  65
  66         return(result);
  67 }
  68
  69 /*
  70  * Class:     net_cp_jlibical_ICalProperty
  71  * Method:    isa_property
  72  * Signature: (Ljava/lang/Object;)I
  73  */
  74 JNIEXPORT jboolean JNICALL Java_net_cp_jlibical_ICalProperty_isa_1property
  75   (JNIEnv *env, jobject jobj, jobject arg)
  76 {
  77         jboolean result = 0;
  78         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
  79
  80         if (cObj != NULL)
  81         {
  82                 void* argObjPtr = 0;
  83
  84                 if (arg != NULL)
  85                 {
  86                         argObjPtr = getCObjectPtr(env,arg);
  87                 }
  88
  89                 // get the result from the c++ object (argObjPtr can be 0, it's cObj's responsibility to handle this if an error).
  90                 result = cObj->isa_property(argObjPtr) != 0;
  91         }
  92
  93         return(result);
  94 }
  95
  96 /*
  97  * Class:     net_cp_jlibical_ICalProperty
  98  * Method:    add_parameter
  99  * Signature: (Lnet/cp/jlibical/ICalParameter;)V
 100  */
 101 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_add_1parameter
 102   (JNIEnv *env, jobject jobj, jobject arg)
 103 {
 104         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 105
 106         if (cObj != NULL)
 107         {
 108                 ICalParameter* icalparameter = getSubjectAsICalParameter(env,arg,JLIBICAL_ERR_ILLEGAL_ARGUMENT);
 109
 110                 if (icalparameter != NULL)
 111                 {
 112                         cObj->add_parameter(*icalparameter);
 113                 }
 114         }
 115 }
 116
 117 /*
 118  * Class:     net_cp_jlibical_ICalProperty
 119  * Method:    set_parameter
 120  * Signature: (Lnet/cp/jlibical/ICalParameter;)V
 121  */
 122 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1parameter
 123   (JNIEnv *env, jobject jobj, jobject arg)
 124 {
 125         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 126
 127         if (cObj != NULL)
 128         {
 129                 ICalParameter* icalparameter = getSubjectAsICalParameter(env,arg,JLIBICAL_ERR_ILLEGAL_ARGUMENT);
 130
 131                 if (icalparameter != NULL)
 132                 {
 133                         cObj->set_parameter(*icalparameter);
 134                 }
 135         }
 136 }
 137
 138 /*
 139  * Class:     net_cp_jlibical_ICalProperty
 140  * Method:    set_parameter_from_string
 141  * Signature: (Ljava/lang/String;Ljava/lang/String;)V
 142  */
 143 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1parameter_1from_1string
 144   (JNIEnv *env, jobject jobj, jstring name, jstring value)
 145 {
 146         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 147
 148         if (cObj != NULL)
 149         {
 150                 const char* szName = env->GetStringUTFChars(name,NULL);
 151                 const char* szValue = env->GetStringUTFChars(value,NULL);
 152
 153                 if (szName != NULL && szValue != NULL)
 154                 {
 155                         cObj->set_parameter_from_string((string)szName, (string)szValue);
 156                 }
 157         }
 158 }
 159
 160 /*
 161  * Class:     net_cp_jlibical_ICalProperty
 162  * Method:    get_parameter_as_string
 163  * Signature: (Ljava/lang/String;)Ljava/lang/String;
 164  */
 165 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1parameter_1as_1string
 166   (JNIEnv *env, jobject jobj, jstring name)
 167 {
 168         jstring result = NULL;
 169         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 170
 171         if (cObj != NULL)
 172         {
 173                 const char* szName = env->GetStringUTFChars(name,NULL);
 174
 175                 if (szName != NULL)
 176                 {
 177                         char* szValue = cObj->get_parameter_as_string((string)szName);
 178
 179                         if (szValue == NULL)
 180                         {
 181                                 szValue = "";
 182                         }
 183
 184                         result = env->NewStringUTF(szValue);
 185                 }
 186         }
 187
 188         return (result);
 189 }
 190
 191 /*
 192  * Class:     net_cp_jlibical_ICalProperty
 193  * Method:    remove_parameter
 194  * Signature: (I)V
 195  */
 196 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_remove_1parameter
 197   (JNIEnv *env, jobject jobj, jint kind)
 198 {
 199         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 200
 201         if (cObj != NULL)
 202         {
 203                 cObj->remove_parameter((icalparameter_kind)kind);
 204         }
 205 }
 206
 207 /*
 208  * Class:     net_cp_jlibical_ICalProperty
 209  * Method:    count_parameters
 210  * Signature: ()I
 211  */
 212 JNIEXPORT jint JNICALL Java_net_cp_jlibical_ICalProperty_count_1parameters
 213   (JNIEnv *env, jobject jobj)
 214 {
 215         jint result = 0;
 216         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 217
 218         if (cObj != NULL)
 219         {
 220                 result = cObj->count_parameters();
 221         }
 222
 223         return(result);
 224 }
 225
 226 /*
 227  * Class:     net_cp_jlibical_ICalProperty
 228  * Method:    get_first_parameter
 229  * Signature: (I)Lnet/cp/jlibical/ICalParameter;
 230  */
 231 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1first_1parameter
 232   (JNIEnv *env, jobject jobj, jint kind)
 233 {
 234         jobject result = 0;
 235         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 236
 237         if (cObj != NULL)
 238         {
 239                 // get the first parameter from CObj
 240                 ICalParameter* aParameter = cObj->get_first_parameter((icalparameter_kind)kind);
 241
 242                 // create a new surrogate, using aParameter as the subject (returns NULL if subject is NULL).
 243                 result = createNewICalParameterSurrogate(env,aParameter);
 244         }
 245
 246         return(result);
 247 }
 248
 249 /*
 250  * Class:     net_cp_jlibical_ICalProperty
 251  * Method:    get_next_parameter
 252  * Signature: (I)Lnet/cp/jlibical/ICalParameter;
 253  */
 254 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1next_1parameter
 255   (JNIEnv *env, jobject jobj, jint kind)
 256 {
 257         jobject result = 0;
 258         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 259
 260         if (cObj != NULL)
 261         {
 262                 // get the first parameter from CObj
 263                 ICalParameter* aParameter = cObj->get_next_parameter((icalparameter_kind)kind);
 264
 265                 // create a new surrogate, using aParameter as the subject (returns NULL if subject is NULL).
 266                 result = createNewICalParameterSurrogate(env,aParameter);
 267         }
 268
 269         return(result);
 270 }
 271
 272 /*
 273  * Class:     net_cp_jlibical_ICalProperty
 274  * Method:    set_value
 275  * Signature: (Lnet/cp/jlibical/ICalValue;)V
 276  */
 277 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1value
 278   (JNIEnv *env, jobject jobj, jobject arg)
 279 {
 280         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 281
 282         if (cObj != NULL)
 283         {
 284                 ICalValue* aValue = getSubjectAsICalValue(env,arg,JLIBICAL_ERR_ILLEGAL_ARGUMENT);
 285                 cObj->set_value(*aValue);
 286         }
 287 }
 288
 289 /*
 290  * Class:     net_cp_jlibical_ICalProperty
 291  * Method:    set_value_from_string
 292  * Signature: (Ljava/lang/String;Ljava/lang/String;)V
 293  */
 294 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1value_1from_1string
 295   (JNIEnv *env, jobject jobj, jstring name, jstring value)
 296 {
 297         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 298
 299         if (cObj != NULL)
 300         {
 301                 const char* szName = env->GetStringUTFChars(name,NULL);
 302                 const char* szValue = env->GetStringUTFChars(value,NULL);
 303
 304                 if (szName != NULL && szValue != NULL)
 305                 {
 306                         cObj->set_value_from_string((string)szName, (string)szValue);
 307                 }
 308         }
 309 }
 310
 311 /*
 312  * Class:     net_cp_jlibical_ICalProperty
 313  * Method:    get_value
 314  * Signature: ()Lnet/cp/jlibical/ICalValue;
 315  */
 316 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1value
 317   (JNIEnv *env, jobject jobj)
 318 {
 319         jobject result = 0;
 320         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 321
 322         if (cObj != NULL)
 323         {
 324                 // get the first value from CObj
 325                 ICalValue* aValue = cObj->get_value();
 326
 327                 // create a new surrogate, using aValue as the subject (returns NULL if subject is NULL).
 328                 result = createNewICalValueSurrogate(env,aValue);
 329         }
 330
 331         return (result);
 332 }
 333
 334 /*
 335  * Class:     net_cp_jlibical_ICalProperty
 336  * Method:    get_value_as_string
 337  * Signature: ()Ljava/lang/String;
 338  */
 339 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1value_1as_1string
 340   (JNIEnv *env, jobject jobj)
 341 {
 342         jstring result = NULL;
 343         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 344
 345         if (cObj != NULL)
 346         {
 347                 char* icalStr = cObj->get_value_as_string();
 348
 349                 if (icalStr == NULL)
 350                 {
 351                         icalStr = "";
 352                 }
 353
 354                 result = env->NewStringUTF(icalStr);
 355         }
 356
 357         return(result);
 358 }
 359
 360 /*
 361  * Class:     net_cp_jlibical_ICalProperty
 362  * Method:    get_name
 363  * Signature: ()Ljava/lang/String;
 364  */
 365 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1name
 366   (JNIEnv *env, jobject jobj)
 367 {
 368         jstring result = NULL;
 369         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 370
 371         if (cObj != NULL)
 372         {
 373                 char* icalStr = cObj->get_name();
 374
 375                 if (icalStr == NULL)
 376                 {
 377                         icalStr = "";
 378                 }
 379
 380                 result = env->NewStringUTF(icalStr);
 381         }
 382
 383         return(result);
 384 }
 385
 386 /*
 387  * Class:     net_cp_jlibical_ICalProperty
 388  * Method:    set_action
 389  * Signature: (I)V
 390  */
 391 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1action
 392   (JNIEnv *env, jobject jobj, jint value)
 393 {
 394         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 395
 396         if (cObj != NULL)
 397         {
 398                 cObj->set_action((icalproperty_action)value);
 399         }
 400 }
 401
 402 /*
 403  * Class:     net_cp_jlibical_ICalProperty
 404  * Method:    get_action
 405  * Signature: ()I
 406  */
 407 JNIEXPORT jint JNICALL Java_net_cp_jlibical_ICalProperty_get_1action
 408   (JNIEnv *env, jobject jobj)
 409 {
 410         jint result = 0;
 411         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 412
 413         if (cObj != NULL)
 414         {
 415                 result = cObj->get_action();
 416         }
 417
 418         return(result);
 419 }
 420
 421 /*
 422  * Class:     net_cp_jlibical_ICalProperty
 423  * Method:    set_attendee
 424  * Signature: (Ljava/lang/String;)V
 425  */
 426 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1attendee
 427   (JNIEnv *env, jobject jobj, jstring str)
 428 {
 429         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 430
 431         if (cObj != NULL)
 432         {
 433                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 434
 435                 cObj->set_attendee((char*)szTemp);
 436                 env->ReleaseStringUTFChars(str,szTemp);
 437         }
 438 }
 439
 440 /*
 441  * Class:     net_cp_jlibical_ICalProperty
 442  * Method:    get_attendee
 443  * Signature: ()Ljava/lang/String;
 444  */
 445 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1attendee
 446   (JNIEnv *env, jobject jobj)
 447 {
 448         jstring result = NULL;
 449         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 450
 451         if (cObj != NULL)
 452         {
 453                 char* icalStr = cObj->get_attendee();
 454
 455                 if (icalStr == NULL)
 456                 {
 457                         icalStr = "";
 458                 }
 459
 460                 result = env->NewStringUTF(icalStr);
 461         }
 462
 463         return(result);
 464 }
 465
 466 /*
 467  * Class:     net_cp_jlibical_ICalProperty
 468  * Method:    set_comment
 469  * Signature: (Ljava/lang/String;)V
 470  */
 471 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1comment
 472   (JNIEnv *env, jobject jobj, jstring str)
 473 {
 474         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 475
 476         if (cObj != NULL)
 477         {
 478                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 479
 480                 cObj->set_comment((char*)szTemp);
 481                 env->ReleaseStringUTFChars(str,szTemp);
 482         }
 483 }
 484
 485 /*
 486  * Class:     net_cp_jlibical_ICalProperty
 487  * Method:    get_comment
 488  * Signature: ()Ljava/lang/String;
 489  */
 490 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1comment
 491   (JNIEnv *env, jobject jobj)
 492 {
 493         jstring result = NULL;
 494         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 495
 496         if (cObj != NULL)
 497         {
 498                 char* commentStr = cObj->get_comment();
 499
 500                 if (commentStr == NULL)
 501                 {
 502                         commentStr = "";
 503                 }
 504
 505                 result = env->NewStringUTF(commentStr);
 506         }
 507         return(result);
 508 }
 509
 510 /*
 511  * Class:     net_cp_jlibical_ICalProperty
 512  * Method:    set_description
 513  * Signature: (Ljava/lang/String;)V
 514  */
 515 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1description
 516   (JNIEnv *env, jobject jobj, jstring str)
 517 {
 518         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 519
 520         if (cObj != NULL)
 521         {
 522                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 523
 524                 cObj->set_description((char*)szTemp);
 525                 env->ReleaseStringUTFChars(str,szTemp);
 526         }
 527 }
 528
 529 /*
 530  * Class:     net_cp_jlibical_ICalProperty
 531  * Method:    get_description
 532  * Signature: ()Ljava/lang/String;
 533  */
 534 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1description
 535   (JNIEnv *env, jobject jobj)
 536 {
 537         jstring result = NULL;
 538         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 539
 540         if (cObj != NULL)
 541         {
 542                 char* icalStr = cObj->get_description();
 543
 544                 if (icalStr == NULL)
 545                 {
 546                         icalStr = "";
 547                 }
 548
 549                 result = env->NewStringUTF(icalStr);
 550         }
 551
 552         return(result);
 553 }
 554
 555 /*
 556  * Class:     net_cp_jlibical_ICalProperty
 557  * Method:    set_dtend
 558  * Signature: (Lnet/cp/jlibical/ICalTimeType;)V
 559  */
 560 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1dtend
 561   (JNIEnv *env, jobject jobj, jobject arg)
 562 {
 563         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 564
 565         if (cObj != NULL)
 566         {
 567                 icaltimetype aTime;
 568
 569                 if (copyObjToicaltimetype(env,arg,&aTime))
 570                 {
 571                         cObj->set_dtend(aTime);
 572                 }
 573         }
 574 }
 575
 576 /*
 577  * Class:     net_cp_jlibical_ICalProperty
 578  * Method:    get_dtend
 579  * Signature: ()Lnet/cp/jlibical/ICalTimeType;
 580  */
 581 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1dtend
 582   (JNIEnv *env, jobject jobj)
 583 {
 584         jobject result = 0;
 585         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 586
 587         if (cObj != NULL)
 588         {
 589                 // get the dtend time from CObj
 590                 icaltimetype aTime = cObj->get_dtend();
 591
 592                 // create a new surrogate, using aTime as the subject.
 593                 result = createNewICalTimeType(env,&aTime);
 594         }
 595
 596         return (result);
 597 }
 598
 599 /*
 600  * Class:     net_cp_jlibical_ICalProperty
 601  * Method:    set_dtstamp
 602  * Signature: (Lnet/cp/jlibical/ICalTimeType;)V
 603  */
 604 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1dtstamp
 605   (JNIEnv *env, jobject jobj, jobject dtstamp)
 606 {
 607         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 608
 609         if (cObj != NULL)
 610         {
 611                 icaltimetype aDTStamp;
 612
 613                 if (copyObjToicaltimetype(env,dtstamp,&aDTStamp))
 614                 {
 615                         cObj->set_dtstamp(aDTStamp);
 616                 }
 617         }
 618 }
 619
 620 /*
 621  * Class:     net_cp_jlibical_ICalProperty
 622  * Method:    get_dtstamp
 623  * Signature: ()Lnet/cp/jlibical/ICalTimeType;
 624  */
 625 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1dtstamp
 626   (JNIEnv *env, jobject jobj)
 627 {
 628         jobject result = 0;
 629         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 630
 631         if (cObj != NULL)
 632         {
 633                 // get the dtstamp time from CObj
 634                 icaltimetype aDTStamp = cObj->get_dtstamp();
 635
 636                 // create a new surrogate, using aDTStamp as the subject.
 637                 result = createNewICalTimeType(env,&aDTStamp);
 638         }
 639
 640         return (result);
 641 }
 642
 643 /*
 644  * Class:     net_cp_jlibical_ICalProperty
 645  * Method:    set_dtstart
 646  * Signature: (Lnet/cp/jlibical/ICalTimeType;)V
 647  */
 648 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1dtstart
 649   (JNIEnv *env, jobject jobj, jobject arg)
 650 {
 651         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 652
 653         if (cObj != NULL)
 654         {
 655                 icaltimetype aTime;
 656
 657                 if (copyObjToicaltimetype(env,arg,&aTime))
 658                 {
 659                         cObj->set_dtstart(aTime);
 660                 }
 661         }
 662 }
 663
 664 /*
 665  * Class:     net_cp_jlibical_ICalProperty
 666  * Method:    get_dtstart
 667  * Signature: ()Lnet/cp/jlibical/ICalTimeType;
 668  */
 669 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1dtstart
 670   (JNIEnv *env, jobject jobj)
 671 {
 672         jobject result = 0;
 673         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 674
 675         if (cObj != NULL)
 676         {
 677                 // get the dtend time from CObj
 678                 icaltimetype aTime = cObj->get_dtstart();
 679
 680                 // create a new surrogate, using aTime as the subject.
 681                 result = createNewICalTimeType(env,&aTime);
 682         }
 683
 684         return (result);
 685 }
 686
 687 /*
 688  * Class:     net_cp_jlibical_ICalProperty
 689  * Method:    set_due
 690  * Signature: (Lnet/cp/jlibical/ICalTimeType;)V
 691  */
 692 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1due
 693   (JNIEnv *env, jobject jobj, jobject arg)
 694 {
 695         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 696
 697         if (cObj != NULL)
 698         {
 699                 icaltimetype aTime;
 700
 701                 if (copyObjToicaltimetype(env,arg,&aTime))
 702                 {
 703                         cObj->set_due(aTime);
 704                 }
 705         }
 706 }
 707
 708 /*
 709  * Class:     net_cp_jlibical_ICalProperty
 710  * Method:    get_due
 711  * Signature: ()Lnet/cp/jlibical/ICalTimeType;
 712  */
 713 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1due
 714   (JNIEnv *env, jobject jobj)
 715 {
 716         jobject result = 0;
 717         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 718
 719         if (cObj != NULL)
 720         {
 721                 // get the dtend time from CObj
 722                 icaltimetype aTime = cObj->get_due();
 723
 724                 // create a new surrogate, using aTime as the subject.
 725                 result = createNewICalTimeType(env,&aTime);
 726         }
 727
 728         return (result);
 729 }
 730
 731 /*
 732  * Class:     net_cp_jlibical_ICalProperty
 733  * Method:    set_duration
 734  * Signature: (Lnet/cp/jlibical/ICalDurationType;)V
 735  */
 736 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1duration
 737   (JNIEnv *env, jobject jobj, jobject arg)
 738 {
 739         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 740
 741         if (cObj != NULL)
 742         {
 743                 icaldurationtype aDuration;
 744
 745                 if (copyObjToicaldurationtype(env,arg,&aDuration))
 746                 {
 747                         cObj->set_duration(aDuration);
 748                 }
 749         }
 750 }
 751
 752 /*
 753  * Class:     net_cp_jlibical_ICalProperty
 754  * Method:    get_duration
 755  * Signature: ()Lnet/cp/jlibical/ICalDurationType;
 756  */
 757 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1duration
 758   (JNIEnv *env, jobject jobj)
 759 {
 760         jobject result = 0;
 761         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 762
 763         if (cObj != NULL)
 764         {
 765                 // get the dtend time from CObj
 766                 icaldurationtype aDuration = cObj->get_duration();
 767
 768                 // create a new surrogate, using aTime as the subject.
 769                 result = createNewICalDurationType(env,&aDuration);
 770         }
 771
 772         return (result);
 773 }
 774
 775 /*
 776  * Class:     net_cp_jlibical_ICalProperty
 777  * Method:    set_location
 778  * Signature: (Ljava/lang/String;)V
 779  */
 780 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1location
 781   (JNIEnv *env, jobject jobj, jstring str)
 782 {
 783         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 784
 785         if (cObj != NULL)
 786         {
 787                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 788
 789                 cObj->set_location((char*)szTemp);
 790                 env->ReleaseStringUTFChars(str,szTemp);
 791         }
 792 }
 793
 794 /*
 795  * Class:     net_cp_jlibical_ICalProperty
 796  * Method:    get_location
 797  * Signature: ()Ljava/lang/String;
 798  */
 799 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1location
 800   (JNIEnv *env, jobject jobj)
 801 {
 802         jstring result = NULL;
 803         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 804
 805         if (cObj != NULL)
 806         {
 807                 char* icalStr = cObj->get_location();
 808
 809                 if (icalStr == NULL)
 810                 {
 811                         icalStr = "";
 812                 }
 813
 814                 result = env->NewStringUTF(icalStr);
 815         }
 816
 817         return(result);
 818 }
 819
 820 /*
 821  * Class:     net_cp_jlibical_ICalProperty
 822  * Method:    set_method
 823  * Signature: (I)V
 824  */
 825 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1method
 826   (JNIEnv *env, jobject jobj, jint value)
 827 {
 828         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 829
 830         if (cObj != NULL)
 831         {
 832                 cObj->set_method((icalproperty_method)value);
 833         }
 834 }
 835
 836 /*
 837  * Class:     net_cp_jlibical_ICalProperty
 838  * Method:    get_method
 839  * Signature: ()I
 840  */
 841 JNIEXPORT jint JNICALL Java_net_cp_jlibical_ICalProperty_get_1method
 842   (JNIEnv *env, jobject jobj)
 843 {
 844         jint result = 0;
 845         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 846
 847         if (cObj != NULL)
 848         {
 849                 result = cObj->get_method();
 850         }
 851
 852         return(result);
 853 }
 854
 855 /*
 856  * Class:     net_cp_jlibical_ICalProperty
 857  * Method:    set_organizer
 858  * Signature: (Ljava/lang/String;)V
 859  */
 860 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1organizer
 861   (JNIEnv *env, jobject jobj, jstring str)
 862 {
 863         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 864
 865         if (cObj != NULL)
 866         {
 867                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 868
 869                 cObj->set_organizer((char*)szTemp);
 870                 env->ReleaseStringUTFChars(str,szTemp);
 871         }
 872 }
 873
 874 /*
 875  * Class:     net_cp_jlibical_ICalProperty
 876  * Method:    get_organizer
 877  * Signature: ()Ljava/lang/String;
 878  */
 879 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1organizer
 880   (JNIEnv *env, jobject jobj)
 881 {
 882         jstring result = NULL;
 883         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 884
 885         if (cObj != NULL)
 886         {
 887                 char* organizerStr = cObj->get_organizer();
 888
 889                 if (organizerStr == NULL)
 890                 {
 891                         organizerStr = "";
 892                 }
 893
 894                 result = env->NewStringUTF(organizerStr);
 895         }
 896         return(result);
 897 }
 898
 899 /*
 900  * Class:     net_cp_jlibical_ICalProperty
 901  * Method:    set_owner
 902  * Signature: (Ljava/lang/String;)V
 903  */
 904 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1owner
 905   (JNIEnv *env, jobject jobj, jstring str)
 906 {
 907         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 908
 909         if (cObj != NULL)
 910         {
 911                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 912
 913                 cObj->set_owner((char*)szTemp);
 914                 env->ReleaseStringUTFChars(str,szTemp);
 915         }
 916 }
 917
 918 /*
 919  * Class:     net_cp_jlibical_ICalProperty
 920  * Method:    get_owner
 921  * Signature: ()Ljava/lang/String;
 922  */
 923 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1owner
 924   (JNIEnv *env, jobject jobj)
 925 {
 926         jstring result = NULL;
 927         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 928
 929         if (cObj != NULL)
 930         {
 931                 char* icalStr = cObj->get_owner();
 932
 933                 if (icalStr == NULL)
 934                 {
 935                         icalStr = "";
 936                 }
 937
 938                 result = env->NewStringUTF(icalStr);
 939         }
 940
 941         return(result);
 942 }
 943
 944 /*
 945  * Class:     net_cp_jlibical_ICalProperty
 946  * Method:    set_prodid
 947  * Signature: (Ljava/lang/String;)V
 948  */
 949 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1prodid
 950   (JNIEnv *env, jobject jobj, jstring str)
 951 {
 952         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 953
 954         if (cObj != NULL)
 955         {
 956                 const char* szTemp = env->GetStringUTFChars(str,NULL);
 957
 958                 cObj->set_prodid((char*)szTemp);
 959                 env->ReleaseStringUTFChars(str,szTemp);
 960         }
 961 }
 962
 963 /*
 964  * Class:     net_cp_jlibical_ICalProperty
 965  * Method:    get_prodid
 966  * Signature: ()Ljava/lang/String;
 967  */
 968 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1prodid
 969   (JNIEnv *env, jobject jobj)
 970 {
 971         jstring result = NULL;
 972         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 973
 974         if (cObj != NULL)
 975         {
 976                 char* icalStr = cObj->get_prodid();
 977
 978                 if (icalStr == NULL)
 979                 {
 980                         icalStr = "";
 981                 }
 982
 983                 result = env->NewStringUTF(icalStr);
 984         }
 985
 986         return(result);
 987 }
 988
 989 /*
 990  * Class:     net_cp_jlibical_ICalProperty
 991  * Method:    set_query
 992  * Signature: (Ljava/lang/String;)V
 993  */
 994 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1query
 995   (JNIEnv *env, jobject jobj, jstring str)
 996 {
 997         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
 998
 999         if (cObj != NULL)
1000         {
1001                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1002
1003                 cObj->set_query((char*)szTemp);
1004                 env->ReleaseStringUTFChars(str,szTemp);
1005         }
1006 }
1007
1008 /*
1009  * Class:     net_cp_jlibical_ICalProperty
1010  * Method:    get_query
1011  * Signature: ()Ljava/lang/String;
1012  */
1013 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1query
1014   (JNIEnv *env, jobject jobj)
1015 {
1016         jstring result = NULL;
1017         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1018
1019         if (cObj != NULL)
1020         {
1021                 char* icalStr = cObj->get_query();
1022
1023                 if (icalStr == NULL)
1024                 {
1025                         icalStr = "";
1026                 }
1027
1028                 result = env->NewStringUTF(icalStr);
1029         }
1030
1031         return(result);
1032 }
1033
1034 /*
1035  * Class:     net_cp_jlibical_ICalProperty
1036  * Method:    set_queryname
1037  * Signature: (Ljava/lang/String;)V
1038  */
1039 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1queryname
1040   (JNIEnv *env, jobject jobj, jstring str)
1041 {
1042         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1043
1044         if (cObj != NULL)
1045         {
1046                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1047
1048                 cObj->set_queryname((char*)szTemp);
1049                 env->ReleaseStringUTFChars(str,szTemp);
1050         }
1051 }
1052
1053 /*
1054  * Class:     net_cp_jlibical_ICalProperty
1055  * Method:    get_queryname
1056  * Signature: ()Ljava/lang/String;
1057  */
1058 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1queryname
1059   (JNIEnv *env, jobject jobj)
1060 {
1061         jstring result = NULL;
1062         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1063
1064         if (cObj != NULL)
1065         {
1066                 char* icalStr = cObj->get_queryname();
1067
1068                 if (icalStr == NULL)
1069                 {
1070                         icalStr = "";
1071                 }
1072
1073                 result = env->NewStringUTF(icalStr);
1074         }
1075
1076         return(result);
1077 }
1078
1079 /*
1080  * Class:     net_cp_jlibical_ICalProperty
1081  * Method:    set_repeat
1082  * Signature: (I)V
1083  */
1084 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1repeat
1085   (JNIEnv *env, jobject jobj, jint value)
1086 {
1087         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1088
1089         if (cObj != NULL)
1090         {
1091                 cObj->set_repeat(value);
1092         }
1093 }
1094
1095 /*
1096  * Class:     net_cp_jlibical_ICalProperty
1097  * Method:    get_repeat
1098  * Signature: ()I
1099  */
1100 JNIEXPORT jint JNICALL Java_net_cp_jlibical_ICalProperty_get_1repeat
1101   (JNIEnv *env, jobject jobj)
1102 {
1103         jint result = 0;
1104         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1105
1106         if (cObj != NULL)
1107         {
1108                 result = cObj->get_repeat();
1109         }
1110
1111         return(result);
1112 }
1113
1114 /*
1115  * Class:     net_cp_jlibical_ICalProperty
1116  * Method:    set_summary
1117  * Signature: (Ljava/lang/String;)V
1118  */
1119 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1summary
1120   (JNIEnv *env, jobject jobj, jstring str)
1121 {
1122         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1123
1124         if (cObj != NULL)
1125         {
1126                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1127
1128                 cObj->set_summary((char*)szTemp);
1129                 env->ReleaseStringUTFChars(str,szTemp);
1130         }
1131 }
1132
1133 /*
1134  * Class:     net_cp_jlibical_ICalProperty
1135  * Method:    get_summary
1136  * Signature: ()Ljava/lang/String;
1137  */
1138 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1summary
1139   (JNIEnv *env, jobject jobj)
1140 {
1141         jstring result = NULL;
1142         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1143
1144         if (cObj != NULL)
1145         {
1146                 char* icalStr = cObj->get_summary();
1147
1148                 if (icalStr == NULL)
1149                 {
1150                         icalStr = "";
1151                 }
1152
1153                 result = env->NewStringUTF(icalStr);
1154         }
1155
1156         return(result);
1157 }
1158
1159 /*
1160  * Class:     net_cp_jlibical_ICalProperty
1161  * Method:    set_target
1162  * Signature: (Ljava/lang/String;)V
1163  */
1164 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1target
1165   (JNIEnv *env, jobject jobj, jstring str)
1166 {
1167         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1168
1169         if (cObj != NULL)
1170         {
1171                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1172
1173                 cObj->set_target((char*)szTemp);
1174                 env->ReleaseStringUTFChars(str,szTemp);
1175         }
1176 }
1177
1178 /*
1179  * Class:     net_cp_jlibical_ICalProperty
1180  * Method:    get_target
1181  * Signature: ()Ljava/lang/String;
1182  */
1183 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1target
1184   (JNIEnv *env, jobject jobj)
1185 {
1186         jstring result = NULL;
1187         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1188
1189         if (cObj != NULL)
1190         {
1191                 char* icalStr = cObj->get_target();
1192
1193                 if (icalStr == NULL)
1194                 {
1195                         icalStr = "";
1196                 }
1197
1198                 result = env->NewStringUTF(icalStr);
1199         }
1200
1201         return(result);
1202 }
1203
1204 /*
1205  * Class:     net_cp_jlibical_ICalProperty
1206  * Method:    set_trigger
1207  * Signature: (Lnet/cp/jlibical/ICalTriggerType;)V
1208  */
1209 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1trigger
1210   (JNIEnv *env, jobject jobj, jobject arg)
1211 {
1212         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1213
1214         if (cObj != NULL)
1215         {
1216                 icaltriggertype aTrigger;
1217
1218                 if (copyObjToicaltriggertype(env,arg,&aTrigger))
1219                 {
1220                         cObj->set_trigger(aTrigger);
1221                 }
1222         }
1223 }
1224
1225 /*
1226  * Class:     net_cp_jlibical_ICalProperty
1227  * Method:    get_trigger
1228  * Signature: ()Lnet/cp/jlibical/ICalTriggerType;
1229  */
1230 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1trigger
1231   (JNIEnv *env, jobject jobj)
1232 {
1233         jobject result = 0;
1234         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1235
1236         if (cObj != NULL)
1237         {
1238                 // get the dtend time from CObj
1239                 icaltriggertype aTrigger = cObj->get_trigger();
1240
1241                 // create a new surrogate, using aTime as the subject.
1242                 result = createNewICalTriggerType(env,&aTrigger);
1243         }
1244
1245         return (result);
1246 }
1247
1248 /*
1249  * Class:     net_cp_jlibical_ICalProperty
1250  * Method:    set_tzid
1251  * Signature: (Ljava/lang/String;)V
1252  */
1253 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1tzid
1254   (JNIEnv *env, jobject jobj, jstring str)
1255 {
1256         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1257
1258         if (cObj != NULL)
1259         {
1260                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1261
1262                 cObj->set_tzid((char*)szTemp);
1263                 env->ReleaseStringUTFChars(str,szTemp);
1264         }
1265 }
1266
1267 /*
1268  * Class:     net_cp_jlibical_ICalProperty
1269  * Method:    get_tzid
1270  * Signature: ()Ljava/lang/String;
1271  */
1272 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1tzid
1273   (JNIEnv *env, jobject jobj)
1274 {
1275         jstring result = NULL;
1276         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1277
1278         if (cObj != NULL)
1279         {
1280                 char* icalStr = cObj->get_tzid();
1281
1282                 if (icalStr == NULL)
1283                 {
1284                         icalStr = "";
1285                 }
1286
1287                 result = env->NewStringUTF(icalStr);
1288         }
1289
1290         return(result);
1291 }
1292
1293 /*
1294  * Class:     net_cp_jlibical_ICalProperty
1295  * Method:    set_uid
1296  * Signature: (Ljava/lang/String;)V
1297  */
1298 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1uid
1299   (JNIEnv *env, jobject jobj, jstring str)
1300 {
1301         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1302
1303         if (cObj != NULL)
1304         {
1305                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1306
1307                 cObj->set_uid((char*)szTemp);
1308                 env->ReleaseStringUTFChars(str,szTemp);
1309         }
1310 }
1311
1312 /*
1313  * Class:     net_cp_jlibical_ICalProperty
1314  * Method:    get_uid
1315  * Signature: ()Ljava/lang/String;
1316  */
1317 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1uid
1318   (JNIEnv *env, jobject jobj)
1319 {
1320         jstring result = NULL;
1321         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1322
1323         if (cObj != NULL)
1324         {
1325                 char* icalStr = cObj->get_uid();
1326
1327                 if (icalStr == NULL)
1328                 {
1329                         icalStr = "";
1330                 }
1331
1332                 result = env->NewStringUTF(icalStr);
1333         }
1334
1335         return(result);
1336 }
1337
1338 /*
1339  * Class:     net_cp_jlibical_ICalProperty
1340  * Method:    init
1341  * Signature: ()V
1342  */
1343 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_init__
1344   (JNIEnv *env, jobject jobj)
1345 {
1346         setCObjectPtr(env,jobj,new ICalProperty());
1347 }
1348
1349 /*
1350  * Class:     net_cp_jlibical_ICalProperty
1351  * Method:    init
1352  * Signature: (Ljava/lang/String;)V
1353  */
1354 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_init__Ljava_lang_String_2
1355   (JNIEnv *env, jobject jobj, jstring str)
1356 {
1357         if (str != NULL)
1358         {
1359                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1360
1361                 setCObjectPtr(env,jobj,new ICalProperty((char*)szTemp));
1362                 env->ReleaseStringUTFChars(str,szTemp);
1363         }
1364         else
1365         {
1366                 throwException( env, JLIBICAL_ERR_ILLEGAL_ARGUMENT );
1367         }
1368 }
1369
1370 /*
1371  * Class:     net_cp_jlibical_ICalProperty
1372  * Method:    init
1373  * Signature: (I)V
1374  */
1375 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_init__I
1376   (JNIEnv *env, jobject jobj, jint kind)
1377 {
1378         setCObjectPtr(env,jobj,new ICalProperty((icalproperty_kind)kind));
1379 }
1380
1381
1382 /*
1383  * Class:     net_cp_jlibical_ICalProperty
1384  * Method:    set_status
1385  * Signature: (I)V
1386  */
1387
1388 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1status
1389   (JNIEnv *env, jobject jobj, jint value)
1390 {
1391         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1392
1393         if (cObj != NULL)
1394         {
1395                 cObj->set_status((icalproperty_status)value);
1396         }
1397 }
1398
1399 /*
1400  * Class:     net_cp_jlibical_ICalProperty
1401  * Method:    get_status
1402  * Signature: ()I
1403  */
1404 JNIEXPORT jint JNICALL Java_net_cp_jlibical_ICalProperty_get_1status
1405   (JNIEnv *env, jobject jobj)
1406 {
1407         jint result = 0;
1408         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1409
1410         if (cObj != NULL)
1411         {
1412                 result = cObj->get_status();
1413         }
1414
1415         return(result);
1416 }
1417
1418 /*
1419  * Class:     net_cp_jlibical_ICalProperty
1420  * Method:    set_relcalid
1421  * Signature: (Ljava/lang/String;)V
1422  */
1423 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1relcalid
1424   (JNIEnv *env, jobject jobj, jstring str)
1425 {
1426         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1427
1428         if (cObj != NULL)
1429         {
1430                 const char* szTemp = env->GetStringUTFChars(str,NULL);
1431
1432                 cObj->set_relcalid((char *)szTemp);
1433
1434                 env->ReleaseStringUTFChars(str,szTemp);
1435         }
1436 }
1437
1438 /*
1439  * Class:     net_cp_jlibical_ICalProperty
1440  * Method:    get_relcalid
1441  * Signature: ()Ljava/lang/String;
1442  */
1443 JNIEXPORT jstring JNICALL Java_net_cp_jlibical_ICalProperty_get_1relcalid
1444   (JNIEnv *env, jobject jobj)
1445 {
1446         jstring result = NULL;
1447         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1448
1449         if (cObj != NULL)
1450         {
1451                 char* icalStr = cObj->get_relcalid();
1452
1453                 if (icalStr == NULL)
1454                 {
1455                        icalStr = "";
1456                 }
1457
1458                 result = env->NewStringUTF(icalStr);
1459         }
1460
1461         return(result);
1462 }
1463
1464 /*
1465  * Class:     net_cp_jlibical_ICalProperty
1466  * Method:    set_exdate
1467  * Signature: (Lnet/cp/jlibical/ICalTimeType;)V
1468  */
1469 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1exdate
1470   (JNIEnv *env, jobject jobj, jobject exdate)
1471 {
1472         // get the ICalProperty c++ object from jobj
1473         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1474
1475         if (cObj != NULL)
1476         {
1477                 icaltimetype aExDate;
1478
1479                 if (copyObjToicaltimetype(env,exdate,&aExDate))
1480                 {
1481                         cObj->set_exdate(aExDate);
1482                 }
1483         }
1484 }
1485
1486 /*
1487  * Class:     net_cp_jlibical_ICalProperty
1488  * Method:    get_exdate
1489  * Signature: ()Lnet/cp/jlibical/ICalTimeType;
1490  */
1491 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1exdate
1492   (JNIEnv *env, jobject jobj)
1493 {
1494         jobject result = 0;
1495         // get the ICalProperty c++ object from jobj
1496         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1497
1498         if (cObj != NULL)
1499         {
1500                 // get the exdate from CObj
1501                 icaltimetype aExDate = cObj->get_exdate();
1502
1503                 // create a new surrogate, using aRecurrenceId as the subject.
1504                 result = createNewICalTimeType(env,&aExDate);
1505         }
1506
1507         return(result);
1508 }
1509
1510 /*
1511  * Class:     net_cp_jlibical_ICalProperty
1512  * Method:    set_exrule
1513  * Signature: (Lnet/cp/jlibical/ICalRecurrenceType;)V
1514  */
1515 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1exrule
1516   (JNIEnv *env, jobject jobj, jobject exrule)
1517 {
1518         // get the ICalProperty c++ object from jobj
1519         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1520         if (cObj != NULL)
1521         {
1522                 icalrecurrencetype aExRule;
1523                 if (copyObjToicalrecurrencetype(env,exrule,&aExRule))
1524                 {
1525                         cObj->set_exrule(aExRule);
1526                 }
1527         }
1528 }
1529
1530 /*
1531  * Class:     net_cp_jlibical_ICalProperty
1532  * Method:    get_exrule
1533  * Signature: ()Lnet/cp/jlibical/ICalRecurrenceType;
1534  */
1535 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1exrule
1536   (JNIEnv *env, jobject jobj)
1537 {
1538         jobject result = 0;
1539         // get the ICalProperty c++ object from jobj
1540         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1541
1542         if (cObj != NULL)
1543         {
1544                 // get the exrule from CObj
1545                 icalrecurrencetype aExRule = cObj->get_exrule();
1546
1547                 // create a new surrogate, using aExRule as the subject.
1548                 result = createNewICalRecurrenceType(env,&aExRule);
1549         }
1550
1551         return(result);
1552 }
1553
1554 /*
1555  * Class:     net_cp_jlibical_ICalProperty
1556  * Method:    set_freebusy
1557  * Signature: (Lnet/cp/jlibical/ICalPeriodType;)V
1558  */
1559 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1freebusy
1560   (JNIEnv *env, jobject jobj, jobject period)
1561 {
1562         // get the ICalProperty c++ object from jobj
1563         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1564
1565         if (cObj != NULL)
1566         {
1567                 icalperiodtype aPeriod;
1568
1569                 if (copyObjToicalperiodtype(env,period,&aPeriod))
1570                 {
1571                         cObj->set_freebusy(aPeriod);
1572                 }
1573         }
1574 }
1575
1576 /*
1577  * Class:     net_cp_jlibical_ICalProperty
1578  * Method:    get_freebusy
1579  * Signature: ()Lnet/cp/jlibical/ICalPeriodType;
1580  */
1581 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1freebusy
1582   (JNIEnv *env, jobject jobj)
1583 {
1584         jobject result = 0;
1585         // get the ICalProperty c++ object from jobj
1586         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1587
1588         if (cObj != NULL)
1589         {
1590                 // get the period from CObj
1591                 icalperiodtype aPeriod = cObj->get_freebusy();
1592
1593                 // create a new surrogate, using aPeriod as the subject.
1594                 result = createNewICalPeriodType(env,&aPeriod);
1595         }
1596
1597         return(result);
1598 }
1599
1600 /*
1601  * Class:     net_cp_jlibical_ICalProperty
1602  * Method:    set_recurrenceid
1603  * Signature: (Lnet/cp/jlibical/ICalTimeType;)V
1604  */
1605 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1recurrenceid
1606   (JNIEnv *env, jobject jobj, jobject recurrenceid)
1607 {
1608         // get the ICalProperty c++ object from jobj
1609         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1610
1611         if (cObj != NULL)
1612         {
1613                 icaltimetype aRecurrenceId;
1614
1615                 if (copyObjToicaltimetype(env,recurrenceid,&aRecurrenceId))
1616                 {
1617                         cObj->set_recurrenceid(aRecurrenceId);
1618                 }
1619         }
1620 }
1621
1622 /*
1623  * Class:     net_cp_jlibical_ICalProperty
1624  * Method:    get_recurrenceid
1625  * Signature: ()Lnet/cp/jlibical/ICalTimeType;
1626  */
1627 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1recurrenceid
1628   (JNIEnv *env, jobject jobj)
1629 {
1630         jobject result = 0;
1631         // get the ICalProperty c++ object from jobj
1632         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1633
1634         if (cObj != NULL)
1635         {
1636                 // get the exdate from CObj
1637                 icaltimetype aRecurrenceId = cObj->get_recurrenceid();
1638
1639                 // create a new surrogate, using aRecurrenceId as the subject.
1640                 result = createNewICalTimeType(env,&aRecurrenceId);
1641         }
1642
1643         return(result);
1644 }
1645
1646 /*
1647  * Class:     net_cp_jlibical_ICalProperty
1648  * Method:    set_rrule
1649  * Signature: (Lnet/cp/jlibical/ICalRecurrenceType;)V
1650  */
1651 JNIEXPORT void JNICALL Java_net_cp_jlibical_ICalProperty_set_1rrule
1652   (JNIEnv *env, jobject jobj, jobject rrule)
1653 {
1654         // get the ICalProperty c++ object from jobj
1655         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1656
1657         if (cObj != NULL)
1658         {
1659                 icalrecurrencetype aRRule;
1660
1661                 if (copyObjToicalrecurrencetype(env,rrule,&aRRule))
1662                 {
1663                         cObj->set_rrule(aRRule);
1664                 }
1665         }
1666 }
1667
1668 /*
1669  * Class:     net_cp_jlibical_ICalProperty
1670  * Method:    get_rrule
1671  * Signature: ()Lnet/cp/jlibical/ICalRecurrenceType;
1672  */
1673 JNIEXPORT jobject JNICALL Java_net_cp_jlibical_ICalProperty_get_1rrule
1674   (JNIEnv *env, jobject jobj)
1675 {
1676         jobject result = 0;
1677         // get the ICalProperty c++ object from jobj
1678         ICalProperty* cObj = getSubjectAsICalProperty(env,jobj,JLIBICAL_ERR_CLIENT_INTERNAL);
1679
1680         if (cObj != NULL)
1681         {
1682                 // get the rrule from CObj
1683                 icalrecurrencetype aRRule = cObj->get_rrule();
1684
1685                 // create a new surrogate, using aExRule as the subject.
1686                 result = createNewICalRecurrenceType(env,&aRRule);
1687         }
1688
1689         return(result);
1690 }