/*
 * Class:     mapnik_FeatureSet
 * Method:    dealloc
 * Signature: (JJ)V
 */
JNIEXPORT void JNICALL Java_mapnik_FeatureSet_dealloc
  (JNIEnv *env, jobject, jlong fsptr, jlong fptr)
{
	if (fsptr)
		delete static_cast<mapnik::featureset_ptr*>(TO_POINTER(fsptr));
	if (fptr)
		delete static_cast<mapnik::feature_ptr*>(TO_POINTER(fptr));
}
Exemple #2
0
/*
 * Class:     mapnik_Layer
 * Method:    dealloc
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_mapnik_Layer_dealloc
  (JNIEnv *env, jclass c, jlong ptr)
{
	if (ptr) {
		delete static_cast<mapnik::layer*>(TO_POINTER(ptr));
	}
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_cylinder
(JNIEnv *env, jobject obj, jlong quadric,
 jdouble baseRadius, jdouble topRadius, jdouble height,
 jint slices, jint stacks)
{
    gluCylinder(TO_POINTER(quadric), baseRadius, topRadius, height, slices, stacks);
}
Exemple #4
0
/*
 * Class:     mapnik_Image
 * Method:    dealloc
 * Signature: (J)J
 */
JNIEXPORT void JNICALL Java_mapnik_Image_dealloc
  (JNIEnv * env, jclass c, jlong ptr)
{
	mapnik::image_32* im=static_cast<mapnik::image_32*>(TO_POINTER(ptr));
	if (im) {
		delete im;
	}
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_partialDisk
(JNIEnv *env, jobject obj, jlong quadric,
 jdouble innerRadius, jdouble outerRadius,
 jint slices, jint loops, jdouble startAngle, jdouble sweepAngle)
{
    gluPartialDisk(TO_POINTER(quadric), innerRadius, outerRadius, slices, loops,
                   startAngle, sweepAngle);
}
/*
 * Class:     mapnik_FeatureTypeStyle
 * Method:    dealloc
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_mapnik_FeatureTypeStyle_dealloc
  (JNIEnv *env, jobject, jlong ptr)
{
	PREAMBLE;
	mapnik::feature_type_style* style=static_cast<mapnik::feature_type_style*>(TO_POINTER(ptr));
	delete style;
	TRAILER_VOID;
}
Exemple #7
0
/*
 * Class:     mapnik_MapDefinition
 * Method:    dealloc
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_mapnik_MapDefinition_dealloc
  (JNIEnv *env, jobject, jlong ptr)
{
	PREAMBLE;
	if (ptr) {
		delete static_cast<mapnik::Map*>(TO_POINTER(ptr));
	}
	TRAILER_VOID;
}
Exemple #8
0
/*
 * Class:     mapnik_MapDefinition
 * Method:    copy
 * Signature: (J)J
 */
JNIEXPORT jlong JNICALL Java_mapnik_MapDefinition_copy
  (JNIEnv *env, jclass c, jlong otherPtr)
{
	if (!otherPtr) return 0;
	PREAMBLE;

	mapnik::Map* other=static_cast<mapnik::Map*>(TO_POINTER(otherPtr));
	mapnik::Map* m=new mapnik::Map(*other);

	return FROM_POINTER(m);
	TRAILER(0);
}
Exemple #9
0
/*
 * Class:     mapnik_MapDefinition
 * Method:    addLayer
 * Signature: (Lmapnik/Layer;)V
 */
JNIEXPORT void JNICALL Java_mapnik_MapDefinition_addLayer
  (JNIEnv *env, jobject mapobject, jobject layerobject)
{
	if (!layerobject) return;

	PREAMBLE;
	mapnik::Map* map=LOAD_MAP_POINTER(mapobject);
	mapnik::layer* layer=
			static_cast<mapnik::layer*>(TO_POINTER(env->GetLongField(layerobject, FIELD_PTR)));

	map->addLayer(*layer);
	TRAILER_VOID;
}
Exemple #10
0
/*
 * Class:     mapnik_MapDefinition
 * Method:    addStyle
 * Signature: (Ljava/lang/String;Lmapnik/FeatureTypeStyle;)V
 */
JNIEXPORT void JNICALL Java_mapnik_MapDefinition_addStyle
  (JNIEnv *env, jobject mapobject, jstring namej, jobject styleobject)
{
	PREAMBLE;
	if (!styleobject) return;

	mapnik::Map* map=LOAD_MAP_POINTER(mapobject);
	refjavastring name(env, namej);
	mapnik::feature_type_style* style=static_cast<mapnik::feature_type_style*>(
			TO_POINTER(env->GetLongField(styleobject, FIELD_PTR))
			);
	map->insert_style(name.stringz, *style);
	TRAILER_VOID;
}
Exemple #11
0
/*
 * Class:     mapnik_Layer
 * Method:    setDatasource
 * Signature: (Lmapnik/Datasource;)V
 */
JNIEXPORT void JNICALL Java_mapnik_Layer_setDatasource
  (JNIEnv *env, jobject layerobj, jobject dsobject)
{
	mapnik::layer* layer=LOAD_LAYER_POINTER(layerobj);

	if (!dsobject) {
		layer->set_datasource(mapnik::datasource_ptr());
		return;
	}

	mapnik::datasource_ptr* dspinned=
			static_cast<mapnik::datasource_ptr*>(
					TO_POINTER(env->GetLongField(dsobject, CLASS_DATASOURCE.ptr_field)));
	layer->set_datasource(*dspinned);
}
Exemple #12
0
/*
 * Class:     mapnik_MapDefinition
 * Method:    setLayer
 * Signature: (ILmapnik/Layer;)V
 */
JNIEXPORT void JNICALL Java_mapnik_MapDefinition_setLayer
  (JNIEnv *env, jobject mapobject, jint index, jobject layerobject)
{
	PREAMBLE;
	mapnik::Map* map=LOAD_MAP_POINTER(mapobject);
	std::vector<mapnik::layer> &layers(map->layers());
	if (index<0 || ((unsigned)index)>layers.size()) {
		return;
	}

	if (!layerobject) return;
	mapnik::layer* layer=
			static_cast<mapnik::layer*>(TO_POINTER(env->GetLongField(layerobject, FIELD_PTR)));
	layers[index]=*layer;
	TRAILER_VOID;
}
Exemple #13
0
/*
 * Class:     mapnik_Layer
 * Method:    setDatasource
 * Signature: (Lmapnik/Datasource;)V
 */
JNIEXPORT void JNICALL Java_mapnik_Layer_setDatasource
  (JNIEnv *env, jobject layerobj, jobject dsobject)
{
	PREAMBLE;
	mapnik::layer* layer=LOAD_LAYER_POINTER(layerobj);

	if (!dsobject) {
		layer->set_datasource(mapnik::datasource_ptr());
		return;
	}

	mapnik::datasource_ptr* dspinned=
			static_cast<mapnik::datasource_ptr*>(
					TO_POINTER(env->GetLongField(dsobject, FIELD_PTR)));
	layer->set_datasource(*dspinned);
	TRAILER_VOID;
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_sphere
(JNIEnv *env, jobject obj, jlong quadric, jdouble radius,
 jint slices, jint stacks)
{
    gluSphere(TO_POINTER(quadric), radius, slices, stacks);
}
Exemple #15
0
void c_port_write(char *buffer, Word size)
{
    /* ************************************************************** *
     *  No local variables...                                         *
     * ************************************************************** */


    /* ************************************************************** *
     *  Now lets see if it looks like we are allowed to be printing...*
     *  Check for the following:                                      *
     *    1) We are at level 1 for spool files...                     *
     *    2) We have an open spool file                               *
     *    3) No errors have occured (yet)                             *
     * ************************************************************** */

    if ((open_count != 1) ||
        (data_file_ptr == (KS_FILE_PTR) NULL) ||
        (port_status != PORT_SPOOLING))
        {
        return;
        };


    /* ************************************************************** *
     *  Looks good... write this data to the buffered output file.    *
     *  Remember to check for an error...                             *
     * ************************************************************** */

    KS_FILE_WRITE(data_file_ptr,
                  KS_NEXT_FILE_POSITION,
                  (LongWord) size,
                  TO_POINTER(buffer),
                  error);
    if (error != KS_E_SUCCESS)
        {
        error_message = CANT_WRITE_DATA;
        goto ERROR_CANT_WRITE_DATA;
        };


    /* ************************************************************** *
     *  Everything is all done here - return to our caller...         *
     * ************************************************************** */

    return;


    /* ************************************************************** *
     *  Error processing for all of the error cases of the above code *
     *                                                                *
     *  Something bad happened... that means we have to give up       *
     *  on printing and give our user an error dialog that tells      *
     *  them what happened.                                           *
     * ************************************************************** */

ERROR_CANT_WRITE_DATA:

    /* ************************************************************** *
     *  First we close the spool file (can't use it anymore now...)   *
     *  then give our user some feed back (like an error message).    *
     * ************************************************************** */

    KS_FILE_CLOSE(data_file_ptr, error2);

    data_file_ptr = (KS_FILE_PTR) NULL;
    open_count--;
    port_status = PORT_ERROR;

    ERROR_DIALOG(error_message, error, button);

    return;
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_quadricTexture
(JNIEnv *env, jobject obj, jlong quadric, jboolean texture)
{
    gluQuadricTexture(TO_POINTER(quadric), texture);
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_quadricNormals
(JNIEnv *env, jobject obj, jlong quadric, jint normals)
{
    gluQuadricNormals(TO_POINTER(quadric), normals);
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_quadricOrientation
(JNIEnv *env, jobject obj, jlong quadric, jint orientation)
{
    gluQuadricOrientation(TO_POINTER(quadric), orientation);
}
/* Set the drawing style for the quadric. */
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_quadricDrawStyle
(JNIEnv *env, jobject obj, jlong quadric, jint drawStyle)
{
    gluQuadricDrawStyle(TO_POINTER(quadric), drawStyle);
}
/* Deletes a quadric. */
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_deleteQuadric
(JNIEnv *env, jobject obj, jlong quadric)
{
    gluDeleteQuadric((GLUquadric*)(TO_POINTER(quadric)));
}
JNIEXPORT void JNICALL Java_OpenGL_GLUQuadric_disk
(JNIEnv *env, jobject obj, jlong quadric, jdouble innerRadius,
 jdouble outerRadius, jint slices, jint loops)
{
    gluDisk(TO_POINTER(quadric), innerRadius, outerRadius, slices, loops);
}
Exemple #22
0
KS_E_ERROR ks_file_write(KS_FILE_PTR file_ptr,
                         LongWord position,
                         LongWord data_size,
                         Pointer data_buffer)
{
    /* ************************************************************** *
     *  Local declarations:                                           *
     * ************************************************************** */

    KS_E_ERROR   error;            /* Holds error codes for subroutine*/
                                   /*  calls                          */
    LongWord     data_offset;      /* Offset into the buffer to return*/
    LongWord     remaining_space;  /* Space remaining in file buffer  */
    LongWord     buffer_request;   /* Size of each copy from the      */
                                   /*  file buffer                    */


    ROUTINE_ENTER();


    /* ************************************************************** *
     *  Verify the structure ID passed in is the correct one.         *
     * ************************************************************** */

    if (file_ptr->struct_id != KS_FILE_ID)
        {
        KS_ERROR(KS_E_INVALID_STRUCT_ID, KS_FILE_ID);
        };


    /* ************************************************************** *
     *  Zero the number of bytes transfered in the KS_FILE structure. *
     * ************************************************************** */

    file_ptr->data_size = 0;


    /* ************************************************************** *
     *  If there is a buffer, then lets put data into the file buffer.*
     * ************************************************************** */

    if (file_ptr->buffer_size != NULL)
        {

        /* ********************************************************** *
         *  Loop till we satisfy the request (or take an error)       *
         * ********************************************************** */

        data_offset = 0;

        while (data_size > 0)
            {

            /* ****************************************************** *
             *  Calculate the remaining space in the buffer.  If      *
             *  there is any space left in the buffer then lets copy  *
             *  as much as we need to into the file buffer.           *
             * ****************************************************** */

            remaining_space = (file_ptr->buffer_available) -
                              (file_ptr->buffer_offset);

            if (remaining_space > 0)
                {
                buffer_request = MIN(data_size,
                                     remaining_space);

                COPY_BYTES(data_buffer,
                           data_offset,
                           file_ptr->buffer,
                           file_ptr->buffer_offset,
                           buffer_request);

                /* ************************************************** *
                 *  Now modify the parameters of the buffers by:      *
                 *                                                    *
                 *  1) Adding the size of the request to the file     *
                 *  buffer ofset and the data offset (IE: Indices to  *
                 *  the file buffer and the read request buffer).     *
                 *                                                    *
                 *  2) Subtracting the request size from the read     *
                 *  request size and the remaining number of          *
                 *  characters in the file buffer.                    *
                 * ************************************************** */

                file_ptr->buffer_offset = file_ptr->buffer_offset +
                                          buffer_request;

                data_offset = data_offset + buffer_request;

                file_ptr->data_size = data_offset; 

                data_size = data_size - buffer_request;

                remaining_space = remaining_space - buffer_request;
                };


            /* ****************************************************** *
             *  If the file buffer is full, then we have to write it  *
             *  to disk.  The problem is that the buffer size may     *
             *  have changed due to what our user wants (users are    *
             *  bound to be the end of all computing...).  This means *
             *  that we'll junp through a few hoops if we must change *
             *  buffer sizes - so expect some weirdness here.         *
             * ****************************************************** */

            if (remaining_space == 0)
                {

                /* ************************************************** *
                 *  Issue a Read to the file into our buffer.         *
                 * ************************************************** */

                KSf_pkts.IO.pCount = 4;
                KSf_pkts.IO.refNum = file_ptr->refNum;
                KSf_pkts.IO.dataBuffer = TO_POINTER(file_ptr->buffer);
                KSf_pkts.IO.requestCount = file_ptr->buffer_size;

                WriteGS(&KSf_pkts.IO);

                if ((error = GET_ERROR()) != KS_E_SUCCESS)
                    {
                    goto EXIT_NOW;
                    };

                file_ptr->buffer_available = file_ptr->buffer_size;
                file_ptr->buffer_offset = 0;


                /* ************************************************** *
                 *  This is the above mentioned weirdness - if the    *
                 *  user specified a different size buffer we will    *
                 *  no comply with their wishes.                      *
                 * ************************************************** */

                if (file_ptr->buffer_size != KSf_FileBufferSize)
                    {
                    KS_MEMORY_DEALLOCATE(file_ptr->buffer_handle,
                                         error);

                    if (error != KS_E_SUCCESS)
                        {
                        goto EXIT_NOW;
                        };

                    KS_MEMORY_ALLOCATE(attrFixed + attrLocked,
                                       KSf_FileBufferSize,
                                       BUFFER_USERID,
                                       file_ptr->buffer_handle,
                                       error);

                    if (error != KS_E_SUCCESS)
                        {
                        goto EXIT_NOW;
                        };

                    file_ptr->buffer = (Byte *)
                                         *(file_ptr->buffer_handle);

                    file_ptr->buffer_size = KSf_FileBufferSize;

                    file_ptr->buffer_available = KSf_FileBufferSize;
                    };

                };  /* End if there is no remaining buffer space      */

            };  /* End while there are characters to be read...       */

        KS_SUCCESS();

        };  /* End if we are doing buffer I/O from the file           */




    /* ************************************************************** *
     *  Ok, we've done enough buffering... lets do some real output...*
     *                                                                *
     *  Position the 'mark' (where we will write to) in the file.     *
     *  Note: We'll move the mark only if our user asks us to.        *
     * ************************************************************** */

    if (position != KS_NEXT_FILE_POSITION)
        {
        KSf_pkts.position.pCount = 3;
        KSf_pkts.position.refNum = file_ptr->refNum;
        KSf_pkts.position.base = startPlus;
        KSf_pkts.position.displacement = position;

        SetMarkGS(&KSf_pkts.position);

        if ((error = GET_ERROR()) != KS_E_SUCCESS)
            {
            goto EXIT_NOW;
            };

        };  /* End if we must change the file position                */


    /* ************************************************************** *
     *  Setup the I/O packet and write what our user is asking for.   *
     * ************************************************************** */

    KSf_pkts.IO.pCount = 4;
    KSf_pkts.IO.refNum = file_ptr->refNum;
    KSf_pkts.IO.dataBuffer = data_buffer;
    KSf_pkts.IO.requestCount = data_size;

    WriteGS(&KSf_pkts.IO);

    if ((error = GET_ERROR()) != KS_E_SUCCESS)
        {
        goto EXIT_NOW;
        };


    /* ************************************************************** *
     *  Save the number of bytes transfered in the KS_FILE structure. *
     * ************************************************************** */

    file_ptr->data_size = KSf_pkts.IO.transferCount;


    /* ************************************************************** *
     *  Return the status back to our caller.                         *
     * ************************************************************** */

EXIT_NOW:

    if (error != KS_E_SUCCESS)
        {
        KS_ERROR(error, KS_FILE_ID);
        };

    KS_SUCCESS();

}   /* End of ks_file_write()                                         */
/*
 * Class:     mapnik_FeatureTypeStyle
 * Method:    dealloc
 * Signature: (J)V
 */
JNIEXPORT void JNICALL Java_mapnik_FeatureTypeStyle_dealloc
  (JNIEnv *env, jclass c, jlong ptr)
{
	mapnik::feature_type_style* style=static_cast<mapnik::feature_type_style*>(TO_POINTER(ptr));
	delete style;
}