Background gradient stuff
authorThomas White <taw@bitwiz.org.uk>
Thu, 10 Nov 2011 21:20:03 +0000 (22:20 +0100)
committerThomas White <taw@bitwiz.org.uk>
Thu, 10 Nov 2011 21:20:03 +0000 (22:20 +0100)
src/slide_render.c
src/stylesheet.c
src/stylesheet.h

index c3e5ee2..b5637e3 100644 (file)
@@ -39,7 +39,8 @@ static void render_bgblock(cairo_t *cr, struct bgblock *b)
 {
        GdkColor col1;
        GdkColor col2;
-       cairo_pattern_t *patt;
+       cairo_pattern_t *patt = NULL;
+       double cx, cy, r, r1, r2;
 
        cairo_rectangle(cr, b->min_x, b->min_y,
                            b->max_x - b->min_x,
@@ -54,22 +55,47 @@ static void render_bgblock(cairo_t *cr, struct bgblock *b)
                cairo_fill(cr);
                break;
 
+               case BGBLOCK_GRADIENT_CIRCULAR :
+               cx = b->min_x + (b->max_x-b->min_x)/2.0;
+               cy = b->min_y + (b->max_y-b->min_y)/2.0;
+               r1 = (b->max_x-b->min_x)/2.0;
+               r2 = (b->max_y-b->min_y)/2.0;
+               r = r1 > r2 ? r1 : r2;
+               patt = cairo_pattern_create_radial(cx, cy, r, cx, cy, 0.0);
+               /* Fall-through */
+
+               case BGBLOCK_GRADIENT_X :
+               if ( patt == NULL ) {
+                       patt = cairo_pattern_create_linear(b->min_x, 0.0,
+                                                          b->max_y, 0.0);
+               }
+               /* Fall-through */
+
                case BGBLOCK_GRADIENT_Y :
-               patt = cairo_pattern_create_linear(0.0, b->min_y,
-                                                  0.0, b->max_y);
+               if ( patt == NULL ) {
+                       patt = cairo_pattern_create_linear(0.0, b->min_y,
+                                                          0.0, b->max_y);
+               }
+
                gdk_color_parse(b->colour1, &col1);
                gdk_color_parse(b->colour2, &col2);
-               cairo_pattern_add_color_stop_rgb(patt, 0.0, col1.red/65535.0,
-                                                           col1.green/65535.0,
-                                                           col1.blue/65535.0);
-               cairo_pattern_add_color_stop_rgb(patt, 1.0, col2.red/65535.0,
-                                                           col2.green/65535.0,
-                                                           col2.blue/65535.0);
+               cairo_pattern_add_color_stop_rgba(patt, 0.0, col1.red/65535.0,
+                                                            col1.green/65535.0,
+                                                            col1.blue/65535.0,
+                                                            b->alpha1);
+               cairo_pattern_add_color_stop_rgba(patt, 1.0, col2.red/65535.0,
+                                                            col2.green/65535.0,
+                                                            col2.blue/65535.0,
+                                                            b->alpha2);
                cairo_set_source(cr, patt);
                cairo_fill(cr);
                cairo_pattern_destroy(patt);
                break;
 
+               case BGBLOCK_IMAGE :
+               cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
+               cairo_fill(cr);
+
        }
 }
 
index ffbc099..a597abd 100644 (file)
@@ -573,19 +573,86 @@ void default_stylesheet(StyleSheet *ss)
 
        ss->bgblocks = malloc(sizeof(struct bgblock));
        ss->n_bgblocks = 1;
-       ss->bgblocks[0].type = BGBLOCK_GRADIENT_Y;
+       ss->bgblocks[0].type = BGBLOCK_SOLID;
        ss->bgblocks[0].min_x = 0.0;
        ss->bgblocks[0].max_x = 1024.0;
        ss->bgblocks[0].min_y = 0.0;
        ss->bgblocks[0].max_y = 768.0;
-       ss->bgblocks[0].colour1 = strdup("#000000000000");
+       ss->bgblocks[0].colour1 = strdup("#ffffffffffff");
        ss->bgblocks[0].alpha1 = 1.0;
-       ss->bgblocks[0].colour2 = strdup("#ffffffffffff");
-       ss->bgblocks[0].alpha2 = 1.0;
 
 }
 
 
