예제 #1
0
void rot_bitmap_layer_update_func (Layer* l,GContext* ctx) {
    ROT_BITMAP_GET;
    GPoint topOffset=getTopOffset ();
    setTopOffset(GPoint(0,0));
    GRect rect=GRect(0,0,l->frame.size.w,l->frame.size.h);

    SDL_Surface* sur=createSurface(rotbitmap->bitmap->bounds.size.w,rotbitmap->bitmap->bounds.size.h);
    SDL_FillRect(sur,0,0);
    graphics_context_set_compositing_mode (ctx,GCompOpAssign);
    graphics_draw_bitmap_in_rect_to (ctx,rotbitmap->bitmap,rect,sur);
    double angle=(double)rotbitmap->rotation/TRIG_MAX_ANGLE*360.0;
    SDL_Surface* rotated=rotozoomSurface(sur,-angle,1.0,SMOOTHING_OFF);
    SDL_FreeSurface(sur);
    GPoint offset=getPivotRotationOffset(rotbitmap->bitmap->bounds.size,GSize(rotated->w,rotated->h),rotbitmap->src_ic,angle);

    rotbitmap->dest_ic.x=l->frame.size.w/2; //TODO: Verify this
    rotbitmap->dest_ic.y=l->frame.size.h/2;

    setTopOffset(topOffset);
    if (rotbitmap->corner_clip_color!=GColorClear) {
        graphics_context_set_fill_color(ctx,rotbitmap->corner_clip_color);
        graphics_fill_rect(ctx,GRect(0,0,l->frame.size.w,l->frame.size.h),0,0);
    }
    graphics_context_set_compositing_mode (ctx,rotbitmap->compositing_mode);
    graphics_draw_surface_in_rect (ctx,rotated,GRect(rotbitmap->dest_ic.x-offset.x,rotbitmap->dest_ic.y-offset.y,rotated->w,rotated->h));
    SDL_FreeSurface(rotated);
}
예제 #2
0
void graphics_fill_rect(GContext *ctx, GRect rect, uint8_t corner_radius, GCornerMask corner_mask) {
    //TODO: corner_mask
    GPoint topOffset=getTopOffset ();
    if (corner_radius>0)
        roundedBoxColor (getTopScreen(),topOffset.x+rect.origin.x,topOffset.y+rect.origin.y,topOffset.x+rect.origin.x+rect.size.w,topOffset.y+rect.origin.y+rect.size.h,corner_radius,getRawColor(ctx->fill_color));
    else
        boxColor (getTopScreen(),topOffset.x+rect.origin.x,topOffset.y+rect.origin.y,topOffset.x+rect.origin.x+rect.size.w,topOffset.y+rect.origin.y+rect.size.h,getRawColor(ctx->fill_color));
}
예제 #3
0
void graphics_draw_something_in_rect_to(GContext *ctx, void* what,graphics_draw_something_callback callback, GRect rect,SDL_Surface* screen) {
    // TODO: verify composite mode implementations
    // TODO: bitmap->info_flags?
    GCompOp compositing_mode = ctx->compositing_mode;
    GPoint topOffset=getTopOffset ();
    SDL_Rect clipRect;
    SDL_GetClipRect(screen,&clipRect);
    LOCK(screen);
    int16_t x,y;
    callback (what,-1,0);
    for(x=0; x < rect.size.w; x++) {
        int16_t dst_x = x + rect.origin.x+topOffset.x;
        if(dst_x < clipRect.x) continue;
        else if(dst_x >= clipRect.x+clipRect.w) break;


        for(y=0; y < rect.size.h; y++) {
            int16_t dst_y = y + rect.origin.y+topOffset.y;
            if(dst_y < clipRect.y) continue;
            else if(dst_y >= clipRect.y+clipRect.h) break;

            uint32_t src_c = callback(what,x,y);
            uint32_t *dst_c = (uint32_t *)(((uint8_t*)screen->pixels) + screen->pitch * dst_y + 4 * dst_x);

            switch(compositing_mode) {
            case GCompOpAssign:
                *dst_c = src_c;
                break;
            case GCompOpAssignInverted:
                *dst_c = ~(src_c) | 0x000000ff;
                break;
            case GCompOpOr:
                if (src_c == r_white)
                    *dst_c = r_white;
                break;
            case GCompOpAnd:
                if (src_c == r_black)
                    *dst_c = r_black;
                break;
            case GCompOpClear:
                if (src_c == r_white)
                    *dst_c = r_black;
                break;
            case GCompOpSet:
                if (src_c == r_black)
                    *dst_c = r_white;
                break;
            }
        }
    }
    callback(what,0,-1);
    UNLOCK(screen);
}
예제 #4
0
void scroll_layer_shadow_layer_update_func (Layer* me,GContext* ctx) {
    ScrollLayer* scroll_layer=(ScrollLayer*)me->parent;
    SDL_Surface* scroll_shadow=getSimulatorImage(SIM_IMG_SCROLL_SHADOW);
    GPoint topOffset=getTopOffset();
    SDL_Surface* screen=getTopScreen ();
    GPoint offset=scroll_layer_get_content_offset (scroll_layer);
    GSize size=scroll_layer_get_content_size (scroll_layer);
    GSize frameSize=me->frame.size;
    SDL_Rect src,dst;
    if (offset.y<0) {
        src=(SDL_Rect){0,15,144,15};
        dst=(SDL_Rect){topOffset.x,topOffset.y,144,15};
        SDL_gfxBlitRGBA(scroll_shadow,&src,screen,&dst);
    }
    if (offset.y-((Layer*)scroll_layer)->frame.size.h!=-size.h) {
        src=(SDL_Rect){0,0,144,15};
        dst=(SDL_Rect){topOffset.x,topOffset.y+frameSize.h-15,144,15};
        SDL_gfxBlitRGBA(scroll_shadow,&src,screen,&dst);
    }
}
예제 #5
0
void rotbmp_layer_update_func (Layer* me,GContext* ctx) {
    GPoint topOffset=getTopOffset ();
    setTopOffset(GPoint(0,0));
    GRect rect=GRect(0,0,me->frame.size.w,me->frame.size.h);
    RotBitmapLayer* bitmapLayer=(RotBitmapLayer*)me;

    SDL_Surface* bitmap=createSurface(bitmapLayer->bitmap->bounds.size.w,bitmapLayer->bitmap->bounds.size.h);
    SDL_FillRect(bitmap,0,0);
    graphics_context_set_compositing_mode (ctx,GCompOpAssign);
    graphics_draw_bitmap_in_rect_to (ctx,bitmapLayer->bitmap,rect,bitmap);
    double angle=(double)bitmapLayer->rotation/TRIG_MAX_ANGLE*360.0;
    SDL_Surface* rotated=rotozoomSurface(bitmap,-angle,1.0,SMOOTHING_OFF);
    SDL_FreeSurface(bitmap);
    GPoint offset=getPivotRotationOffset(bitmapLayer->bitmap->bounds.size,GSize(rotated->w,rotated->h),bitmapLayer->src_ic,angle);

    setTopOffset(topOffset);
    graphics_context_set_compositing_mode (ctx,bitmapLayer->compositing_mode);
    graphics_draw_surface_in_rect (ctx,rotated,GRect(bitmapLayer->dest_ic.x-offset.x,bitmapLayer->dest_ic.y-offset.y,rotated->w,rotated->h));
    SDL_FreeSurface(rotated);
}
예제 #6
0
void _gpath_to_sdl(GPath *path,Sint16** pointsX,Sint16** pointsY) {
    GPoint topOffset=getTopOffset ();
    *pointsX=(Sint16*)malloc(sizeof(Sint16)*path->num_points);
    *pointsY=(Sint16*)malloc(sizeof(Sint16)*path->num_points);

    double s = sin(((double)path->rotation/TRIG_MAX_ANGLE) * 2*PI );
    double c = cos(((double)path->rotation/TRIG_MAX_ANGLE) * 2*PI);
    int p;
    for(p=0; p<path->num_points; p++) {
        double x, y, nx;
        x = path->points[p].x+0.5;
        y = path->points[p].y+0.5;
        nx = x * c - y * s;
        y = x * s + y * c;
        x = nx;
        x += path->offset.x;
        y += path->offset.y;

        (*pointsX)[p] = (Sint16)(x+topOffset.x);
        (*pointsY)[p] = (Sint16)(y+topOffset.y);
    }
}
예제 #7
0
long PANEElement::getBottomOffset(){
	return getTopOffset() + getActualHeight( getAvailableWidth() );
}
예제 #8
0
void graphics_draw_round_rect(GContext *ctx, GRect rect, int radius) {
    GPoint topOffset=getTopOffset ();
    roundedRectangleColor(getTopScreen(),topOffset.x+rect.origin.x,topOffset.y+rect.origin.y,topOffset.x+rect.origin.x+rect.size.w,topOffset.y+rect.origin.y+rect.size.h,radius,getRawColor(ctx->stroke_color));
}
예제 #9
0
void graphics_fill_circle(GContext *ctx, GPoint p, int radius) {
    GPoint topOffset=getTopOffset ();
    filledCircleColor(getTopScreen(), topOffset.x+p.x, topOffset.y+p.y, radius, getRawColor(ctx->fill_color));
}
예제 #10
0
void graphics_draw_circle(GContext *ctx, GPoint p, int radius) {
    GPoint topOffset=getTopOffset ();
    circleColor(getTopScreen(), topOffset.x+p.x, topOffset.y+p.y, radius, getRawColor(ctx->stroke_color));
}
예제 #11
0
void graphics_draw_line(GContext *ctx, GPoint p0, GPoint p1) {
    GPoint topOffset=getTopOffset ();
    lineColor(getTopScreen(), topOffset.x+p0.x, topOffset.y+p0.y, topOffset.x+p1.x, topOffset.y+p1.y, getRawColor(ctx->stroke_color));
}
예제 #12
0
void graphics_draw_pixel(GContext *ctx, GPoint point) {
    GPoint topOffset=getTopOffset ();
    pixelColor(getTopScreen(), topOffset.x+point.x, topOffset.y+point.y, getRawColor(ctx->stroke_color));
}
예제 #13
0
//#verify #verify #verify !!!!!!!!!!
void graphics_text_draw(GContext *ctx, const char *text, const GFont font, const GRect box, const GTextOverflowMode overflow_mode, const GTextAlignment alignment, const GTextLayoutCacheRef layout) {
    char buffer [256]; //SHIT!! I need to mark the end of the string but I can't use the original parameter...
    TextWrapper textWrapper=(overflow_mode==GTextOverflowModeWordWrap?wrap_words:wrap_points);
    int lineHeight=0,usedHeight=0;
    SDL_Surface* lineSurface,*lineSurfaceTemp;
    SDL_Surface* textSurface=SDL_CreateRGBSurface (SDL_SWSURFACE|SDL_SRCALPHA,box.size.w,box.size.h,32,0xff000000,0x00ff0000,0x0000ff00,0x000000ff);
    SDL_FillRect (textSurface,0,0);
    SDL_Surface* pointsSurface=0; //this will only be initalised when it's needed
    SDL_Rect dstRect,srcRect;
    SDL_Color color=getColor(ctx->text_color);
    GPoint topOffset=getTopOffset ();
    _WrapResult wrap;
    if (text==0)
        return;
    while (*text!=0&&usedHeight<box.size.h) {
        wrap=textWrapper (text,box.size.w,font);
        memcpy(buffer,text,wrap.lineLen);
        buffer[wrap.lineLen]=0;
        text=wrap.newString;
        if (wrap.lineLen==0) {
            usedHeight+=lineHeight;
            continue;
        }
        lineSurfaceTemp=TTF_RenderText_Solid ((TTF_Font*)font,buffer,color);
        if (lineSurfaceTemp==0) {
            printf("[WARN] TTF_RenderText_Solid: %s\n",TTF_GetError ());
            return;
        }
        lineSurface=SDL_ConvertSurface(lineSurfaceTemp,textSurface->format,SDL_SWSURFACE|SDL_SRCALPHA);
        SDL_FreeSurface(lineSurfaceTemp);
        if (lineHeight==0)
            lineHeight=lineSurface->h;
        //prepare blitting
        srcRect=((SDL_Rect) {
            0,0,lineSurface->w,lineSurface->h
        });
        if (srcRect.h+usedHeight>box.size.h)
            srcRect.h=box.size.h-usedHeight;
        dstRect=srcRect;
        dstRect.y=usedHeight;
        //set text alignment
        if (alignment==GTextAlignmentCenter)
            dstRect.x=box.size.w/2-(dstRect.w+wrap.addPoints)/2;
        else if (alignment==GTextAlignmentRight)
            dstRect.x=box.size.w-(dstRect.w+wrap.addPoints);
        //else
        //  srcRect.x=0;
        //blit line to text
        SDL_gfxBlitRGBA(lineSurface,&srcRect,textSurface,&dstRect);
        SDL_FreeSurface(lineSurface);
        if (wrap.addPoints>0) {
            if (pointsSurface==0) {
                pointsSurface=TTF_RenderText_Solid ((TTF_Font*)font,"...",color);
                if (pointsSurface==0) {
                    printf("[WARN] TTF_RenderText_Solid: %s\n",TTF_GetError ());
                    return;
                }
            }
            srcRect.x=0;
            srcRect.w=pointsSurface->w;
            dstRect.x+=dstRect.w;
            dstRect.w=pointsSurface->w;
            SDL_BlitSurface(pointsSurface,&srcRect,textSurface,&dstRect);
        }
        usedHeight+=lineHeight;
    }
    srcRect=((SDL_Rect) {
        0,0,box.size.w,box.size.h
    });
    dstRect=((SDL_Rect) {
        box.origin.x+topOffset.x,box.origin.y+topOffset.y,box.size.w,box.size.h
    });
    SDL_gfxBlitRGBA(textSurface,&srcRect,getTopScreen(),&dstRect);
    SDL_FreeSurface(textSurface);
    if (pointsSurface!=0)
        SDL_FreeSurface(pointsSurface);
}