Revision: 44784
          
http://projects.blender.org/scm/viewvc.php?view=rev&root=bf-blender&revision=44784
Author:   campbellbarton
Date:     2012-03-10 14:20:55 +0000 (Sat, 10 Mar 2012)
Log Message:
-----------
style cleanup: unit code

Modified Paths:
--------------
    trunk/blender/source/blender/blenkernel/intern/unit.c

Modified: trunk/blender/source/blender/blenkernel/intern/unit.c
===================================================================
--- trunk/blender/source/blender/blenkernel/intern/unit.c       2012-03-10 
12:26:32 UTC (rev 44783)
+++ trunk/blender/source/blender/blenkernel/intern/unit.c       2012-03-10 
14:20:55 UTC (rev 44784)
@@ -35,7 +35,6 @@
 #include "BLI_string.h"
 #include "BLI_winstuff.h"
 
-
 #define TEMP_STR_SIZE 256
 
 #define SEP_CHR                '#'
@@ -76,15 +75,15 @@
 /* define a single unit */
 typedef struct bUnitDef {
        const char *name;
-       const char *name_plural;        /* abused a bit for the display name */
-       const char *name_short; /* this is used for display*/
-       const char *name_alt;           /* keyboard-friendly ASCII-only version 
of name_short, can be NULL */
-                                               /* if name_short has non-ASCII 
chars, name_alt should be present */
-       
-       const char *name_display;               /* can be NULL */
+       const char *name_plural; /* abused a bit for the display name */
+       const char *name_short; /* this is used for display*/
+       const char *name_alt; /* keyboard-friendly ASCII-only version of 
name_short, can be NULL */
+       /* if name_short has non-ASCII chars, name_alt should be present */
 
+       const char *name_display; /* can be NULL */
+
        double scalar;
-       double bias;            /* not used yet, needed for converting 
temperature */
+       double bias; /* not used yet, needed for converting temperature */
        int flag;
 } bUnitDef;
 
@@ -94,19 +93,15 @@
 /* define a single unit */
 typedef struct bUnitCollection {
        struct bUnitDef *units;
-       int base_unit;                          /* basic unit index (when user 
doesn't specify unit explicitly) */
-       int flag;                                       /* options for this 
system */
-       int length;                                     /* to quickly find the 
last item */
+       int base_unit; /* basic unit index (when user doesn't specify unit 
explicitly) */
+       int flag; /* options for this system */
+       int length; /* to quickly find the last item */
 } bUnitCollection;
 
 /* Dummy */
-static struct bUnitDef buDummyDef[] = {
-       {"",    NULL, "",       NULL, NULL, 1.0, 0.0},
-       {NULL,  NULL, NULL,     NULL, NULL, 0.0, 0.0}
-};
+static struct bUnitDef buDummyDef[] = { {"", NULL, "", NULL, NULL, 1.0, 0.0}, 
{NULL, NULL, NULL, NULL, NULL, 0.0, 0.0}};
 static struct bUnitCollection buDummyCollecton = {buDummyDef, 0, 0, 
sizeof(buDummyDef)};
 