+static const char *str_halign(enum justify halign)
+{
+       switch ( halign ) {
+               case J_LEFT   : return "left";
+               case J_RIGHT  : return "right";
+               case J_CENTER : return "center";
+               default : return "???";
+       }
+}
+
+
+enum justify str_to_halign(char *halign)
+{
+       if ( strcmp(halign, "left") == 0 ) return J_LEFT;
+       if ( strcmp(halign, "right") == 0 ) return J_RIGHT;
+       if ( strcmp(halign, "center") == 0 ) return J_CENTER;
+
+       return J_LEFT;
+}
+
+
+static const char *str_valign(enum vert_pos valign)
+{
+       switch ( valign ) {
+               case V_TOP    : return "top";
+               case V_BOTTOM : return "bottom";
+               case V_CENTER : return "center";
+               default : return "???";
+       }
+}
+
+
+enum vert_pos str_to_valign(char *valign)
+{
+       if ( strcmp(valign, "top") == 0 ) return V_TOP;
+       if ( strcmp(valign, "bottom") == 0 ) return V_BOTTOM;
+       if ( strcmp(valign, "center") == 0 ) return V_CENTER;
+
+       return J_LEFT;
+}
+
+
+static const char *str_bgtype(enum bgblocktype t)
+{
+       switch ( t ) {
+               case BGBLOCK_SOLID             : return "solid";
+               case BGBLOCK_GRADIENT_X        : return "gradient_x";
+               case BGBLOCK_GRADIENT_Y        : return "gradient_y";
+               case BGBLOCK_GRADIENT_CIRCULAR : return "gradient_circular";
+               case BGBLOCK_IMAGE             : return "image";
+               default : return "???";
+       }
+}
+
+
+static enum bgblocktype str_to_bgtype(char *t)
+{
+       if ( strcmp(t, "solid") == 0 ) return BGBLOCK_SOLID;
+       if ( strcmp(t, "gradient_x") == 0 ) return BGBLOCK_GRADIENT_X;
+       if ( strcmp(t, "gradient_y") == 0 ) return BGBLOCK_GRADIENT_Y;
+       if ( strcmp(t, "gradient_ciruclar") == 0 ) {
+               return BGBLOCK_GRADIENT_CIRCULAR;
+       }
+       if ( strcmp(t, "image") == 0 ) return BGBLOCK_IMAGE;
+
+       return BGBLOCK_SOLID;
+}
+
+
 static int read_style(struct style *sty, struct ds_node *root)
 {
        char *align;
@@ -616,6 +683,41 @@ static int read_style(struct style *sty, struct ds_node *root)
 }
 
 
+static int read_bgblock(struct bgblock *b, struct ds_node *root)
+{
+       char *type;
+
+       get_field_s(root, "type",  &type);
+       b->type = str_to_bgtype(type);
+
+       get_field_f(root, "min_x",  &b->min_x);
+       get_field_f(root, "max_x",  &b->max_x);
+       get_field_f(root, "min_y",  &b->min_y);
+       get_field_f(root, "max_y",  &b->max_y);
+
+       switch ( b->type ) {
+
+               case BGBLOCK_SOLID :
+               get_field_s(root, "colour1",  &b->colour1);
+               get_field_f(root, "alpha1",  &b->alpha1);
+
+               case BGBLOCK_GRADIENT_X :
+               case BGBLOCK_GRADIENT_Y :
+               case BGBLOCK_GRADIENT_CIRCULAR :
+               get_field_s(root, "colour1",  &b->colour1);
+               get_field_f(root, "alpha1",  &b->alpha1);
+               get_field_s(root, "colour2",  &b->colour2);
+               get_field_f(root, "alpha2",  &b->alpha2);
+
+               default:
+               break;
+
+       }
+
+       return 0;
+}
+
+
 StyleSheet *tree_to_stylesheet(struct ds_node *root)
 {
        StyleSheet *ss;
@@ -658,11 +760,38 @@ StyleSheet *tree_to_stylesheet(struct ds_node *root)
 
        }
 
