Is there anything in the allegro libraries the allows text to be drawn within a specified box? I just spent three weeks developing my own class that uses strings to draw, but I would like to know if there was an easier way.:'(

But is there something like
textout_rect(BITMAP *, FONT *, const char *, int x, int y, int width, int height, color)?

That is what I am looking for.

You can achieve the same effect by adjusting the clipping rectangle of the bitmap or by using a subbitmap.
Depending on how you want to use it, one or the other might be more appropriate. If you're writing text to the same area of the bitmap regularly, a subbitmap will be better (create it once and reuse it). If it's just once, then adjusting the clipping rectangle is a little cleaner.

No, but it keeps the text from flowing out of the specified region.
Reading the original post (`allows text to be drawn within a specified box'), I assumed that was what he meant, but taking another look at the topic, I was probably wrong.

One way to do it, using only plain Allegro functions, is by using the d_text_proc function. This can be a bit messy and hackish, but it can be done.

In addition to the functions that Miran pointed out, you would need a function for finding the length of each character. Unfortunately, the only way you can do this in the Allegro public API is by converting each character into a string (copying it to a buffer that is followed by a terminating \0) and using text_length() on the string. However, the internal API has a char_length() method for the font, which will come in useful as we need to measure each character. To make use if it, add the line #include <allegro/internal/aintern.h> to the file where the multiline text-out code is stored.

It just so happens that I've written some code to do just that, so I thought I'd share it (see attatchment). The code can handle unicode characters (although this is currently untested).
[EDIT]The code can also handle newline characters, and prints the wrapped lines justified.[/EDIT]

Use the function aeGetNumTextLinesWithLengthLimit() to get the number of lines that the rendered text will take up, and aeTextoutMultiline() to actually render the text. The code is well commented (it even uses Doxygen-style comments so it can automatically generate docs if passed through Doxygen).

There are still a few things I could do to improve the code. Currently, the code uses a static buffer for the output of each line. This is determined by AEMULTILINEBUFSIZE (currently 512). Also, the code does not do tabs or hyphens, and the helper-function aeAdvanceToStartOfCurrentLineandGetNextLine() could be split into two separate functions.

Anyway, let me know if this is what you're after.

AE.

See edit to my previous post.

AE.

I guess your IDE has auto-complete...

Yeah I've done this before. You have to use an internal function that d_text_proc uses and hack it a bit and then you can kind of use it to do it. Its all very messy and hacky though, probably only a little bit harder and way cleaner to just write your own word wrapping method. I have one laying around somewhere, maybe I'll come back and paste it sometime if I can find the thing.

[edit]
Ok, heres some code i just ripped from a really really old project. You know what the variables are as well as I do...

Yeach.
That's what gui_set_screen() and gui_get_screen() were created for.

You'll proably want to be able to scroll the box up and down.

What I did to accomplish this was to create a class that understood simple markups.

The way it worked was you passed the class your modifiers:
Suggested max width, Suggested max height. Base Font. Color.

Then, you could pass it your display string, with markups, and it would return you a transparent BITMAP with your text.

I think that is your best solution. I coded for center, left, right, bold, underline, and italic markups.

For the bold/underline/italic markups, you will need to create a "Smart" Font library that can correctly upgrade your base font to the appropriate style based on the markups.

Good luck!

Mae

nMaxLength is the maximum length you are permitting your line to be (although this will be exceded if one line consists of only one character who'se width is greater than nMaxLength).

npMaxLineLength is a running count of the longest length we have so far. This is useful so we can find out the actual length of the longest line that will be printed. Often, this is shorter than nMaxLength, so we may want to shrink the horizontal size of the text-area to take this into account. aeGetNumTextLinesWithLengthLimit() and aeTextoutMultiline() both update the value pointed to by the npMaxLineLength paramater (although in practice, you will usually end up passing in NULL to aeTextoutMultiline()). Note that npMaxLineLength is optional, and you can pass in NULL if you don't want to print your text as compactly as possible.

Below is an example of the usage of the code.

note: this code is untested

The two strings will be printed. Both strings will have the same right-most border when they are justified. If the longest line-length is shorter than the maximum line-length, then the right-most border will be moved to the left to make the string more compact.

AE.

You can do that with aeTextoutMultiline(bitmapdest, text, font, x, y, fgcol, bgcol, width, NULL); The only reason why you need all the rest of the code in my example is if you want to find out how long the longest line is going to be and adjust the right-boundry accordingly. My code lacs the ability to set the alignment (the text always justified, except for the last line before each newline or \0 which are left-aligned).

AE.