FreeJ C++ API: cairo_layer_js.cpp Source File

00001 /*  FreeJ
00002  *  (c) Copyright 2009-2010 Denis Roio <jaromil@dyne.org>
00003  *
00004  * This source code  is free software; you can  redistribute it and/or
00005  * modify it under the terms of the GNU Public License as published by
00006  * the Free Software  Foundation; either version 3 of  the License, or
00007  * (at your option) any later version.
00008  *
00009  * This source code is distributed in the hope that it will be useful,
00010  * but  WITHOUT ANY  WARRANTY; without  even the  implied  warranty of
00011  * MERCHANTABILITY or FITNESS FOR  A PARTICULAR PURPOSE.  Please refer
00012  * to the GNU Public License for more details.
00013  *
00014  * You should  have received  a copy of  the GNU Public  License along
00015  * with this source code; if  not, write to: Free Software Foundation,
00016  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
00017  *
00018  */
00019 
00020 #include <jsparser.h>
00021 #include <callbacks_js.h>
00022 #include <jsparser_data.h>
00023 #include <jsnum.h>
00024 #include <config.h>
00025 
00026 #ifdef WITH_CAIRO
00027 #include <cairo_layer.h>
00028 
00029 
00030 DECLARE_CLASS_GC("VectorLayer", vector_layer_class, vector_layer_constructor, js_layer_gc);
00031 
00033 // Vector Layer methods
00034 // basically exposing Cairo's API
00035 
00036 JSFunctionSpec vector_layer_methods[] = {
00037   ENTRY_METHODS,
00038   { "set_color",        vector_layer_color,            4 },
00039   { "translate",        vector_layer_translate,        2 },
00040   { "scale",            vector_layer_scale,            2 },
00041   { "rotate",           vector_layer_rotate,           1 },
00042   { "save",             vector_layer_save,             0 },
00043   { "restore",          vector_layer_restore,          0 },
00044   { "lineTo",           vector_layer_lineto,           2 },
00045   { "beginPath",        vector_layer_beginpath,        0 },
00046   { "moveTo",           vector_layer_moveto,           2 },
00047   { "quadraticCurveTo", vector_layer_quadcurveto,      4 },
00048   { "bezierCurveTo",    vector_layer_beziercurveto,    6 },
00049   { "arc",              vector_layer_arc,              5 },
00050   { "rect",             vector_layer_rect,             4 },
00051   { "closePath",        vector_layer_closepath,        0 },
00052   { "fill",             vector_layer_fill,             4 },
00053   { "fillRect",         vector_layer_fillrect,         4 },
00054   { "stroke",           vector_layer_stroke,           4 },
00055   { "push_color",       vector_layer_push_color,       0 },
00056   { "pop_color",        vector_layer_pop_color,        0 },
00057   {0}
00058 };
00059 
00060 
00061 JSPropertySpec vector_layer_properties[] = {
00062   { "fillStyle",   0, JSPROP_ENUMERATE | JSPROP_PERMANENT,
00063     vector_layer_fillstyle_g, vector_layer_fillstyle_s },
00064   { "strokeStyle", 1, JSPROP_ENUMERATE | JSPROP_PERMANENT,
00065     vector_layer_strokestyle_g, vector_layer_strokestyle_s },
00066   { "lineCap",     2, JSPROP_ENUMERATE | JSPROP_PERMANENT,
00067     vector_layer_linecap_g, vector_layer_linecap_s },
00068   { "lineWidth",   3, JSPROP_ENUMERATE | JSPROP_PERMANENT,
00069     vector_layer_linewidth_g, vector_layer_linewidth_s },
00070   {0}
00071 };
00072 
00073 
00074 // properties TODO: fillStyle, strokeStyle, lineCap, lineWidth
00075 
00076 JS_CONSTRUCTOR("VectorLayer", vector_layer_constructor, CairoLayer);
00077 
00078 
00079 
00080 JSBool CairoLayer::set_color(JSContext *cx, uintN argc, jsval *argv, int idx) {
00081 
00082   jsdouble r,g,b,a;
00083 
00084   if(argc==1) {
00085 
00086     g = js_get_double(argv[idx]);
00087     func("%s gray [%.2f]", __FUNCTION__, g);
00088     js_debug_argument(cx, argv[idx]);
00089     color->set_gray(g);
00090     return JS_TRUE;
00091 
00092   } else if(argc==2) {
00093 
00094     g = js_get_double(argv[idx]);
00095     a = js_get_double(argv[idx+1]);
00096 
00097     // g is a double
00098     // a is a signed integer
00099     func("%s gray [%.2f] alpha [%.2f]", __FUNCTION__, g, a);
00100     js_debug_property(cx, argv[idx]);
00101     js_debug_property(cx, argv[idx+1]);
00102 
00103     color->set_gray_alpha(g,a);
00104     return JS_TRUE;
00105 
00106   } else if(argc==3) {
00107     r = js_get_double(argv[idx]);
00108     g = js_get_double(argv[idx+1]);
00109     b = js_get_double(argv[idx+2]);
00110 
00111     func("%s r[%.2f] g[%.2f] b[%.2f]", __FUNCTION__, r, g, b);
00112     //    js_debug_property(cx, &argv[idx]);
00113     //    js_debug_property(cx, &argv[idx+1]);
00114     //    js_debug_property(cx, &argv[idx+2]);
00115 
00116     color->set_rgb(r, g, b);
00117     return JS_TRUE;
00118 
00119   } else if(argc==4) {
00120 
00121     r = js_get_double(argv[idx]);
00122     g = js_get_double(argv[idx+1]);
00123     b = js_get_double(argv[idx+2]);
00124     a = js_get_double(argv[idx+3]);
00125 
00126     func("%s r[%.2f] g[%.2f] b[%.2f] a[%.2f]", __FUNCTION__, r, g, b, a);
00127     // js_debug_property(cx, &argv[idx]);
00128     // js_debug_property(cx, &argv[idx+1]);
00129     // js_debug_property(cx, &argv[idx+2]);
00130     // js_debug_property(cx, &argv[idx+3]);
00131 
00132     color->set_rgba(r, g, b, a);
00133     return JS_TRUE;
00134     
00135   }
00136 
00137   error("usage of color with %u args not (yet?) supported",argc);
00138 
00139   return JS_FALSE;
00140 }
00141 
00142 JS(vector_layer_color) {
00143 
00144   GET_LAYER(CairoLayer);
00145 
00146   lay->set_color(cx, argc, argv, 0);
00147   return JS_TRUE;
00148 }
00149 
00150 JS(vector_layer_translate) {
00151 
00152   JS_CHECK_ARGC(2);
00153 
00154   GET_LAYER(CairoLayer);
00155 
00156   jsint tx, ty;
00157   
00158   tx = js_get_int(argv[0]);
00159   ty = js_get_int(argv[1]);
00160 
00161   func("%s x[%i] y[%i]", __FUNCTION__, tx, ty);
00162 
00163   lay->translate(tx, ty);
00164 
00165   return JS_TRUE;
00166 }
00167 
00168 JS(vector_layer_scale) {
00169   JS_CHECK_ARGC(2);
00170 
00171   GET_LAYER(CairoLayer);
00172 
00173   jsdouble sx, sy;
00174   sx = js_get_double(argv[0]);
00175   sy = js_get_double(argv[1]);
00176 
00177   func("%s x[%.2f] y[%.2f]", __FUNCTION__, sx, sy );
00178 
00179   lay->scale(sx, sy);
00180 
00181   return JS_TRUE;
00182 
00183 }
00184 
00185 JS(vector_layer_rotate) {
00186   JS_CHECK_ARGC(1);
00187 
00188   GET_LAYER(CairoLayer);
00189 
00190   jsdouble angle = js_get_double(argv[0]);
00191 
00192   func("%s angle[%.2f]", __FUNCTION__, angle);
00193 
00194   lay->rotate(angle);
00195 
00196   return JS_TRUE;
00197 
00198 }
00199 
00200 JS(vector_layer_save) {
00201   GET_LAYER(CairoLayer);
00202   lay->save();
00203   return JS_TRUE;
00204 }
00205 JS(vector_layer_restore) {
00206   GET_LAYER(CairoLayer);
00207   lay->restore();
00208   return JS_TRUE;
00209 }
00210 
00211 JS(vector_layer_lineto) {
00212 
00213   JS_CHECK_ARGC(2);
00214 
00215   GET_LAYER(CairoLayer);
00216 
00217   jsint x, y;
00218   x = js_get_int(argv[0]);
00219   y = js_get_int(argv[1]);
00220 
00221   func("%s x[%i] y[%i]", __FUNCTION__ , x, y );
00222 
00223   lay->line_to(x, y);
00224 
00225   return JS_TRUE;
00226 }
00227 
00228 JS(vector_layer_beginpath) {
00229   GET_LAYER(CairoLayer);  
00230   lay->new_path();
00231   return JS_TRUE;
00232 }
00233 JS(vector_layer_closepath) {
00234   GET_LAYER(CairoLayer);  
00235   lay->close_path();
00236   return JS_TRUE;
00237 }
00238 
00239 JS(vector_layer_moveto) {
00240 
00241   JS_CHECK_ARGC(2);
00242 
00243   GET_LAYER(CairoLayer);
00244 
00245   jsint x, y;
00246   x = js_get_int(argv[0]);
00247   y = js_get_int(argv[1]);
00248 
00249   func("%s x[%i] y[%i]", __FUNCTION__, x, y  );
00250 
00251   lay->move_to(x, y);
00252 
00253   return JS_TRUE;
00254 }
00255 
00256 JS(vector_layer_quadcurveto) {
00257 
00258   JS_CHECK_ARGC(4);
00259   GET_LAYER(CairoLayer);
00260 
00261   jsint x1, y1;
00262   x1 = js_get_int(argv[0]);
00263   y1 = js_get_int(argv[1]);
00264 
00265   jsint x2, y2;
00266   x2 = js_get_int(argv[2]);
00267   y2 = js_get_int(argv[3]);
00268 
00269   
00270   lay->quad_curve_to( x1, y1, x2, y2) ;
00271 
00272   return JS_TRUE;
00273 }
00274 
00275 JS(vector_layer_beziercurveto) {
00276 
00277   JS_CHECK_ARGC(6);
00278 
00279   GET_LAYER(CairoLayer);
00280 
00281   jsint x1, y1;
00282   x1 = js_get_int(argv[0]);
00283   y1 = js_get_int(argv[1]);
00284 
00285   jsint x2, y2;
00286   x2 = js_get_int(argv[2]);
00287   y2 = js_get_int(argv[3]);
00288 
00289   jsint x3, y3;
00290   x3 = js_get_int(argv[4]);
00291   y3 = js_get_int(argv[5]);
00292   
00293   func("Vector bezier curve :: x1[%i] y1[%i] x2[%i] y2[%i] x3[%i] y3[%i]",
00294        x1, y1, x2, y2, x3, y3 );
00295   
00296   lay->curve_to(x1, y1, x2, y2, x3, y3);
00297 
00298   return JS_TRUE;
00299 }
00300 
00301 JS(vector_layer_rect) {
00302   JS_CHECK_ARGC(4);
00303 
00304   GET_LAYER(CairoLayer);
00305 
00306   jsdouble x1, y1, x2, y2;
00307   x1 = js_get_double(argv[0]);
00308   y1 = js_get_double(argv[1]);
00309   x2 = js_get_double(argv[2]);
00310   y2 = js_get_double(argv[3]);
00311 
00312   func("Vector rect :: x[%i] y[%i] to x[%i] y[%i]",x1, y1, x2, y2);
00313 
00314   lay->rect(x1, y1, x2, y2);
00315 
00316   return JS_TRUE;
00317 
00318 }
00319 
00320 JS(vector_layer_arc) {
00321 
00322   JS_CHECK_ARGC(5);
00323 
00324   GET_LAYER(CairoLayer);
00325 
00326   jsint xc, yc;
00327   xc = js_get_int(argv[0]);
00328   yc = js_get_int(argv[1]);
00329 
00330   jsdouble radius, angle1, angle2;
00331   radius = js_get_double(argv[2]);
00332   angle1 = js_get_double(argv[3]);
00333   angle2 = js_get_double(argv[4]);
00334 
00335   func("Vector arc :: x[%i] y[%i] rad[%.2f] angle1[%.2f] angle2[%.2f]",
00336        xc, yc, radius, angle1, angle2 );
00337   
00338   lay->arc(xc, yc, radius, angle1, angle2);
00339 
00340   return JS_TRUE;
00341 }
00342 
00343 JS(vector_layer_fillrect) {
00344 
00345   JS_CHECK_ARGC(4);
00346 
00347   GET_LAYER(CairoLayer);  
00348 
00349   jsint x1, y1;
00350   x1 = js_get_int(argv[0]);
00351   y1 = js_get_int(argv[1]);
00352 
00353   jsint x2, y2;
00354   x2 = js_get_int(argv[2]);
00355   y2 = js_get_int(argv[3]);
00356 
00357   func("Vector fill_rect :: x1[%i] y1[%i] x2[%i] y2[%i]",
00358        x1, y1, x2, y2);
00359 
00360   lay->fill_rect(x1, y1, x2, y2);
00361 
00362   return JS_TRUE;
00363 }
00364   
00365 JS(vector_layer_fill) {
00366   func("%s",__FUNCTION__);
00367   GET_LAYER(CairoLayer);
00368 
00369   if(argc>0)
00370     lay->set_color(cx, argc, argv, 0);
00371 
00372   lay->fill();
00373   return JS_TRUE;
00374 }
00375 JS(vector_layer_stroke) {
00376   func("%s",__FUNCTION__);
00377   GET_LAYER(CairoLayer);  
00378 
00379   if(argc>0) {
00380     lay->set_color(cx, argc, argv, 0);
00381   }
00382 
00383   lay->stroke();
00384   return JS_TRUE;
00385 }
00386 
00387 JS(vector_layer_push_color) {
00388   func("%s",__FUNCTION__);
00389   GET_LAYER(CairoLayer);  
00390   lay->push_color();
00391   return JS_TRUE;
00392 }
00393 JS(vector_layer_pop_color) {
00394   func("%s",__FUNCTION__);
00395   GET_LAYER(CairoLayer);  
00396   lay->pop_color();
00397   return JS_TRUE;
00398 }
00399 
00400 JSP(vector_layer_fillstyle_g) {
00401   func("%s",__FUNCTION__);
00402   //  js_debug_property(cx, vp);
00403 
00404   //  GET_LAYER(CairoLayer);
00405 
00406   return JS_TRUE;
00407 }
00408 JSP(vector_layer_fillstyle_s) {
00409   func("%s",__FUNCTION__);
00410   //  js_debug_property(cx, vp);
00411 
00412   GET_LAYER(CairoLayer);
00413 
00414   // check if this makes sense
00415   cairo_set_fill_rule(lay->cairo, (cairo_fill_rule_t)*vp);
00416 
00417   // if( JSVAL_IS_NUM(*vp) )
00418   //   func("FILLSTYLE set is NUMBER");
00419 
00420   // if( JSVAL_IS_OBJECT(*vp) )
00421   //   func("FILLSTYLE set is OBJECT");
00422 
00423   // if( JS_IsArrayObject(cx, JSVAL_TO_OBJECT(*vp) ) )
00424   //   func("FILLSTYLE set is ARRAY");
00425 
00426   return JS_TRUE;
00427 }
00428 
00429 JSP(vector_layer_strokestyle_g) { 
00430   func("%s",__FUNCTION__);
00431   //  js_debug_property(cx, vp);
00432 
00433   return JS_TRUE;
00434 }
00435 JSP(vector_layer_strokestyle_s) { 
00436   func("%s",__FUNCTION__);
00437   //  js_debug_property(cx, vp);
00438 
00439   //  GET_LAYER(CairoLayer);  
00440 
00441   //  JS_PROP_NUMBER(num, vp);
00442   //  func("num is %f", num);
00443 
00444   // if( JSVAL_IS_OBJECT(*vp) )
00445   //   func("FILLSTYLE set is OBJECT");
00446   
00447   // if( JS_IsArrayObject(cx, JSVAL_TO_OBJECT(*vp) ) )
00448   //   func("FILLSTYLE set is ARRAY");
00449   
00450   return JS_TRUE;
00451 }
00452 
00453 JSP(vector_layer_linecap_g)     {
00454   func("%s",__FUNCTION__);
00455   //  js_debug_property(cx, vp);
00456 
00457   return JS_TRUE;
00458 }
00459 JSP(vector_layer_linecap_s)     {
00460   //  js_debug_property(cx, vp);
00461 
00462   GET_LAYER(CairoLayer);  
00463 
00464   char *cap = NULL;
00465   if(JSVAL_IS_STRING(*vp))
00466     cap = JS_GetStringBytes( JS_ValueToString(cx, *vp) );
00467   else {
00468     JS_ReportError(cx,"%s: property value is not a string",__FUNCTION__);
00469     ::error("%s: property value is not a string",__FUNCTION__);
00470   }
00471 
00472   func("Vector linecap set :: %s",cap);
00473   if(!cap) return JS_TRUE; // we don't stop the flow
00474 
00475   switch(cap[0]) { // we parse fast, using only first letter
00476     // [b]utt, [r]ound, [s]quare
00477   case 'b':
00478     cairo_set_line_cap(lay->cairo, CAIRO_LINE_CAP_BUTT);
00479     break;
00480   case 'r':
00481     cairo_set_line_cap(lay->cairo, CAIRO_LINE_CAP_ROUND);
00482     break;
00483   case 's':
00484     cairo_set_line_cap(lay->cairo, CAIRO_LINE_CAP_SQUARE);
00485     break;
00486   default:
00487     error("VectorLayer line cap not supported: %s", cap);
00488     error("use: butt, round or square");
00489     break;
00490   }
00491   return JS_TRUE;
00492 }
00493 
00494 JSP(vector_layer_linewidth_g)   { 
00495   func("%s",__FUNCTION__);
00496   //  js_debug_property(cx, vp);
00497 
00498   GET_LAYER(CairoLayer);  
00499 
00500   func("vp is %p : %f",vp, *vp);
00501 
00502   return JS_TRUE; }
00503 
00504 JSP(vector_layer_linewidth_s)   {
00505   func("%s",__FUNCTION__);
00506   //  js_debug_property(cx, vp);
00507 
00508   GET_LAYER(CairoLayer);  
00509 
00510   JS_PROP_DOUBLE(wid, *vp);
00511 
00512   lay->set_line_width(wid);
00513 
00514   return JS_TRUE;
00515 }
00516 
00517 #endif