I haven't actually written any code, but the idea is in my head and I though I'd share to get some general feedback. What I want to do is make function like the following:

void draw_border(BITMAP *bImage, BITMAP *bBorder);

This function will draw the bBorder image around the bImage. For example, if this were bBorder:

http://comp.uark.edu/~spsilve/border.JPG

And this were bImage:

http://comp.uark.edu/~spsilve/image.JPG

Then this should be the final output:

http://comp.uark.edu/~spsilve/final.JPG

The purpose of draw_border is to draw a border on what's actually seen. The image above is just a big square, so no problem there. If I were to have a circle, however, that would be a different situation. The border should follow the edges of the circle or polygon or whatever shape it is. Following the edges isn't really that difficult of a question, but what I've been wondering about is the corners. Notice above the border image turns with the picture. I've thought of a few different methods that might work, but I'm curious as to what you think.

My favorite method so far consists of stripping the border image and drawing pieces of it at a time. Like taking the top one-pixel line of the image and drawing that around the entire space and then go to the next part of the border. Since this is going to be a one-time process in the actual program, it's okay if it takes a little time.

Also note that above I used a very simple border. I could use something like a smile face and get some weird results.

Thought it'd be a nice thing for my gui. If it's too complicated, I'll probably just throw it out.

That could be simplified by adding the restriction of a one-pixel-width border image, so there'd be no "real" pattern to keep.

I guess a generalized approach would be:
1) Vectorize the shape into a polygon.
2) For each edge, create a parallel line.
3) Find the intersection points of two adjacent parallels.
4) You have now vectorized the outline; render it as quads, with appropriate texture coords (s as running variable, increment by edge length per vertex; t as 0 on the original outline and as 1 on the shifted one).

The math involved in step 3 can be a bit tricky though, and you cannot use arbitrary shapes with arbitrary borders.

Yeah, I was thinking I might have to do that due to my limited knowledge. For simple borders above, that'd work fine, since the border is too complex. It would be nice to have different patterns though. Of course, most borders don't have patterns...

The corners and curves are giving me some complications. I haven't tried to code anything yet, so I don't know how difficult it will be.

This sounds most like what I had in my head, especially number 2. However, you kind of lost me on number 4, I'll have to take a closer look.

Nothing wrong with simple. Even if I limit the borders to be pattern-less and only 1-pixel-width wide, you'd still be able to create a multitude of borders for simple, rectangular shapes. Thanks.

I'll made this two days ago, but didn't have change to post it till now:

First custom blender is set which for each pixel drawn with draw_trans/lit_sprite returns global_color. Then for each border, image is stretched into temporary and drawn into destination. This is when custom blender kicks in and draws entire image as solid color. This is repeated for every border except image is stretched less and less. Finally original image is drawn.

It has two problems: It looks ugly and borders are drawn tiner as lines get more angled (see attached image, red primitive is default image).

src is bitmap which should be bordered (not modified)
dest is bitmap on which src + borders are drawn
b_w is single border width
b_c is number of borders (count)
colors is simple a array of ints created my makecol*() (number of colors == b_c)

Working is quite simple: When draw_trans_sprite/draw_lit_sprite are used they call special blender functions for each pixel they are about to draw (see Truecolor transparency). When my blenders are use they simple return current border color for every pixel.
When drawing border I stretch source bitmap into temporary so it has size as current border and then I draw it with draw_trans_sprite which draws that stretched sprite in one color (blenders). I repeat this for all borders.