-
 /* Lengths */
 static struct bUnitDef buMetricLenDef[] = {
        {"kilometer", "kilometers",             "km", NULL,     "Kilometers", 
UN_SC_KM, 0.0,    B_UNIT_DEF_NONE},
@@ -292,85 +287,83 @@
 static bUnitDef *unit_best_fit(double value, bUnitCollection *usys, bUnitDef 
*unit_start, int suppress)
 {
        bUnitDef *unit;
-       double value_abs= value>0.0?value:-value;
+       double value_abs = value > 0.0 ? value : -value;
 
-       for (unit= unit_start ? unit_start:usys->units; unit->name; unit++) {
+       for (unit = unit_start ? unit_start : usys->units; unit->name; unit++) {
 
                if (suppress && (unit->flag & B_UNIT_DEF_SUPPRESS))
                        continue;
 
                /* scale down scalar so 1cm doesnt convert to 10mm because of 
float error */
-               if (value_abs >= unit->scalar*(1.0-EPS))
+               if (value_abs >= unit->scalar * (1.0 - EPS))
                        return unit;
        }
 
        return unit_default(usys);
 }
 
-
-
 /* convert into 2 units and 2 values for "2ft, 3inch" syntax */
-static void unit_dual_convert(double value, bUnitCollection *usys,
-               bUnitDef **unit_a, bUnitDef **unit_b, double *value_a, double 
*value_b)
+static void unit_dual_convert(double value, bUnitCollection *usys, bUnitDef 
**unit_a, bUnitDef **unit_b,
+                              double *value_a, double *value_b)
 {
-       bUnitDef *unit= unit_best_fit(value, usys, NULL, 1);
+       bUnitDef *unit = unit_best_fit(value, usys, NULL, 1);
 
-       *value_a=  (value < 0.0 ? ceil:floor)(value/unit->scalar) * 
unit->scalar;
-       *value_b= value - (*value_a);
+       *value_a = (value < 0.0 ? ceil : floor)(value / unit->scalar) * 
unit->scalar;
+       *value_b = value - (*value_a);
 
-       *unit_a=        unit;
-       *unit_b=        unit_best_fit(*value_b, usys, *unit_a, 1);
+       *unit_a = unit;
+       *unit_b = unit_best_fit(*value_b, usys, *unit_a, 1);
 }
 
 static int unit_as_string(char *str, int len_max, double value, int prec, 
bUnitCollection *usys,
-               /* non exposed options */
-               bUnitDef *unit, char pad)
+                          /* non exposed options */
+                          bUnitDef *unit, char pad)
 {
        double value_conv;
        int len, i;
-       
+
        if (unit) {
                /* use unit without finding the best one */
        }
        else if (value == 0.0) {
                /* use the default units since there is no way to convert */
-               unit= unit_default(usys);
+               unit = unit_default(usys);
        }
        else {
-               unit= unit_best_fit(value, usys, NULL, 1);
+               unit = unit_best_fit(value, usys, NULL, 1);
        }
 
-       value_conv= value/unit->scalar;
+       value_conv = value / unit->scalar;
 
        /* Convert to a string */
        {
-               len= BLI_snprintf(str, len_max, "%.*f", prec, value_conv);
+               len = BLI_snprintf(str, len_max, "%.*f", prec, value_conv);
 
                if (len >= len_max)
-                       len= len_max;
+                       len = len_max;
        }
-       
+
        /* Add unit prefix and strip zeros */
 
        /* replace trailing zero's with spaces
         * so the number is less complicated but allignment in a button wont
         * jump about while dragging */
-       i= len-1;
+       i = len - 1;
 
-       while(i>0 && str[i]=='0') { /* 4.300 -> 4.3 */
-               str[i--]= pad;
+       while (i > 0 && str[i] == '0') { /* 4.300 -> 4.3 */
+               str[i--] = pad;
        }
 
-       if (i>0 && str[i]=='.') { /* 10. -> 10 */
-               str[i--]= pad;
+       if (i > 0 && str[i] == '.') { /* 10. -> 10 */
+               str[i--] = pad;
        }
-       
+
        /* Now add the suffix */
-       if (i<len_max) {
-               int j=0;
+       if (i < len_max) {
+               int j = 0;
                i++;
-               while(unit->name_short[j] && (i < len_max)) {
-                       str[i++]= unit->name_short[j++];
+               while (unit->name_short[j] && (i < len_max)) {
+                       str[i++] = unit->name_short[j++];
                }
 
                if (pad) {
@@ -378,64 +371,62 @@
                         * the unit name only used padded chars,
                         * In that case add padding for the name. */
 
-                       while(i<=len+j && (i < len_max)) {
-                               str[i++]= pad;
+                       while (i <= len + j && (i < len_max)) {
+                               str[i++] = pad;
                        }
                }
        }
 
        /* terminate no matter whats done with padding above */
        if (i >= len_max)
-               i= len_max-1;
+               i = len_max - 1;
 
        str[i] = '\0';
        return i;
 }
 
-
 /* Used for drawing number buttons, try keep fast */
 void bUnit_AsString(char *str, int len_max, double value, int prec, int 
system, int type, int split, int pad)
 {
        bUnitCollection *usys = unit_get_system(system, type);
 
-       if (usys==NULL || usys->units[0].name==NULL)
-               usys= &buDummyCollecton;
-   
+       if (usys == NULL || usys->units[0].name == NULL)
+               usys = &buDummyCollecton;
+
        /* split output makes sense only for length, mass and time */
-       if (split && (type==B_UNIT_LENGTH || type==B_UNIT_MASS || 
type==B_UNIT_TIME)) {
+       if (split && (type == B_UNIT_LENGTH || type == B_UNIT_MASS || type == 
B_UNIT_TIME)) {
                bUnitDef *unit_a, *unit_b;
                double value_a, value_b;
 
-               unit_dual_convert(value, usys,          &unit_a, &unit_b, 
&value_a, &value_b);
+               unit_dual_convert(value, usys, &unit_a, &unit_b, &value_a, 
&value_b);
 
                /* check the 2 is a smaller unit */
                if (unit_b > unit_a) {
-                       int i= unit_as_string(str, len_max, value_a, prec, 
usys,  unit_a, '\0');
+                       int i = unit_as_string(str, len_max, value_a, prec, 
usys, unit_a, '\0');
 
                        /* is there enough space for at least 1 char of the 
next unit? */
-                       if (i+2 < len_max) {
-                               str[i++]= ' ';
+                       if (i + 2 < len_max) {
+                               str[i++] = ' ';
 
                                /* use low precision since this is a smaller 
unit */
-                               unit_as_string(str+i, len_max-i, value_b, 
prec?1:0, usys,  unit_b, '\0');
+                               unit_as_string(str + i, len_max - i, value_b, 
prec ? 1 : 0, usys, unit_b, '\0');
                        }
                        return;
                }
        }
 
-       unit_as_string(str, len_max, value, prec, usys,    NULL, pad?' ':'\0');
+       unit_as_string(str, len_max, value, prec, usys, NULL, pad ? ' ' : '\0');
 }
 
-
 static const char *unit_find_str(const char *str, const char *substr)
 {
        const char *str_found;
 
        if (substr && substr[0] != '\0') {
-               str_found= strstr(str, substr);
+               str_found = strstr(str, substr);
                if (str_found) {
                        /* previous char cannot be a letter */
-                       if (str_found == str || isalpha(*(str_found-1))==0) {
+                       if (str_found == str || isalpha(*(str_found-1)) == 0) {
                                /* next char cannot be alphanum */
                                int len_name = strlen(substr);
 
@@ -462,60 +453,60 @@
 /* not too strict, (- = * /) are most common  */
 static int ch_is_op(char op)
 {
-       switch(op) {
-       case '+':
-       case '-':
-       case '*':
-       case '/':
-       case '|':
-       case '&':
-       case '~':
-       case '<':
-       case '>':
-       case '^':
-       case '!':
-       case '=':
-       case '%':
-               return 1;
-       default:
-               return 0;
+       switch (op) {
+               case '+':
+               case '-':
+               case '*':
+               case '/':
+               case '|':
+               case '&':
+               case '~':
+               case '<':
+               case '>':
+               case '^':
+               case '!':
+               case '=':
+               case '%':
+                       return 1;
+               default:
+                       return 0;
        }
 }
 
-static int unit_scale_str(char *str, int len_max, char *str_tmp,
-                          double scale_pref, bUnitDef *unit, const char 
*replace_str)
+static int unit_scale_str(char *str, int len_max, char *str_tmp, double 
scale_pref, bUnitDef *unit,
+                          const char *replace_str)
 {
        char *str_found;
 
-       if ((len_max>0) && (str_found= (char *)unit_find_str(str, 
replace_str))) {
+       if ((len_max > 0) && (str_found = (char *)unit_find_str(str, 
replace_str))) {
                /* XXX - investigate, does not respect len_max properly  */
 
                int len, len_num, len_name, len_move, found_ofs;
 
-               found_ofs = (int)(str_found-str);
+               found_ofs = (int)(str_found - str);
 
-               len= strlen(str);
+               len = strlen(str);
 
                len_name = strlen(replace_str);
-               len_move= (len - (found_ofs+len_name)) + 1; /* 1+ to copy the 
string terminator */
-               len_num= BLI_snprintf(str_tmp, TEMP_STR_SIZE, "*%g"SEP_STR, 
unit->scalar/scale_pref); /* # removed later */
+               len_move = (len - (found_ofs + len_name)) + 1; /* 1+ to copy 
the string terminator */
+               len_num = BLI_snprintf(str_tmp, TEMP_STR_SIZE, "*%g"SEP_STR, 
unit->scalar / scale_pref); /* # removed later */
 
                if (len_num > len_max)
-                       len_num= len_max;
+                       len_num = len_max;
 
-               if (found_ofs+len_num+len_move > len_max) {
+               if (found_ofs + len_num + len_move > len_max) {
                        /* can't move the whole string, move just as much as 
will fit */
-                       len_move -= (found_ofs+len_num+len_move) - len_max;
+                       len_move -= (found_ofs + len_num + len_move) - len_max;
                }
 
-               if (len_move>0) {
+               if (len_move > 0) {
                        /* resize the last part of the string */
-                       memmove(str_found+len_num, str_found+len_name, 
len_move); /* may grow or shrink the string */
+                       memmove(str_found + len_num, str_found + len_name, 
len_move); /* may grow or shrink the string */
                }
 

@@ Diff output truncated at 10240 characters. @@
_______________________________________________
Bf-blender-cvs mailing list
[email protected]
http://lists.blender.org/mailman/listinfo/bf-blender-cvs

Reply via email to