void Button::draw(){
glPushMatrix();
glTranslatef(rect.x,rect.y,0);
glColor3f(0.25,0.25,0.25);
if(enabled){
if(mouseIsHovering)glColor3f(0.4,0.4,0.4);
if(mouseIsDown)glColor3f(1,0.8,0);
drawRoundedRect(GL_TRIANGLE_FAN,rect.width,rect.height,BUTTON_RECT_RADIUS);
if(mouseIsHovering){
if(mouseIsDown){
ofSetColor(255,255,220);
}else{
ofSetColor(0,0,0);
}
}else{
ofSetColor(150,150,150);
}
}
drawRoundedRect(GL_LINE_LOOP,rect.width,rect.height,BUTTON_RECT_RADIUS);
ofDrawBitmapString(text, ofPoint(margin/2,14));
glPopMatrix();
}
static void drawAndFillRoundedRect(double x, double y, double width,
double height, double r, string color) {
gwp->setColor(color);
fillRoundedRect(x, y,width, height, r);
gwp->setColor("Black");
drawRoundedRect(x, y, width, height, r);
}
void drawMetaDataText (CGContextRef myContext, CGRect contextRect, CFURLRef url)
{
float w, h;
w = contextRect.size.width;
h = contextRect.size.height;
//Lets pull some metadata!
struct metaData struct_metaData;
bzero(struct_metaData.Title, 1024);
bzero(struct_metaData.Header, 1024);
// bzero(struct_metaData.Expdata, 1024);
// bzero(struct_metaData.Resolution, 1024);
// bzero(struct_metaData.JrnlTitle, 1024);
// bzero(struct_metaData.JrnlRef, 1024);
// bzero(struct_metaData.Keywds, 4000);
// bzero(struct_metaData.JrnlAuthor, 4000);
exportMetaData(url, &struct_metaData);
int wraplength = 50;
int colLength = wraplength+5;
int rowLength = 10;
int textposX = 5;
int textposY = 10;
int calc_textposX = textposX;
int calc_textposY = textposY;
CGContextSetRGBFillColor (myContext, 1, 1, 1, 1);
CGContextSelectFont (myContext, "Helvetica", 20, kCGEncodingMacRoman);
CGContextSetCharacterSpacing (myContext, 1);
CGContextSetTextDrawingMode (myContext, kCGTextFill);
CGContextSetRGBFillColor(myContext, 0, 0, 0, 1);
if(struct_metaData.Title[0] != 0){
calcRectangle("Title: ", struct_metaData.Title, rowLength, colLength, wraplength, &calc_textposX, &calc_textposY);
drawRoundedRect(myContext, calc_textposX, calc_textposY);
}
DrawText("Title: ", struct_metaData.Title, myContext, rowLength, colLength, wraplength, &textposX, &textposY);
}
void imguiRenderGLDraw()
{
const imguiGfxCmd* q = imguiGetRenderQueue();
int nq = imguiGetRenderQueueSize();
const float s = 1.0f/8.0f;
glDisable(GL_SCISSOR_TEST);
for (int i = 0; i < nq; ++i)
{
const imguiGfxCmd& cmd = q[i];
if (cmd.type == IMGUI_GFXCMD_RECT)
{
if (cmd.rect.r == 0)
{
drawRect((float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f,
(float)cmd.rect.w*s-1, (float)cmd.rect.h*s-1,
1.0f, cmd.col);
}
else
{
drawRoundedRect((float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f,
(float)cmd.rect.w*s-1, (float)cmd.rect.h*s-1,
(float)cmd.rect.r*s, 1.0f, cmd.col);
}
}
else if (cmd.type == IMGUI_GFXCMD_LINE)
{
drawLine(cmd.line.x0*s, cmd.line.y0*s, cmd.line.x1*s, cmd.line.y1*s, cmd.line.r*s, 1.0f, cmd.col);
}
else if (cmd.type == IMGUI_GFXCMD_TRIANGLE)
{
if (cmd.flags == 1)
{
const float verts[3*2] =
{
(float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f,
(float)cmd.rect.x*s+0.5f+(float)cmd.rect.w*s-1, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s/2-0.5f,
(float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s-1,
};
drawPolygon(verts, 3, 1.0f, cmd.col);
}
if (cmd.flags == 2)
{
const float verts[3*2] =
{
(float)cmd.rect.x*s+0.5f, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s-1,
(float)cmd.rect.x*s+0.5f+(float)cmd.rect.w*s/2-0.5f, (float)cmd.rect.y*s+0.5f,
(float)cmd.rect.x*s+0.5f+(float)cmd.rect.w*s-1, (float)cmd.rect.y*s+0.5f+(float)cmd.rect.h*s-1,
};
drawPolygon(verts, 3, 1.0f, cmd.col);
}
}
else if (cmd.type == IMGUI_GFXCMD_TEXT)
{
drawText(cmd.text.x, cmd.text.y, cmd.text.text, cmd.text.align, cmd.col);
}
else if (cmd.type == IMGUI_GFXCMD_SCISSOR)
{
if (cmd.flags)
{
glEnable(GL_SCISSOR_TEST);
glScissor(cmd.rect.x, cmd.rect.y, cmd.rect.w, cmd.rect.h);
}
else
{
glDisable(GL_SCISSOR_TEST);
}
}
}
glDisable(GL_SCISSOR_TEST);
}
bool
TextAsset::load()
{
// Set up a temporary Cairo surface/context for text measurement
cairo_surface_t* probeSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
if (cairo_surface_status(probeSurface) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not create Cairo surface\n");
_error = true;
return false;
}
cairo_t* probeContext = cairo_create(probeSurface);
if (cairo_status(probeContext) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not create Cairo context\n");
_error = true;
return false;
}
// Text rectangle drawn within border
const int idealWidth = _maxSize.width - _marginLeft - _marginRight;
const Size textRegion(idealWidth, _maxSize.height - _marginTop - _marginBottom);
const float fontSize = primaryFontSize(probeContext, textRegion);
const std::string fontDesc = _fontName + " " + boost::lexical_cast<std::string>(fontSize);
PangoFontDescription* fontDescription = pango_font_description_from_string(fontDesc.c_str());
const std::string req_desc_str(pango_font_description_to_string(fontDescription));
PangoFontMap* fontMap = pango_cairo_font_map_new_for_font_type(CAIRO_FONT_TYPE_FT);
PangoContext* pango_context = pango_font_map_create_context(fontMap);
// TODO: Does this need to be freed or does the context take it with it?
PangoFont* pangoFont = pango_font_map_load_font(fontMap, pango_context, fontDescription);
PangoFontDescription* reverseDescription = pango_font_describe(pangoFont);
const std::string match_desc_str(pango_font_description_to_string(reverseDescription));
pango_font_description_free(reverseDescription);
g_object_unref(pango_context);
if (req_desc_str.find(match_desc_str) == std::string::npos) {
fprintf(stderr, "Warning: Unable to correctly match font \"%s\", using "
"\"%s\" instead.\n", req_desc_str.c_str(), match_desc_str.c_str());
}
float shadowXOffset = 0;
float shadowYOffset = 0;
if (_dropShadow) {
shadowXOffset = _dropShadowOffset.x() * CLIENT_TO_SERVER_SCALE * fontSize;
shadowYOffset = _dropShadowOffset.y() * CLIENT_TO_SERVER_SCALE * fontSize;
}
Rect tight;
const Size textSize = computeSizeOfText(probeContext, _textContent, idealWidth, fontDescription, &tight);
const Size imageSize = imageSizeForTextSize(tight.size, shadowXOffset, shadowYOffset);
// Tear down scratch contexts
cairo_destroy(probeContext);
cairo_surface_destroy(probeSurface);
const int width = imageSize.width;
const int height = imageSize.height;
// Configure the actual Cairo drawing surface/context now that we know the final resolution
cairo_surface_t* cairoSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
if (cairo_surface_status(cairoSurface) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not create Cairo surface\n");
_error = true;
return false;
}
cairo_t* cairoContext = cairo_create(cairoSurface);
// Flip the context like in the iOS version.
// This fixes flipped filters associated with text assets.
cairo_translate(cairoContext, 0.0, height);
cairo_scale(cairoContext, 1.0, -1.0);
if (cairo_status(cairoContext) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not create Cairo context\n");
_error = true;
return false;
}
// Fill the box with the background color
cairo_save(cairoContext);
cairo_set_operator(cairoContext, CAIRO_OPERATOR_SOURCE);
const mf::Color& bgColor(_style->getBackgroundColor());
cairo_set_source_rgba(cairoContext, bgColor.red, bgColor.green, bgColor.blue, bgColor.alpha);
if (_shape == 0) {
if (_cornerWidth > 0 && _cornerHeight > 0) {
// TODO: Support independent corner width and height
drawRoundedRect(cairoContext, 0, 0, imageSize.width, imageSize.height, _cornerWidth);
} else {
cairo_paint(cairoContext);
if (_strokeThickness > 0.0f) {
drawStrokedRect(cairoContext, 0, 0, imageSize.width, imageSize.height, _strokeThickness);
}
}
} else if (_shape == 1) {
strokeFillBezier(cairoContext, 0, 0, imageSize.width, imageSize.height, _strokeThickness);
}
cairo_restore(cairoContext);
const Rect textRect = textRectForTextSize(textSize, imageSize, tight);
if (_dropShadow) {
const Rect shadowRect(textRect.x + shadowXOffset,
textRect.y + shadowYOffset,
textRect.size.width,
textRect.size.height);
cairo_set_source_rgba(cairoContext,
_dropShadowColor.red,
_dropShadowColor.green,
_dropShadowColor.blue,
_dropShadowColor.alpha);
drawText(cairoContext, _textContent, shadowRect, fontDescription, false);
}
cairo_set_source_rgba(cairoContext, _textColor.red, _textColor.green, _textColor.blue, _textColor.alpha);
if (_textColor.alpha > 0.0) {
drawText(cairoContext, _textContent, textRect, fontDescription, true);
}
// DEBUG: Dump rendered text to an image
// cairo_surface_write_to_png(cairoSurface, "text.png");
// Transfer Cairo surface to OpenGL texture
GLubyte* imageData = static_cast<GLubyte *>(cairo_image_surface_get_data(cairoSurface));
glGenTextures(1, &_texture.textureID);
glBindTexture(GL_TEXTURE_2D, _texture.textureID);
_texture.width = width;
_texture.height = height;
_texture.s = 1.0;
_texture.t = 1.0;
_texture.aspect = static_cast<GLfloat>(_texture.width) / _texture.height;
_texture.flipImage = true;
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
#ifdef GL_BGRA
// Allocate and transfer data into texture (allow OpenGL swizzling)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8_REV, imageData);
#else
// Cairo uses a BGRA layout, OpenGL ES 2.0 does not support GL_BGRA as a
// source format so manually perform swizzling.
for (size_t i = 0; i < width * height * BYTES_PER_PIXEL; i += BYTES_PER_PIXEL) {
std::swap(imageData[i], imageData[i + 2]);
}
// Allocate and transfer data into texture
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, imageData);
#endif
// Clean up
pango_font_description_free(fontDescription);
cairo_destroy(cairoContext);
cairo_surface_destroy(cairoSurface);
g_object_unref(pangoFont);
_loading = false;
_loaded = !_loading && !_error;
return true;
}
