void FractalGenerator::handleState()
{
    if ( m_activeJobs > 0 || !m_enabled || m_pendingResolution.isEmpty() )
        return;

    if ( !m_regions.isEmpty() && !m_pending ) {
        addJobs();
        return;
    }

    if ( m_preview && m_buffer && m_regions.isEmpty() && m_resolution == m_pendingResolution ) {
        delete[] m_previewBuffer;
        m_previewBuffer = m_buffer;
        m_buffer = NULL;

        postUpdate( FullUpdate );
    }

    if ( m_pending ) {
        if ( m_buffer && m_bufferSize != m_pendingBufferSize ) {
            delete[] m_buffer;
            m_buffer = NULL;
        }

        m_type = m_pendingType;
        m_position = m_pendingPosition;
        m_settings = m_pendingSettings;
        m_resolution = m_pendingResolution;
        m_bufferSize = m_pendingBufferSize;
        m_pending = false;

        if ( !m_buffer )
            m_buffer = new double[ m_bufferSize.width() * m_bufferSize.height() ];

        createFunctor();

        if ( !m_preview )
            postUpdate( InitialUpdate );

        m_validRegions.clear();

        splitRegions();
        addJobs();
    }
}
void *vlad_malloc(u_int32_t n)
{
	//printf("\n|||Startig Vlad Malloc|||\n\n");

    if (n < (2<<3)) {
        //printf("Must malloc a region bigger than 2^3\n\n");
        return NULL;
    }

    u_int32_t totalSize = n + HEADER_SIZE;

    int i;
    for (i = 0; totalSize > 2<<i; i++);

    totalSize = 2<<i;

    /*printf("Mallocing %d bytes of memory || %lu of HEADER || %d of memory\n"
           , totalSize, HEADER_SIZE, n);*/
	
	vlink_t currFreeLink = free_list_ptr;
	free_header_t * currFreeHead = (free_header_t *) &memory[currFreeLink];

    //printf("Free List ptr: %d\n\n", free_list_ptr);
	
	//one region
	if (currFreeLink == currFreeHead->next) {
		//region is too small
		if (currFreeHead->size < totalSize+HEADER_SIZE) {
			//printf("Only one region and it's too small\n\n");
			return NULL;
        } 
    }

    //general case
    //first header with enough memory
    while (currFreeHead->size < totalSize) {
        //printf("finding sufficient region\n");
        currFreeHead = (free_header_t *) &memory[currFreeHead->next];
    }

        if (currFreeHead->size >= totalSize) {
            //printf("Region (%d) has sufficient memory\n\n", currFreeLink);
            //change magic value

            splitRegions(currFreeLink, totalSize);
            
            if (currFreeLink == currFreeHead->next) {
                //printf("There is not enough space for a second header\n");

                //testFreeList();
                return NULL;
            }

            currFreeHead->magic = MAGIC_ALLOC;

            removeCurrFromFree(currFreeLink);

            //fix free_list_ptr
            free_list_ptr = currFreeHead->next;

            /*printf("Successfully malloced memory\n\n"
           "-------------------------------\n\n");*/

            //testFreeList();

            return &memory[currFreeLink+HEADER_SIZE];
        }

    //printf("xxxxxxxxxSomthing Went Wrongxxxxxxxx\n");

    return NULL;
}