+       node = find_node(root, "bgblocks");
+       if ( node == NULL ) {
+               fprintf(stderr, "Couldn't find bgblocks\n");
+               free_stylesheet(ss);
+               return NULL;
+       }
+
+       ss->bgblocks = malloc(node->n_children * sizeof(struct bgblock));
+       if ( ss->bgblocks == NULL ) {
+               fprintf(stderr, "Couldn't allocate bgblocks\n");
+               free_stylesheet(ss);
+               return NULL;
+       }
+       ss->n_bgblocks = node->n_children;
+
+       for ( i=0; i<node->n_children; i++ ) {
+
+               struct bgblock *b;
+
+               b = &ss->bgblocks[i];
+
+               if ( read_bgblock(b, node->children[i]) ) {
+                       fprintf(stderr, "Couldn't read bgblock %i\n", i);
+                       continue;
+               }
+
+       }
+
        return ss;
 }
 
 
-
 StyleSheet *new_stylesheet()
 {
        StyleSheet *ss;
@@ -760,51 +889,50 @@ StylesheetWindow *open_stylesheet(struct presentation *p)
 }
 
 
-static const char *str_halign(enum justify halign)
-{
-       switch ( halign ) {
-               case J_LEFT   : return "left";
-               case J_RIGHT  : return "right";
-               case J_CENTER : return "center";
-               default : return "???";
-       }
-}
-
-
-enum justify str_to_halign(char *halign)
+void write_stylesheet(StyleSheet *ss, struct serializer *ser)
 {
-       if ( strcmp(halign, "left") == 0 ) return J_LEFT;
-       if ( strcmp(halign, "right") == 0 ) return J_RIGHT;
-       if ( strcmp(halign, "center") == 0 ) return J_CENTER;
-
-       return J_LEFT;
-}
+       int i;
 
+       serialize_start(ser, "bgblocks");
+       for ( i=0; i<ss->n_bgblocks; i++ ) {
 
-static const char *str_valign(enum vert_pos valign)
-{
-       switch ( valign ) {
-               case V_TOP    : return "top";
-               case V_BOTTOM : return "bottom";
-               case V_CENTER : return "center";
-               default : return "???";
-       }
-}
+               struct bgblock *b = &ss->bgblocks[i];
+               char id[32];
 
+               snprintf(id, 31, "%i", i);
 
-enum vert_pos str_to_valign(char *valign)
-{
-       if ( strcmp(valign, "top") == 0 ) return V_TOP;
-       if ( strcmp(valign, "bottom") == 0 ) return V_BOTTOM;
-       if ( strcmp(valign, "center") == 0 ) return V_CENTER;
+               serialize_start(ser, id);
+               serialize_s(ser, "type", str_bgtype(b->type));
+               serialize_f(ser, "min_x", b->min_x);
+               serialize_f(ser, "min_y", b->min_y);
+               serialize_f(ser, "max_x", b->max_x);
+               serialize_f(ser, "max_y", b->max_y);
+
+               switch ( b->type ) {
+
+                       case BGBLOCK_SOLID :
+                       serialize_s(ser, "colour1", b->colour1);
+                       serialize_f(ser, "alpha1", b->alpha1);
+                       break;
+
+                       case BGBLOCK_GRADIENT_X :
+                       case BGBLOCK_GRADIENT_Y :
+                       case BGBLOCK_GRADIENT_CIRCULAR :
+                       serialize_s(ser, "colour1", b->colour1);
+                       serialize_f(ser, "alpha1", b->alpha1);
+                       serialize_s(ser, "colour2", b->colour2);
+                       serialize_f(ser, "alpha2", b->alpha2);
+                       break;
+
+                       default:
+                       break;
 
-       return J_LEFT;
-}
+               }
 
+               serialize_end(ser);
 
-void write_stylesheet(StyleSheet *ss, struct serializer *ser)
-{
-       int i;
+       }
+       serialize_end(ser);
 
        serialize_start(ser, "styles");
        for ( i=0; i<ss->n_styles; i++ ) {
index 0c021e4..e9134d1 100644 (file)
@@ -75,6 +75,7 @@ enum bgblocktype
        BGBLOCK_SOLID,
        BGBLOCK_GRADIENT_X,
        BGBLOCK_GRADIENT_Y,
+       BGBLOCK_GRADIENT_CIRCULAR,
        BGBLOCK_IMAGE,
 };