void Logo::create_x(const Point2f &upper_left, const float &height) {
const Point2f p00 = get_p00(upper_left, height);
const Point2f p20 = get_p20(upper_left, height);
const Point2f p02 = get_p02(upper_left, height);
const Point2f p22 = get_p22(upper_left, height);
const float thickness = get_thickness(height);
create_thick_line(p00, p22, thickness, m_text_color);
create_thick_line(p02, p20, thickness, m_text_color);
create_circle(p00, thickness, m_text_color, 12);
create_circle(p20, thickness, m_text_color, 12);
create_circle(p02, thickness, m_text_color, 12);
create_circle(p22, thickness, m_text_color, 12);
}
// ---------------------------------------------------------------------------
//
// -----------
void bToolShape::end_clic(){
bStdToolGeom::end_clic();
if(!get_use_drag()){
return;
}
if(!get_active()){
return;
}
set_use_drag(false);
set_use_track(false);
CGPoint pa,pb;
get_clic(&pa);
get_cur(&pb);
CGFloat d=CGPointsDist(&pa,&pb);
if(d<=sqrt(2)){
return;
}
clearTempPathContext(true);
validTempPathContext();
if(get_mnu_cmd()==kShapeRect){
create_rect();
}
else{
create_circle();
}
}
static Object_t*
circle_factory_create_object1(gint x, gint y)
{
_start_x = x;
_start_y = y;
return create_circle(x, y, 0);
}
void Logo::create_p(const Point2f &upper_left, const float &height) {
const Point2f p00 = get_p00(upper_left, height);
const Point2f p10 = get_p10(upper_left, height);
const Point2f p01 = get_p01(upper_left, height);
const Point2f p11 = get_p11(upper_left, height);
const Point2f p02 = get_p02(upper_left, height);
const Point2f phc(p10.x, 0.5f * (p10.y + p11.y));
const float thickness = get_thickness(height);
create_thick_line(p00, p10, thickness, m_text_color);
create_thick_line(p00, p02, thickness, m_text_color);
create_thick_line(p01, p11, thickness, m_text_color);
create_circle(p00, thickness, m_text_color, 12);
create_circle(p02, thickness, m_text_color, 12);
create_hollow_ellipse(phc, Point2f(0.167f * m_height - thickness, 0.125f * m_height - thickness), Point2f(0.167f * m_height + thickness, 0.125f * m_height + thickness), m_text_color, 36, 18);
}
static void draw_normal_geom(SkCanvas* canvas, const SkPoint& offset, int geom, bool useAA) {
SkPaint p;
p.setAntiAlias(useAA);
p.setColor(SK_ColorBLACK);
switch (geom) {
case kRect_Geometry: // fall thru
case kRectAndRect_Geometry:
canvas->drawRect(create_rect(offset), p);
break;
case kRRect_Geometry: // fall thru
case kRectAndRRect_Geometry:
canvas->drawRRect(create_rrect(offset), p);
break;
case kCircle_Geometry:
canvas->drawRRect(create_circle(offset), p);
break;
case kConvexPath_Geometry: // fall thru
case kRectAndConvex_Geometry:
canvas->drawPath(create_convex_path(offset), p);
break;
case kConcavePath_Geometry: // fall thru
case kRectAndConcave_Geometry:
canvas->drawPath(create_concave_path(offset), p);
break;
}
}
void ShZshapeManager::create_shape(const char* content)
{
if (content == "cube")
{
create_cube();
}
if (content == "cylinder")
{
create_cylinder();
}
if (content == "pipe")
{
create_pipe();
}
if (content == "cone")
{
create_cone();
}
if (content == "circle")
{
create_circle();
}
if (content == "ring")
{
create_ring();
}
if (content == "pyramid")
{
create_pyramid();
}
if (content == "triangle")
{
create_triangle();
}
if (content == "rectangle")
{
create_rectangle();
}
if (content == "polygon")
{
create_polygon();
}
if (content == "multigonalStar")
{
create_multigonalStar();
}
}
void Logo::create_logo(const Point2f &upper_left, const float &height) {
const Point2f p30(upper_left.x + 0.500f * height, upper_left.y );
const Point2f p02(upper_left.x , upper_left.y + 0.333f * height);
const Point2f p42(upper_left.x + 0.666f * height, upper_left.y + 0.333f * height);
const Point2f p06(upper_left.x , upper_left.y + height);
const Point2f p26(upper_left.x + 0.333f * height, upper_left.y + height);
const Point2f p66(upper_left.x + height, upper_left.y + height);
const float thickness = 0.68f / 30.0f * height;
create_thick_line(p30, p06, thickness, m_logo_color);
create_thick_line(p30, p66, thickness, m_logo_color);
create_thick_line(p02, p42, thickness, m_logo_color);
create_thick_line(p06, p26, thickness, m_logo_color);
create_circle(p30, thickness, m_logo_color, 18);
create_circle(p02, thickness, m_logo_color, 18);
create_circle(p06, thickness, m_logo_color, 18);
create_circle(p26, thickness, m_logo_color, 18);
create_circle(p66, thickness, m_logo_color, 18);
}
void drawClippedGeom(SkCanvas* canvas, const SkPoint& offset, bool useAA) {
int count = canvas->save();
switch (fGeom) {
case kRect_Geometry:
canvas->clipRect(create_rect(offset), SkRegion::kReplace_Op, useAA);
break;
case kRRect_Geometry:
canvas->clipRRect(create_rrect(offset), SkRegion::kReplace_Op, useAA);
break;
case kCircle_Geometry:
canvas->clipRRect(create_circle(offset), SkRegion::kReplace_Op, useAA);
break;
case kConvexPath_Geometry:
canvas->clipPath(create_convex_path(offset), SkRegion::kReplace_Op, useAA);
break;
case kConcavePath_Geometry:
canvas->clipPath(create_concave_path(offset), SkRegion::kReplace_Op, useAA);
break;
case kRectAndRect_Geometry: {
SkRect r = create_rect(offset);
r.offset(fSign * kXlate, fSign * kXlate);
canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
canvas->clipRect(create_rect(offset), SkRegion::kIntersect_Op, useAA);
} break;
case kRectAndRRect_Geometry: {
SkRect r = create_rect(offset);
r.offset(fSign * kXlate, fSign * kXlate);
canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
canvas->clipRRect(create_rrect(offset), SkRegion::kIntersect_Op, useAA);
} break;
case kRectAndConvex_Geometry: {
SkRect r = create_rect(offset);
r.offset(fSign * kXlate, fSign * kXlate);
canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
canvas->clipPath(create_convex_path(offset), SkRegion::kIntersect_Op, useAA);
} break;
case kRectAndConcave_Geometry: {
SkRect r = create_rect(offset);
r.offset(fSign * kXlate, fSign * kXlate);
canvas->clipRect(r, SkRegion::kReplace_Op, true); // AA here forces shader clips
canvas->clipPath(create_concave_path(offset), SkRegion::kIntersect_Op, useAA);
} break;
}
SkISize size = canvas->getDeviceSize();
SkRect bigR = SkRect::MakeWH(SkIntToScalar(size.width()), SkIntToScalar(size.height()));
SkPaint p;
p.setColor(SK_ColorRED);
canvas->drawRect(bigR, p);
canvas->restoreToCount(count);
}
int main(int argc ,char *argv[])
{
/* Please keep all the files that you are using have this as the basic code */
circle *tree; // create the doc object
tree=create_circle(NULL); // initialize the datastructure
read_ssf_from_file(tree,argv[1]); // read from the file into tree
int sentence=sentences(tree);
node * temp[sentence]; // create the node object to store all the nodes retuned
int count=0,i,k; // count to count the # of sentences or nodes returned
count=traverse_tree(tree,temp,count); // function which returns all the sentence nodes into temp
for(i=0;i<count;i++) {
child(temp[i]);
}
print_tree_to_file(tree, "temp.txt");
return 0;
}
void ShZshapeManager::create_shape(const char* content, GLdouble positionX, GLdouble positionY, GLdouble positionZ, GLdouble r)
{
if (content == "circle")
{
create_circle(positionX, positionY, positionZ, r);
}
if (content == "ring")
{
create_ring(positionX, positionY, positionZ, r);
}
if (content == "triangle")
{
create_triangle(positionX, positionY, positionZ, r);
}
if (content == "rectangle")
{
create_rectangle(positionX, positionY, positionZ, r);
}
}
void
scene_pulley_joint (Scene *scene)
{
ClutterActor *stage;
ClutterActor *box2d;
stage = clutter_stage_get_default ();
box2d = clutter_box2d_new ();
clutter_container_add_actor (CLUTTER_CONTAINER (stage), box2d);
scene->group = box2d;
add_cage (box2d, FALSE);
{
ClutterVertex v1, v2, v3;
ClutterActor *joint1, *joint2, *box1, *box2;
/* Create platform 1 */
joint1 = create_circle (10);
clutter_actor_set_position (joint1, 110, 250);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), joint1);
clutter_box2d_child_set_is_circle (CLUTTER_BOX2D (box2d), joint1, TRUE);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), joint1,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), joint1,
TRUE);
box1 = clutter_rectangle_new ();
clutter_actor_set_size (box1, 200, 20);
clutter_actor_set_position (box1, 10, 350);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), box1);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), box1,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), box1,
TRUE);
add_hand (box2d, 20, 350 - 62);
add_hand (box2d, 210 - 58, 350 - 62);
v1 = (ClutterVertex){10, 10, 0};
v2 = (ClutterVertex){0, 0, 0};
v3 = (ClutterVertex){200, 0, 0};
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint1, box1,
&v1, &v2,
150, 0, 0);
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint1, box1,
&v1, &v3,
150, 0, 0);
/* Create platform 2 */
joint2 = create_circle (10);
clutter_actor_set_position (joint2, 530, 250);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), joint2);
clutter_box2d_child_set_is_circle (CLUTTER_BOX2D (box2d), joint2, TRUE);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), joint2,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), joint2,
TRUE);
box2 = clutter_rectangle_new ();
clutter_actor_set_size (box2, 200, 20);
clutter_actor_set_position (box2, 430, 350);
clutter_container_add_actor (CLUTTER_CONTAINER (box2d), box2);
clutter_box2d_child_set_mode (CLUTTER_BOX2D (box2d), box2,
CLUTTER_BOX2D_DYNAMIC);
clutter_box2d_child_set_manipulatable (CLUTTER_BOX2D (box2d), box2,
TRUE);
add_hand (box2d, 440, 350 - 62);
add_hand (box2d, 640 - 58, 350 - 62);
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint2, box2,
&v1, &v2,
150, 0, 0);
clutter_box2d_add_distance_joint (CLUTTER_BOX2D (box2d),
joint2, box2,
&v1, &v3,
150, 0, 0);
/* Create pulley joint */
v1 = (ClutterVertex){ 10, 10, 0 };
v2 = (ClutterVertex){ 120, 50, 0};
v3 = (ClutterVertex){ 540, 50, 0};
clutter_box2d_add_pulley_joint (CLUTTER_BOX2D (box2d),
joint1, joint2,
&v1, &v1,
&v2, &v3,
210, 210,
400, 400,
1.0);
}
clutter_box2d_set_simulating (CLUTTER_BOX2D (box2d), simulating);
}
static Object_t*
circle_factory_create_object2(gint x, gint y)
{
return create_circle(x, y, 0);
}
