void draw_cairo(cairo_surface_t *in) { cairo_t *cr; int mid ; if(0)printf("%p\n", in); if(!psize ) return; if(!in) return; cr = cairo_create (in); draw_path(cr); draw_fill(cr); draw_text(cr); draw_mask(cr); return; cairo_set_source_rgb (cr, 0, 1, 0); cairo_rectangle (cr, 0, 0, 640,480); cairo_fill (cr); cairo_set_source_rgb (cr, 0, 0, 0.9); cairo_rectangle (cr, 0, 0, 64,480); cairo_fill (cr); // cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE); // cairo_set_source_rgba (cr, 0, 0, 0, 0); // cairo_paint (cr); cairo_set_source_rgb (cr, 1, 1, 1); cairo_rectangle (cr, 0, 0, 100, 100); cairo_paint_with_alpha (cr, 0.5); // /cairo_fill (cr); //*surface_inout = cairo_surface_reference (cairo_get_target (cr)); #define M_PI 3.1415 cairo_arc (cr, 128.0, 128.0, 76.8, 0, 2 * M_PI); cairo_clip (cr); cairo_new_path (cr); cairo_rectangle (cr, 0, 0, 256, 256); cairo_fill (cr); cairo_set_source_rgb (cr, 0, 1, 0); cairo_move_to (cr, 0, 0); cairo_line_to (cr, 256, 256); cairo_move_to (cr, 256, 0); cairo_line_to (cr, 0, 256); cairo_set_line_width (cr, 10.0); cairo_stroke (cr); cairo_destroy (cr); }
static void resize_finish(int w, int h) { recalc_size(w, h); yutani_window_resize_accept(yctx, window, w, h); reinit_graphics_yutani(gfx_ctx, window); draw_fill(gfx_ctx, rgb(0,0,0)); if (current_doc) { /* redraw the page */ draw_decors(current_page, current_epage); drawpage(current_ctx, current_doc, current_page); } yutani_window_resize_done(yctx, window); yutani_flip(yctx, window); }
int main (int argc, char ** argv) { setup_windowing(); int width = wins_globals->server_width; int height = wins_globals->server_height; win_width = width; win_height = height; /* Do something with a window */ window_t * wina = window_create(0,0, width, height); assert(wina); window_reorder (wina, 0); ctx = init_graphics_window_double_buffer(wina); draw_fill(ctx, rgb(127,127,127)); flip(ctx); #if 1 printf("Loading background...\n"); init_sprite(0, "/usr/share/login-background.bmp", NULL); printf("Background loaded.\n"); draw_sprite_scaled(ctx, sprites[0], 0, 0, width, height); #endif #if 0 init_sprite(1, "/usr/share/bs.bmp", "/usr/share/bs-alpha.bmp"); draw_sprite_scaled(sprites[1], center_x(sprites[1]->width), center_y(sprites[1]->height), sprites[1]->width, sprites[1]->height); #endif flip(ctx); while (1) { syscall_yield(); //syscall_wait(wins_globals->server_pid); } #if 0 window_destroy(window); // (will close on exit) teardown_windowing(); #endif return 0; }
int main (int argc, char ** argv) { left = 100; top = 100; width = 500; height = 500; yctx = yutani_init(); wina = yutani_window_create(yctx, width, height); yutani_window_move(yctx, wina, left, top); ctx = init_graphics_yutani(wina); draw_fill(ctx, rgb(0,0,0)); pthread_t thread; pthread_create(&thread, NULL, draw_thread, NULL); while (!should_exit) { yutani_msg_t * m = yutani_poll(yctx); if (m) { switch (m->type) { case YUTANI_MSG_KEY_EVENT: { struct yutani_msg_key_event * ke = (void*)m->data; if (ke->event.action == KEY_ACTION_DOWN && ke->event.keycode == 'q') { should_exit = 1; syscall_yield(); } } break; case YUTANI_MSG_SESSION_END: should_exit = 1; break; default: break; } } free(m); } yutani_close(yctx, wina); return 0; }
void ttk_window_draw(ttk_window_t * window) { draw_fill(window->core_context, rgb(TTK_BACKGROUND_DEFAULT)); ttk_redraw_borders(window); /* TODO actual drawing */ { /* TODO move these surfaces into the ttk_window_t object */ int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, window->core_window->width); cairo_surface_t * core_surface = cairo_image_surface_create_for_data(window->core_context->backbuffer, CAIRO_FORMAT_ARGB32, window->core_window->width, window->core_window->height, stride); cairo_t * cr_main = cairo_create(core_surface); /* TODO move this surface to a ttk_frame_t or something; GUIs man, go look at some Qt or GTK APIs! */ cairo_surface_t * internal_surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, window->width, window->height); cairo_t * cr = cairo_create(internal_surface); _ttk_draw_menu(cr, 0, 0, window->width); _ttk_draw_button(cr, 4, TTK_MENU_HEIGHT + 4, window->width - 8, 40, "Regular Button"); _ttk_draw_button(cr, 4, TTK_MENU_HEIGHT + 48 + 4, (window->width / 2) - 8, 40, "Regular Button"); _ttk_draw_button_hover(cr, 4 + (window->width / 2), TTK_MENU_HEIGHT + 48 + 4, (window->width / 2) - 8, 40, "Hover Button"); _ttk_draw_button_select(cr, 4, TTK_MENU_HEIGHT + 2 * 48 + 4, (window->width / 2) - 8, 40, "Selected"); _ttk_draw_button_disabled(cr, 4 + (window->width / 2), TTK_MENU_HEIGHT + 2 * 48 + 4, (window->width / 2) - 8, 40, "Disabled Button"); _ttk_draw_button(cr, 4, TTK_MENU_HEIGHT + 3 * 48 + 4, window->width - 8, window->height - (3 * 48) - TTK_MENU_HEIGHT - 8, "Regular Button"); /* Paint the window's internal surface onto the backbuffer */ cairo_set_source_surface(cr_main, internal_surface, (double)window->off_x, (double)window->off_y); cairo_paint(cr_main); cairo_surface_flush(internal_surface); cairo_destroy(cr); cairo_surface_destroy(internal_surface); /* In theory, we don't actually want to destroy much of any of this; maybe the cairo_t */ cairo_surface_flush(core_surface); cairo_destroy(cr_main); cairo_surface_destroy(core_surface); } flip(window->core_context); yutani_flip(yctx, window->core_window); }
ttk_window_t * ttk_window_new(char * title, uint16_t width, uint16_t height) { ttk_window_t * new_win = malloc(sizeof(ttk_window_t)); new_win->title = strdup(title); new_win->width = width; new_win->height = height; new_win->off_x = decor_left_width; new_win->off_y = decor_top_height; new_win->core_window = yutani_window_create(yctx, new_win->width + decor_width(), new_win->height + decor_height()); yutani_window_move(yctx, new_win->core_window, TTK_DEFAULT_X, TTK_DEFAULT_Y); assert(new_win->core_window && "Oh dear, I've failed to allocate a new window from the server. This is terrible."); /* XXX icon; also need to do this if we change the title later */ yutani_window_advertise(yctx, new_win->core_window, new_win->title); new_win->core_context = init_graphics_yutani_double_buffer(new_win->core_window); draw_fill(new_win->core_context, rgb(TTK_BACKGROUND_DEFAULT)); ttk_window_draw(new_win); hashmap_set(ttk_wids_to_windows, (void*)new_win->core_window->wid, new_win); }
//std::wstring draw_fill::get_type_ms() //{ // std::wstring fillType; // switch(type_) // { // case draw_fill::none: fillType = L"a:noFill";break; // case draw_fill::hatch: fillType = L"a:pattFill";break; // case draw_fill::solid: fillType = L"a:solidFill";break; // case draw_fill::gradient: fillType = L"a:gradFill";break; // case draw_fill::bitmap: fillType = L"a:imageFill";break; // } // return fillType; //} draw_fill draw_fill::parse(const std::wstring & Str) { std::wstring tmp = Str; boost::algorithm::to_lower(tmp); if (tmp == L"none") return draw_fill( none ); else if (tmp == L"solid") return draw_fill( solid ); else if (tmp == L"bitmap") return draw_fill( bitmap ); else if (tmp == L"gradient") return draw_fill( gradient ); else if (tmp == L"hatch") return draw_fill( hatch ); else { BOOST_THROW_EXCEPTION( errors::invalid_attribute() ); return draw_fill( solid ); } }
int main (int argc, char ** argv) { setup_windowing(); int width = wins_globals->server_width; int height = wins_globals->server_height; win_width = width; win_height = height; init_shmemfonts(); set_font_size(14); /* Create the panel */ window_t * panel = window_create(0, 0, width, PANEL_HEIGHT); window_reorder (panel, 0xFFFF); ctx = init_graphics_window_double_buffer(panel); draw_fill(ctx, rgba(0,0,0,0)); flip(ctx); init_sprite_png(0, "/usr/share/panel.png"); init_sprite_png(1, "/usr/share/icons/panel-shutdown.png"); for (uint32_t i = 0; i < width; i += sprites[0]->width) { draw_sprite(ctx, sprites[0], i, 0); } size_t buf_size = panel->width * panel->height * sizeof(uint32_t); char * buf = malloc(buf_size); memcpy(buf, ctx->backbuffer, buf_size); flip(ctx); struct timeval now; int last = 0; struct tm * timeinfo; char buffer[80]; struct utsname u; uname(&u); /* UTF-8 Strings FTW! */ uint8_t * os_name_ = "PonyOS"; uint8_t final[512]; uint32_t l = snprintf(final, 512, "%s %s", os_name_, u.release); syscall_signal(2, sig_int); /* Enable mouse */ win_use_threaded_handler(); mouse_action_callback = panel_check_click; while (_continue) { /* Redraw the background by memcpy (super speedy) */ memcpy(ctx->backbuffer, buf, buf_size); syscall_gettimeofday(&now, NULL); //time(NULL); if (now.tv_sec != last) { last = now.tv_sec; timeinfo = localtime((time_t *)&now.tv_sec); strftime(buffer, 80, "%I:%M:%S %p", timeinfo); draw_string(ctx, width - 120, 17, rgb(255,255,255), buffer); draw_string(ctx, 10, 17, rgb(255,255,255), final); draw_sprite(ctx, sprites[1], win_width - 23, 1); /* Logout button */ flip(ctx); } syscall_nanosleep(0,50); }
void draw_render_polygon_object (gerbv_net_t *oldNet, cairo_t *cairoTarget, gdouble sr_x, gdouble sr_y, gerbv_image_t *image, enum draw_mode drawMode, gerbv_selection_info_t *selectionInfo, gboolean pixelOutput) { gerbv_net_t *currentNet, *polygonStartNet; int haveDrawnFirstFillPoint = 0; gdouble x2,y2,cp_x=0,cp_y=0; haveDrawnFirstFillPoint = FALSE; /* save the first net in the polygon as the "ID" net pointer in case we are saving this net to the selection array */ polygonStartNet = oldNet; cairo_new_path(cairoTarget); for (currentNet = oldNet->next; currentNet!=NULL; currentNet = currentNet->next) { x2 = currentNet->stop_x + sr_x; y2 = currentNet->stop_y + sr_y; /* translate circular x,y data as well */ if (currentNet->cirseg) { cp_x = currentNet->cirseg->cp_x + sr_x; cp_y = currentNet->cirseg->cp_y + sr_y; } if (!haveDrawnFirstFillPoint) { draw_cairo_move_to (cairoTarget, x2, y2, FALSE, pixelOutput); haveDrawnFirstFillPoint=TRUE; continue; } switch (currentNet->interpolation) { case GERBV_INTERPOLATION_x10 : case GERBV_INTERPOLATION_LINEARx01 : case GERBV_INTERPOLATION_LINEARx001 : case GERBV_INTERPOLATION_LINEARx1 : draw_cairo_line_to (cairoTarget, x2, y2, FALSE, pixelOutput); break; case GERBV_INTERPOLATION_CW_CIRCULAR : case GERBV_INTERPOLATION_CCW_CIRCULAR : if (currentNet->cirseg->angle2 > currentNet->cirseg->angle1) { cairo_arc (cairoTarget, cp_x, cp_y, currentNet->cirseg->width/2.0, DEG2RAD(currentNet->cirseg->angle1), DEG2RAD(currentNet->cirseg->angle2)); } else { cairo_arc_negative (cairoTarget, cp_x, cp_y, currentNet->cirseg->width/2.0, DEG2RAD(currentNet->cirseg->angle1), DEG2RAD(currentNet->cirseg->angle2)); } break; case GERBV_INTERPOLATION_PAREA_END : cairo_close_path(cairoTarget); /* turn off anti-aliasing for polygons, since it shows seams with adjacent polygons (usually on PCB ground planes) */ cairo_antialias_t oldAlias = cairo_get_antialias (cairoTarget); cairo_set_antialias (cairoTarget, CAIRO_ANTIALIAS_NONE); draw_fill (cairoTarget, drawMode, selectionInfo, image, polygonStartNet); cairo_set_antialias (cairoTarget, oldAlias); return; default : break; } } }
int draw_image_to_cairo_target (cairo_t *cairoTarget, gerbv_image_t *image, gdouble pixelWidth, enum draw_mode drawMode, gerbv_selection_info_t *selectionInfo, gerbv_render_info_t *renderInfo, gboolean allowOptimization, gerbv_user_transformation_t transform, gboolean pixelOutput) { const int hole_cross_inc_px = 8; struct gerbv_net *net, *polygonStartNet=NULL; double x1, y1, x2, y2, cp_x=0, cp_y=0; gdouble *p, p0, p1, dx, dy, lineWidth, r; gerbv_netstate_t *oldState; gerbv_layer_t *oldLayer; cairo_operator_t drawOperatorClear, drawOperatorDark; gboolean invertPolarity = FALSE, oddWidth = FALSE; gdouble minX=0, minY=0, maxX=0, maxY=0; gdouble criticalRadius; gdouble scaleX = transform.scaleX; gdouble scaleY = transform.scaleY; gboolean limitLineWidth = TRUE; gboolean displayPixel = TRUE; /* If we are scaling the image at all, ignore the line width checks * since scaled up lines can still be visible */ if ((scaleX != 1)||(scaleY != 1)){ limitLineWidth = FALSE; } if (transform.mirrorAroundX) scaleY *= -1; if (transform.mirrorAroundY) scaleX *= -1; cairo_translate (cairoTarget, transform.translateX, transform.translateY); cairo_scale (cairoTarget, scaleX, scaleY); cairo_rotate (cairoTarget, transform.rotation); gboolean useOptimizations = allowOptimization; /* If the user is using any transformations for this layer, then don't * bother using rendering optimizations */ if ((fabs(transform.translateX) > 0.00001) || (fabs(transform.translateY) > 0.00001) || (fabs(transform.scaleX - 1) > 0.00001) || (fabs(transform.scaleY - 1) > 0.00001) || (fabs(transform.rotation) > 0.00001) || transform.mirrorAroundX || transform.mirrorAroundY) useOptimizations = FALSE; if (useOptimizations && pixelOutput) { minX = renderInfo->lowerLeftX; minY = renderInfo->lowerLeftY; maxX = renderInfo->lowerLeftX + (renderInfo->displayWidth / renderInfo->scaleFactorX); maxY = renderInfo->lowerLeftY + (renderInfo->displayHeight / renderInfo->scaleFactorY); } /* do initial justify */ cairo_translate (cairoTarget, image->info->imageJustifyOffsetActualA, image->info->imageJustifyOffsetActualB); /* set the fill rule so aperture holes are cleared correctly */ cairo_set_fill_rule (cairoTarget, CAIRO_FILL_RULE_EVEN_ODD); /* offset image */ cairo_translate (cairoTarget, image->info->offsetA, image->info->offsetB); /* do image rotation */ cairo_rotate (cairoTarget, image->info->imageRotation); /* load in polarity operators depending on the image polarity */ invertPolarity = transform.inverted; if (image->info->polarity == GERBV_POLARITY_NEGATIVE) invertPolarity = !invertPolarity; if (drawMode == DRAW_SELECTIONS) invertPolarity = FALSE; if (invertPolarity) { drawOperatorClear = CAIRO_OPERATOR_OVER; drawOperatorDark = CAIRO_OPERATOR_CLEAR; cairo_set_operator (cairoTarget, CAIRO_OPERATOR_OVER); cairo_paint (cairoTarget); cairo_set_operator (cairoTarget, CAIRO_OPERATOR_CLEAR); } else { drawOperatorClear = CAIRO_OPERATOR_CLEAR; drawOperatorDark = CAIRO_OPERATOR_OVER; } /* next, push two cairo states to simulate the first layer and netstate translations (these will be popped when another layer or netstate is started */ cairo_save (cairoTarget); cairo_save (cairoTarget); /* store the current layer and netstate so we know when they change */ oldLayer = image->layers; oldState = image->states; for (net = image->netlist->next; net != NULL; net = gerbv_image_return_next_renderable_object(net)) { /* check if this is a new layer */ if (net->layer != oldLayer){ /* it's a new layer, so recalculate the new transformation matrix for it */ cairo_restore (cairoTarget); cairo_restore (cairoTarget); cairo_save (cairoTarget); /* do any rotations */ cairo_rotate (cairoTarget, net->layer->rotation); /* handle the layer polarity */ if ((net->layer->polarity == GERBV_POLARITY_CLEAR)^invertPolarity) { cairo_set_operator (cairoTarget, CAIRO_OPERATOR_CLEAR); drawOperatorClear = CAIRO_OPERATOR_OVER; drawOperatorDark = CAIRO_OPERATOR_CLEAR; } else { cairo_set_operator (cairoTarget, CAIRO_OPERATOR_OVER); drawOperatorClear = CAIRO_OPERATOR_CLEAR; drawOperatorDark = CAIRO_OPERATOR_OVER; } /* Draw any knockout areas */ gerbv_knockout_t *ko = &net->layer->knockout; if (ko->firstInstance == TRUE) { cairo_operator_t oldOperator = cairo_get_operator (cairoTarget); if (ko->polarity == GERBV_POLARITY_CLEAR) { cairo_set_operator (cairoTarget, drawOperatorClear); } else { cairo_set_operator (cairoTarget, drawOperatorDark); } cairo_new_path (cairoTarget); cairo_rectangle (cairoTarget, ko->lowerLeftX - ko->border, ko->lowerLeftY - ko->border, ko->width + 2*ko->border, ko->height + 2*ko->border); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); cairo_set_operator (cairoTarget, oldOperator); } /* Finally, reapply old netstate transformation */ cairo_save (cairoTarget); draw_apply_netstate_transformation (cairoTarget, net->state); oldLayer = net->layer; } /* check if this is a new netstate */ if (net->state != oldState){ /* pop the transformation matrix back to the "pre-state" state and resave it */ cairo_restore (cairoTarget); cairo_save (cairoTarget); /* it's a new state, so recalculate the new transformation matrix for it */ draw_apply_netstate_transformation (cairoTarget, net->state); oldState = net->state; } /* if we are only drawing from the selection buffer, search if this net is in the buffer */ if (drawMode == DRAW_SELECTIONS) { /* this flag makes sure we don't draw any unintentional polygons... if we've successfully entered a polygon (the first net matches, and we don't want to check the nets inside the polygon) then polygonStartNet will be set */ if (!polygonStartNet) { if (!draw_net_is_in_selection_buffer_remove (net, selectionInfo, FALSE)) continue; } } /* step and repeat */ gerbv_step_and_repeat_t *sr = &net->layer->stepAndRepeat; int ix, iy; for (ix = 0; ix < sr->X; ix++) { for (iy = 0; iy < sr->Y; iy++) { double sr_x = ix * sr->dist_X; double sr_y = iy * sr->dist_Y; if (useOptimizations && pixelOutput && ((net->boundingBox.right+sr_x < minX) || (net->boundingBox.left+sr_x > maxX) || (net->boundingBox.top+sr_y < minY) || (net->boundingBox.bottom+sr_y > maxY))) { continue; } x1 = net->start_x + sr_x; y1 = net->start_y + sr_y; x2 = net->stop_x + sr_x; y2 = net->stop_y + sr_y; /* translate circular x,y data as well */ if (net->cirseg) { cp_x = net->cirseg->cp_x + sr_x; cp_y = net->cirseg->cp_y + sr_y; } /* render any labels attached to this net */ /* NOTE: this is currently only used on PNP files, so we may make some assumptions here... */ if (net->label) { cairo_set_font_size (cairoTarget, 0.05); cairo_save (cairoTarget); cairo_move_to (cairoTarget, x1, y1); cairo_scale (cairoTarget, 1, -1); cairo_show_text (cairoTarget, net->label->str); cairo_restore (cairoTarget); } /* Polygon area fill routines */ switch (net->interpolation) { case GERBV_INTERPOLATION_PAREA_START : draw_render_polygon_object (net, cairoTarget, sr_x, sr_y, image, drawMode, selectionInfo, pixelOutput); continue; case GERBV_INTERPOLATION_DELETED: continue; default : break; } /* * If aperture state is off we allow use of undefined apertures. * This happens when gerber files starts, but hasn't decided on * which aperture to use. */ if (image->aperture[net->aperture] == NULL) continue; switch (net->aperture_state) { case GERBV_APERTURE_STATE_ON : /* if the aperture width is truly 0, then render as a 1 pixel width line. 0 diameter apertures are used by some programs to draw labels, etc, and they are rendered by other programs as 1 pixel wide */ /* NOTE: also, make sure all lines are at least 1 pixel wide, so they always show up at low zoom levels */ if (limitLineWidth&&((image->aperture[net->aperture]->parameter[0] < pixelWidth)&& (pixelOutput))) criticalRadius = pixelWidth/2.0; else criticalRadius = image->aperture[net->aperture]->parameter[0]/2.0; lineWidth = criticalRadius*2.0; // convert to a pixel integer cairo_user_to_device_distance (cairoTarget, &lineWidth, &x1); if (pixelOutput) { lineWidth = round(lineWidth); if ((int)lineWidth % 2) { oddWidth = TRUE; } else { oddWidth = FALSE; } } cairo_device_to_user_distance (cairoTarget, &lineWidth, &x1); cairo_set_line_width (cairoTarget, lineWidth); switch (net->interpolation) { case GERBV_INTERPOLATION_x10 : case GERBV_INTERPOLATION_LINEARx01 : case GERBV_INTERPOLATION_LINEARx001 : case GERBV_INTERPOLATION_LINEARx1 : cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); /* weed out any lines that are * obviously not going to * render on the visible screen */ switch (image->aperture[net->aperture]->type) { case GERBV_APTYPE_CIRCLE : if (renderInfo->show_cross_on_drill_holes && image->layertype == GERBV_LAYERTYPE_DRILL) { /* Draw center crosses on slot hole */ cairo_set_line_width (cairoTarget, pixelWidth); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_SQUARE); r = image->aperture[net->aperture]->parameter[0]/2.0 + hole_cross_inc_px*pixelWidth; draw_cairo_cross (cairoTarget, x1, y1, r); draw_cairo_cross (cairoTarget, x2, y2, r); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); cairo_set_line_width (cairoTarget, lineWidth); } draw_cairo_move_to (cairoTarget, x1, y1, oddWidth, pixelOutput); draw_cairo_line_to (cairoTarget, x2, y2, oddWidth, pixelOutput); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; case GERBV_APTYPE_RECTANGLE : dx = image->aperture[net->aperture]->parameter[0]/2; dy = image->aperture[net->aperture]->parameter[1]/2; if(x1 > x2) dx = -dx; if(y1 > y2) dy = -dy; cairo_new_path(cairoTarget); draw_cairo_move_to (cairoTarget, x1 - dx, y1 - dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x1 - dx, y1 + dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x2 - dx, y2 + dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x2 + dx, y2 + dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x2 + dx, y2 - dy, FALSE, pixelOutput); draw_cairo_line_to (cairoTarget, x1 + dx, y1 - dy, FALSE, pixelOutput); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); break; /* TODO: for now, just render ovals or polygons like a circle */ case GERBV_APTYPE_OVAL : case GERBV_APTYPE_POLYGON : draw_cairo_move_to (cairoTarget, x1,y1, oddWidth, pixelOutput); draw_cairo_line_to (cairoTarget, x2,y2, oddWidth, pixelOutput); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; /* macros can only be flashed, so ignore any that might be here */ default: GERB_COMPILE_WARNING(_("Skipped aperture type \"%s\""), _(aperture_names[image->aperture[net->aperture]->type])); break; } break; case GERBV_INTERPOLATION_CW_CIRCULAR : case GERBV_INTERPOLATION_CCW_CIRCULAR : /* cairo doesn't have a function to draw oval arcs, so we must * draw an arc and stretch it by scaling different x and y values */ cairo_new_path(cairoTarget); if (image->aperture[net->aperture]->type == GERBV_APTYPE_RECTANGLE) { cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_SQUARE); } else { cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); } cairo_save (cairoTarget); cairo_translate(cairoTarget, cp_x, cp_y); cairo_scale (cairoTarget, net->cirseg->width, net->cirseg->height); if (net->cirseg->angle2 > net->cirseg->angle1) { cairo_arc (cairoTarget, 0.0, 0.0, 0.5, DEG2RAD(net->cirseg->angle1), DEG2RAD(net->cirseg->angle2)); } else { cairo_arc_negative (cairoTarget, 0.0, 0.0, 0.5, DEG2RAD(net->cirseg->angle1), DEG2RAD(net->cirseg->angle2)); } cairo_restore (cairoTarget); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; default : GERB_COMPILE_WARNING(_("Skipped interpolation type %d"), net->interpolation); break; } break; case GERBV_APERTURE_STATE_OFF : break; case GERBV_APERTURE_STATE_FLASH : p = image->aperture[net->aperture]->parameter; cairo_save (cairoTarget); draw_cairo_translate_adjust(cairoTarget, x2, y2, pixelOutput); switch (image->aperture[net->aperture]->type) { case GERBV_APTYPE_CIRCLE : if (renderInfo->show_cross_on_drill_holes && image->layertype == GERBV_LAYERTYPE_DRILL) { /* Draw center cross on drill hole */ cairo_set_line_width (cairoTarget, pixelWidth); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_SQUARE); r = p[0]/2.0 + hole_cross_inc_px*pixelWidth; draw_cairo_cross (cairoTarget, 0, 0, r); cairo_set_line_width (cairoTarget, lineWidth); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_ROUND); } gerbv_draw_circle(cairoTarget, p[0]); gerbv_draw_aperture_hole (cairoTarget, p[1], p[2], pixelOutput); break; case GERBV_APTYPE_RECTANGLE : // some CAD programs use very thin flashed rectangles to compose // logos/images, so we must make sure those display here displayPixel = pixelOutput; p0 = p[0]; p1 = p[1]; if (limitLineWidth && (p[0] < pixelWidth) && pixelOutput) { p0 = pixelWidth; displayPixel = FALSE; } if (limitLineWidth && (p[1] < pixelWidth) && pixelOutput) { p1 = pixelWidth; displayPixel = FALSE; } gerbv_draw_rectangle(cairoTarget, p0, p1, displayPixel); gerbv_draw_aperture_hole (cairoTarget, p[2], p[3], displayPixel); break; case GERBV_APTYPE_OVAL : gerbv_draw_oblong(cairoTarget, p[0], p[1]); gerbv_draw_aperture_hole (cairoTarget, p[2], p[3], pixelOutput); break; case GERBV_APTYPE_POLYGON : gerbv_draw_polygon(cairoTarget, p[0], p[1], p[2]); gerbv_draw_aperture_hole (cairoTarget, p[3], p[4], pixelOutput); break; case GERBV_APTYPE_MACRO : gerbv_draw_amacro(cairoTarget, drawOperatorClear, drawOperatorDark, image->aperture[net->aperture]->simplified, (gint)p[0], pixelWidth, drawMode, selectionInfo, image, net); break; default : GERB_MESSAGE(_("Unknown aperture type")); return 0; } /* and finally fill the path */ draw_fill (cairoTarget, drawMode, selectionInfo, image, net); cairo_restore (cairoTarget); break; default: GERB_MESSAGE(_("Unknown aperture state")); return 0; } } } } /* restore the initial two state saves (one for layer, one for netstate)*/ cairo_restore (cairoTarget); cairo_restore (cairoTarget); return 1; }
static int arrowdraw(struct objlist *obj, N_VALUE *inst, N_VALUE *rval, int argc, char **argv) { int GC, w, h, intp, i, j, num, close_path; struct narray *points; int *points2, *pdata; int x0, y0, x1, y1, type, stroke, fill, clip, zoom; if (_exeparent(obj, argv[1], inst, rval, argc, argv)) { return 1; } _getobj(obj, "GC", inst, &GC); if (GC < 0) { return 0; } _getobj(obj, "stroke", inst, &stroke); _getobj(obj, "fill", inst, &fill); if (fill == 0 && stroke == 0) { return 0; } _getobj(obj, "type", inst, &type); _getobj(obj, "clip", inst, &clip); _getobj(obj, "close_path", inst, &close_path); if (type == PATH_TYPE_CURVE) { _getobj(obj, "interpolation", inst, &intp); _getobj(obj, "_points", inst, &points); if (arraynum(points) == 0) { curve_expand_points(obj, inst, intp, points); } if (intp == INTERPOLATION_TYPE_SPLINE_CLOSE || intp == INTERPOLATION_TYPE_BSPLINE_CLOSE) { close_path = TRUE; } } else { _getobj(obj, "points", inst, &points); } num = arraynum(points) / 2; pdata = arraydata(points); points2 = g_malloc(sizeof(int) * num * 2); if (points2 == NULL) { return 1; } j = 0; x1 = y1 = 0; for (i = 0; i < num; i++) { x0 = pdata[2 * i]; y0 = pdata[2 * i + 1]; if (i == 0 || x0 != x1 || y0 != y1) { points2[2 * j] = x0; points2[2 * j + 1] = y0; j++; x1 = x0; y1 = y0; } } num = j; if (num < 2) { g_free(points2); return 0; } GRAregion(GC, &w, &h, &zoom); GRAview(GC, 0, 0, w * 10000.0 / zoom, h * 10000.0 / zoom, clip); if (fill) { draw_fill(obj, inst, GC, points2, num); } if (stroke) { draw_stroke(obj, inst, GC, points2, pdata, num, close_path); } g_free(points2); GRAaddlist(GC, obj, inst, argv[0], argv[1]); return 0; }
int gerbv_draw_amacro(cairo_t *cairoTarget, cairo_operator_t clearOperator, cairo_operator_t darkOperator, gerbv_simplified_amacro_t *s, gint usesClearPrimative, gdouble pixelWidth, enum draw_mode drawMode, gerbv_selection_info_t *selectionInfo, gerbv_image_t *image, struct gerbv_net *net) { int handled = 1; gerbv_simplified_amacro_t *ls = s; dprintf("Drawing simplified aperture macros:\n"); if (usesClearPrimative) cairo_push_group (cairoTarget); while (ls != NULL) { /* * This handles the exposure thing in the aperture macro * The exposure is always the first element on stack independent * of aperture macro. */ cairo_save (cairoTarget); cairo_new_path(cairoTarget); cairo_operator_t oldOperator = cairo_get_operator (cairoTarget); switch (ls->type) { case GERBV_APTYPE_MACRO_CIRCLE: if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[CIRCLE_EXPOSURE])) { cairo_translate (cairoTarget, ls->parameter[CIRCLE_CENTER_X], ls->parameter[CIRCLE_CENTER_Y]); gerbv_draw_circle (cairoTarget, ls->parameter[CIRCLE_DIAMETER]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; case GERBV_APTYPE_MACRO_OUTLINE: { int pointCounter,numberOfPoints; /* Number of points parameter seems to not include the start point, * so we add one to include the start point. */ numberOfPoints = (int) ls->parameter[OUTLINE_NUMBER_OF_POINTS] + 1; if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[OUTLINE_EXPOSURE])) { cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[2*(numberOfPoints - 1) + OUTLINE_ROTATION])); cairo_move_to (cairoTarget, ls->parameter[OUTLINE_FIRST_X], ls->parameter[OUTLINE_FIRST_Y]); for (pointCounter=0; pointCounter < numberOfPoints; pointCounter++) { cairo_line_to (cairoTarget, ls->parameter[pointCounter * 2 + OUTLINE_FIRST_X], ls->parameter[pointCounter * 2 + OUTLINE_FIRST_Y]); } /* although the gerber specs allow for an open outline, I interpret it to mean the outline should be closed by the rendering softare automatically, since there is no dimension for line thickness. */ draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; } case GERBV_APTYPE_MACRO_POLYGON: if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[POLYGON_EXPOSURE])) { cairo_translate (cairoTarget, ls->parameter[POLYGON_CENTER_X], ls->parameter[POLYGON_CENTER_Y]); gerbv_draw_polygon(cairoTarget, ls->parameter[POLYGON_DIAMETER], ls->parameter[POLYGON_NUMBER_OF_POINTS], ls->parameter[POLYGON_ROTATION]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; case GERBV_APTYPE_MACRO_MOIRE: { gdouble diameter, diameterDifference; int circleIndex; cairo_translate (cairoTarget, ls->parameter[MOIRE_CENTER_X], ls->parameter[MOIRE_CENTER_Y]); cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[MOIRE_ROTATION])); diameter = ls->parameter[MOIRE_OUTSIDE_DIAMETER] - ls->parameter[MOIRE_CIRCLE_THICKNESS]; diameterDifference = 2*(ls->parameter[MOIRE_GAP_WIDTH] + ls->parameter[MOIRE_CIRCLE_THICKNESS]); cairo_set_line_width (cairoTarget, ls->parameter[MOIRE_CIRCLE_THICKNESS]); for (circleIndex = 0; circleIndex < (int)ls->parameter[MOIRE_NUMBER_OF_CIRCLES]; circleIndex++) { gdouble currentDiameter = diameter - diameterDifference * (float) circleIndex; if (currentDiameter >= 0) { gerbv_draw_circle (cairoTarget, currentDiameter); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); } } gdouble crosshairRadius = ls->parameter[MOIRE_CROSSHAIR_LENGTH] / 2.0; cairo_set_line_width (cairoTarget, ls->parameter[MOIRE_CROSSHAIR_THICKNESS]); cairo_move_to (cairoTarget, -crosshairRadius, 0); cairo_line_to (cairoTarget, crosshairRadius, 0); cairo_move_to (cairoTarget, 0, -crosshairRadius); cairo_line_to (cairoTarget, 0, crosshairRadius); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); break; } case GERBV_APTYPE_MACRO_THERMAL: { gint i; gdouble startAngle1, startAngle2, endAngle1, endAngle2; cairo_translate (cairoTarget, ls->parameter[THERMAL_CENTER_X], ls->parameter[THERMAL_CENTER_Y]); cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[THERMAL_ROTATION])); startAngle1 = asin (ls->parameter[THERMAL_CROSSHAIR_THICKNESS]/ls->parameter[THERMAL_INSIDE_DIAMETER]); endAngle1 = M_PI_2 - startAngle1; endAngle2 = asin (ls->parameter[THERMAL_CROSSHAIR_THICKNESS]/ls->parameter[THERMAL_OUTSIDE_DIAMETER]); startAngle2 = M_PI_2 - endAngle2; for (i = 0; i < 4; i++) { cairo_arc (cairoTarget, 0, 0, ls->parameter[THERMAL_INSIDE_DIAMETER]/2.0, startAngle1, endAngle1); cairo_arc_negative (cairoTarget, 0, 0, ls->parameter[THERMAL_OUTSIDE_DIAMETER]/2.0, startAngle2, endAngle2); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); cairo_rotate (cairoTarget, M_PI_2); } break; } case GERBV_APTYPE_MACRO_LINE20: if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[LINE20_EXPOSURE])) { gdouble cParameter = ls->parameter[LINE20_LINE_WIDTH]; if (cParameter < pixelWidth) cParameter = pixelWidth; cairo_set_line_width (cairoTarget, cParameter); cairo_set_line_cap (cairoTarget, CAIRO_LINE_CAP_BUTT); cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[LINE20_ROTATION])); cairo_move_to (cairoTarget, ls->parameter[LINE20_START_X], ls->parameter[LINE20_START_Y]); cairo_line_to (cairoTarget, ls->parameter[LINE20_END_X], ls->parameter[LINE20_END_Y]); draw_stroke (cairoTarget, drawMode, selectionInfo, image, net); } break; case GERBV_APTYPE_MACRO_LINE21: { gdouble halfWidth, halfHeight; if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[LINE21_EXPOSURE])) { halfWidth = ls->parameter[LINE21_WIDTH] / 2.0; halfHeight = ls->parameter[LINE21_HEIGHT] / 2.0; if (halfWidth < pixelWidth) halfWidth = pixelWidth; if (halfHeight < pixelWidth) halfHeight = pixelWidth; cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[LINE21_ROTATION])); cairo_translate (cairoTarget, ls->parameter[LINE21_CENTER_X], ls->parameter[LINE21_CENTER_Y]); cairo_rectangle (cairoTarget, -halfWidth, -halfHeight, ls->parameter[LINE21_WIDTH], ls->parameter[LINE21_HEIGHT]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; } case GERBV_APTYPE_MACRO_LINE22: { gdouble halfWidth, halfHeight; if (draw_update_macro_exposure (cairoTarget, clearOperator, darkOperator, ls->parameter[LINE22_EXPOSURE])) { halfWidth = ls->parameter[LINE22_WIDTH] / 2.0; halfHeight = ls->parameter[LINE22_HEIGHT] / 2.0; if (halfWidth < pixelWidth) halfWidth = pixelWidth; if (halfHeight < pixelWidth) halfHeight = pixelWidth; cairo_rotate (cairoTarget, DEG2RAD(ls->parameter[LINE22_ROTATION])); cairo_translate (cairoTarget, ls->parameter[LINE22_LOWER_LEFT_X], ls->parameter[LINE22_LOWER_LEFT_Y]); cairo_rectangle (cairoTarget, 0, 0, ls->parameter[LINE22_WIDTH], ls->parameter[LINE22_HEIGHT]); draw_fill (cairoTarget, drawMode, selectionInfo, image, net); } break; } default: handled = 0; } cairo_set_operator (cairoTarget, oldOperator); cairo_restore (cairoTarget); ls = ls->next; } if (usesClearPrimative) { cairo_pop_group_to_source (cairoTarget); cairo_paint (cairoTarget); } return handled; }
int main(int argc, char **argv) { fz_document *doc = NULL; int c; fz_context *ctx; fz_var(doc); yctx = yutani_init(); char * _width = getenv("WIDTH"); char * _height = getenv("HEIGHT"); width = _width ? atoi(_width) : 512; height = _height ? atoi(_height) : 512; init_decorations(); window = yutani_window_create(yctx, width + decor_width(), height + decor_height()); yutani_window_move(yctx, window, 50, 50); yutani_window_advertise_icon(yctx, window, "PDF Viewer", "pdfviewer"); gfx_ctx = init_graphics_yutani(window); draw_fill(gfx_ctx,rgb(0,0,0)); render_decorations(window, gfx_ctx, "PDFViewer - Loading..."); while ((c = fz_getopt(argc, argv, "wf")) != -1) { switch (c) { case 'f': fit = 1; break; } } ctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT); if (!ctx) { fprintf(stderr, "Could not initialize fitz context.\n"); exit(1); } fz_set_aa_level(ctx, alphabits); colorspace = fz_device_rgb; fz_try(ctx) { while (fz_optind < argc) { fz_try(ctx) { filename = argv[fz_optind++]; files++; fz_try(ctx) { doc = fz_open_document(ctx, filename); } fz_catch(ctx) { fz_throw(ctx, "cannot open document: %s", filename); } if (fz_optind == argc || !isrange(argv[fz_optind])) drawrange(ctx, doc, "1-"); if (fz_optind < argc && isrange(argv[fz_optind])) drawrange(ctx, doc, argv[fz_optind++]); fz_close_document(doc); doc = NULL; } fz_catch(ctx) { if (!ignore_errors) fz_rethrow(ctx); fz_close_document(doc); doc = NULL; fz_warn(ctx, "ignoring error in '%s'", filename); } } } fz_catch(ctx) { fz_close_document(doc); fprintf(stderr, "error: cannot draw '%s'\n", filename); errored = 1; } fz_free_context(ctx); return (errored != 0); }
/** \brief Fill nth element of the vertex buffer. * * \param idx Vertex index. * \param pp Coordinates. */ inline void draw_fill(unsigned idx, const math::vec2f &pp) { draw_fill(idx, pp.x(), pp.y()); }
void toggle_decorations(void) { toggle_decors = !toggle_decors; draw_fill(gfx_ctx, rgb(0,0,0)); recalc_size(window->width, window->height); }
void onDrawContent(SkCanvas* canvas) override { SkPath path; SkScalar width = fWidth; if (fCubicButton.fEnabled) { path.moveTo(fPts[0]); path.cubicTo(fPts[1], fPts[2], fPts[3]); setForGeometry(); draw_stroke(canvas, path, width, 950, false); } if (fConicButton.fEnabled) { path.moveTo(fPts[4]); path.conicTo(fPts[5], fPts[6], fWeight); setForGeometry(); draw_stroke(canvas, path, width, 950, false); } if (fQuadButton.fEnabled) { path.reset(); path.moveTo(fPts[7]); path.quadTo(fPts[8], fPts[9]); setForGeometry(); draw_stroke(canvas, path, width, 950, false); } if (fRRectButton.fEnabled) { SkScalar rad = 32; SkRect r; r.set(&fPts[10], 2); path.reset(); SkRRect rr; rr.setRectXY(r, rad, rad); path.addRRect(rr); setForGeometry(); draw_stroke(canvas, path, width, 950, false); path.reset(); SkRRect rr2; rr.inset(width/2, width/2, &rr2); path.addRRect(rr2, SkPath::kCCW_Direction); rr.inset(-width/2, -width/2, &rr2); path.addRRect(rr2, SkPath::kCW_Direction); SkPaint paint; paint.setAntiAlias(true); paint.setColor(0x40FF8844); canvas->drawPath(path, paint); } if (fCircleButton.fEnabled) { path.reset(); SkRect r; r.set(&fPts[12], 2); path.addOval(r); setForGeometry(); if (fCircleButton.fFill) { draw_fill(canvas, r, width); } else { draw_stroke(canvas, path, width, 950, false); } } if (fTextButton.fEnabled) { path.reset(); SkPaint paint; paint.setAntiAlias(true); paint.setTextSize(fTextSize); paint.getTextPath(fText.c_str(), fText.size(), 0, fTextSize, &path); setForText(); draw_stroke(canvas, path, width * fWidthScale / fTextSize, fTextSize, true); } if (fAnimate) { fWidth += fDWidth; if (fDWidth > 0 && fWidth > kWidthMax) { fDWidth = -fDWidth; } else if (fDWidth < 0 && fWidth < kWidthMin) { fDWidth = -fDWidth; } } setAsNeeded(); if (fConicButton.fEnabled) { draw_control(canvas, fWeightControl, fWeight, 0, 5, "weight"); } #ifdef SK_DEBUG draw_control(canvas, fErrorControl, gDebugStrokerError, kStrokerErrorMin, kStrokerErrorMax, "error"); #endif draw_control(canvas, fWidthControl, fWidth * fWidthScale, kWidthMin * fWidthScale, kWidthMax * fWidthScale, "width"); draw_button(canvas, fQuadButton); draw_button(canvas, fCubicButton); draw_button(canvas, fConicButton); draw_button(canvas, fRRectButton); draw_button(canvas, fCircleButton); draw_button(canvas, fTextButton); this->inval(NULL); }
int main (int argc, char ** argv) { setup_windowing(); int width = wins_globals->server_width; int height = wins_globals->server_height; win_width = width; win_height = height; event_pipe = syscall_mkpipe(); /* Do something with a window */ window_t * wina = window_create(0,0, width, height); assert(wina); window_reorder (wina, 0); ctx = init_graphics_window_double_buffer(wina); draw_fill(ctx, rgb(127,127,127)); flip(ctx); syscall_signal(2, sig_int); char f_name[512]; sprintf(f_name, "%s/.wallpaper.png", getenv("HOME")); FILE * f = fopen(f_name, "r"); if (f) { fclose(f); init_sprite_png(0, f_name); } else { init_sprite_png(0, "/usr/share/wallpaper.png"); } float x = (float)width / (float)sprites[0]->width; float y = (float)height / (float)sprites[0]->height; int nh = (int)(x * (float)sprites[0]->height); int nw = (int)(y * (float)sprites[0]->width);; if (nw > width) { draw_sprite_scaled(ctx, sprites[0], (width - nw) / 2, 0, nw, height); } else { draw_sprite_scaled(ctx, sprites[0], 0, (height - nh) / 2, width, nh); } flip(ctx); init_shmemfonts(); /* Load Application Shortcuts */ uint32_t i = 0; while (1) { if (!applications[i].icon) { break; } printf("Loading png %s\n", applications[i].icon); init_sprite_png(i+1, applications[i].icon); draw_sprite(ctx, sprites[i+1], ICON_X, ICON_TOP_Y + ICON_SPACING_Y * i); int str_w = draw_string_width(applications[i].title) / 2; int str_x = ICON_X + ICON_WIDTH / 2 - str_w; int str_y = ICON_TOP_Y + ICON_SPACING_Y * i + ICON_WIDTH + 14; draw_string_shadow(ctx, str_x, str_y, rgb(255,255,255), applications[i].title, rgb(0,0,0), 2, 1, 1, 3.0); ++i; } flip(ctx); /* Enable mouse */ win_use_threaded_handler(); mouse_action_callback = wallpaper_check_click; while (_continue) { char buf; read(event_pipe, &buf, 1); if (next_run_activate) { launch_application(next_run_activate); next_run_activate = NULL; } } teardown_windowing(); return 0; }
int main (int argc, char ** argv) { init_shmemfonts(); yutani_t * y = yutani_init(); if (!y) { fprintf(stderr, "[glogin] Connection to server failed.\n"); return 1; } /* Load config */ { confreader_t * conf = confreader_load("/etc/glogin.conf"); LOGO_FINAL_OFFSET = confreader_intd(conf, "style", "logo_padding", LOGO_FINAL_OFFSET); BOX_WIDTH = confreader_intd(conf, "style", "box_width", BOX_WIDTH); BOX_HEIGHT = confreader_intd(conf, "style", "box_height", BOX_HEIGHT); BOX_ROUNDNESS = confreader_intd(conf, "style", "box_roundness", BOX_ROUNDNESS); CENTER_BOX_X = confreader_intd(conf, "style", "center_box_x", CENTER_BOX_X); CENTER_BOX_Y = confreader_intd(conf, "style", "center_box_y", CENTER_BOX_Y); BOX_LEFT = confreader_intd(conf, "style", "box_left", BOX_LEFT); BOX_RIGHT = confreader_intd(conf, "style", "box_right", BOX_RIGHT); BOX_TOP = confreader_intd(conf, "style", "box_top", BOX_TOP); BOX_BOTTOM = confreader_intd(conf, "style", "box_bottom", BOX_BOTTOM); BOX_COLOR_R = confreader_intd(conf, "style", "box_color_r", BOX_COLOR_R); BOX_COLOR_G = confreader_intd(conf, "style", "box_color_g", BOX_COLOR_G); BOX_COLOR_B = confreader_intd(conf, "style", "box_color_b", BOX_COLOR_B); BOX_COLOR_A = confreader_intd(conf, "style", "box_color_a", BOX_COLOR_A); WALLPAPER = confreader_getd(conf, "image", "wallpaper", WALLPAPER); LOGO = confreader_getd(conf, "image", "logo", LOGO); confreader_free(conf); TRACE("Loading complete"); } TRACE("Loading logo..."); load_sprite_png(&logo, LOGO); TRACE("... done."); /* Generate surface for background */ sprite_t * bg_sprite; int width = y->display_width; int height = y->display_height; int skip_animation = 0; /* Do something with a window */ TRACE("Connecting to window server..."); yutani_window_t * wina = yutani_window_create(y, width, height); assert(wina); yutani_set_stack(y, wina, 0); ctx = init_graphics_yutani_double_buffer(wina); draw_fill(ctx, rgba(0,0,0,255)); yutani_flip(y, wina); TRACE("... done."); redo_everything: win_width = width; win_height = height; cairo_surface_t * cs = cairo_image_surface_create_for_data((void*)ctx->backbuffer, CAIRO_FORMAT_ARGB32, ctx->width, ctx->height, cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, ctx->width)); cairo_t * cr = cairo_create(cs); TRACE("Loading wallpaper..."); { sprite_t * wallpaper = malloc(sizeof(sprite_t)); load_sprite_png(wallpaper, WALLPAPER); float x = (float)width / (float)wallpaper->width; float y = (float)height / (float)wallpaper->height; int nh = (int)(x * (float)wallpaper->height); int nw = (int)(y * (float)wallpaper->width);; bg_sprite = create_sprite(width, height, ALPHA_OPAQUE); gfx_context_t * bg = init_graphics_sprite(bg_sprite); if (nw > width) { draw_sprite_scaled(bg, wallpaper, (width - nw) / 2, 0, nw, height); } else { draw_sprite_scaled(bg, wallpaper, 0, (height - nh) / 2, width, nh); } /* Three box blurs = good enough approximation of a guassian, but faster*/ blur_context_box(bg, 20); blur_context_box(bg, 20); blur_context_box(bg, 20); free(bg); free(wallpaper); } TRACE("... done."); while (1) { yutani_set_stack(y, wina, 0); yutani_focus_window(y, wina->wid); draw_fill(ctx, rgb(0,0,0)); draw_sprite(ctx, bg_sprite, center_x(width), center_y(height)); flip(ctx); yutani_flip(y, wina); char * foo = malloc(sizeof(uint32_t) * width * height); memcpy(foo, ctx->backbuffer, sizeof(uint32_t) * width * height); TRACE("Begin animation."); if (!skip_animation) { struct timeval start; gettimeofday(&start, NULL); while (1) { uint32_t tick; struct timeval t; gettimeofday(&t, NULL); uint32_t sec_diff = t.tv_sec - start.tv_sec; uint32_t usec_diff = t.tv_usec - start.tv_usec; if (t.tv_usec < start.tv_usec) { sec_diff -= 1; usec_diff = (1000000 + t.tv_usec) - start.tv_usec; } tick = (uint32_t)(sec_diff * 1000 + usec_diff / 1000); int i = (float)LOGO_FINAL_OFFSET * (float)tick / 700.0f; if (i >= LOGO_FINAL_OFFSET) break; memcpy(ctx->backbuffer, foo, sizeof(uint32_t) * width * height); draw_sprite(ctx, &logo, center_x(logo.width), center_y(logo.height) - i); flip(ctx); yutani_flip_region(y, wina, center_x(logo.width), center_y(logo.height) - i, logo.width, logo.height + 5); usleep(10000); } } TRACE("End animation."); skip_animation = 0; size_t buf_size = wina->width * wina->height * sizeof(uint32_t); char * buf = malloc(buf_size); uint32_t i = 0; uint32_t black = rgb(0,0,0); uint32_t white = rgb(255,255,255); int x_offset = 65; int y_offset = 64; int fuzz = 3; char username[INPUT_SIZE] = {0}; char password[INPUT_SIZE] = {0}; char hostname[512]; // we do it here to calculate the final string position get_updated_hostname_with_time_info(hostname); char kernel_v[512]; { struct utsname u; uname(&u); /* UTF-8 Strings FTW! */ uint8_t * os_name_ = "とあるOS"; uint32_t l = snprintf(kernel_v, 512, "%s %s", os_name_, u.release); } uid = 0; int box_x, box_y; if (CENTER_BOX_X) { box_x = center_x(BOX_WIDTH); } else if (BOX_LEFT == -1) { box_x = win_width - BOX_RIGHT - BOX_WIDTH; } else { box_x = BOX_LEFT; } if (CENTER_BOX_Y) { box_y = center_y(0) + 8; } else if (BOX_TOP == -1) { box_y = win_width - BOX_BOTTOM - BOX_HEIGHT; } else { box_y = BOX_TOP; } int focus = 0; set_font_size(11); int hostname_label_left = width - 10 - draw_string_width(hostname); int kernel_v_label_left = 10; struct text_box username_box = { (BOX_WIDTH - 170) / 2, 30, 170, 20, rgb(0,0,0), NULL, 0, 0, 0, username, "Username" }; struct text_box password_box = { (BOX_WIDTH - 170) / 2, 58, 170, 20, rgb(0,0,0), NULL, 0, 1, 0, password, "Password" }; struct login_container lc = { box_x, box_y, BOX_WIDTH, BOX_HEIGHT, &username_box, &password_box, 0 }; username_box.parent = &lc; password_box.parent = &lc; while (1) { focus = 0; memset(username, 0x0, INPUT_SIZE); memset(password, 0x0, INPUT_SIZE); while (1) { // update time info get_updated_hostname_with_time_info(hostname); memcpy(ctx->backbuffer, foo, sizeof(uint32_t) * width * height); draw_sprite(ctx, &logo, center_x(logo.width), center_y(logo.height) - LOGO_FINAL_OFFSET); set_font_size(11); draw_string_shadow(ctx, hostname_label_left, height - 12, white, hostname, rgb(0,0,0), 2, 1, 1, 3.0); draw_string_shadow(ctx, kernel_v_label_left, height - 12, white, kernel_v, rgb(0,0,0), 2, 1, 1, 3.0); if (focus == USERNAME_BOX) { username_box.is_focused = 1; password_box.is_focused = 0; } else if (focus == PASSWORD_BOX) { username_box.is_focused = 0; password_box.is_focused = 1; } else { username_box.is_focused = 0; password_box.is_focused = 0; } draw_login_container(cr, &lc); flip(ctx); yutani_flip(y, wina); struct yutani_msg_key_event kbd; struct yutani_msg_window_mouse_event mou; int msg_type = 0; collect_events: do { yutani_msg_t * msg = yutani_poll(y); switch (msg->type) { case YUTANI_MSG_KEY_EVENT: { struct yutani_msg_key_event * ke = (void*)msg->data; if (ke->event.action == KEY_ACTION_DOWN) { memcpy(&kbd, ke, sizeof(struct yutani_msg_key_event)); msg_type = 1; } } break; case YUTANI_MSG_WINDOW_MOUSE_EVENT: { struct yutani_msg_window_mouse_event * me = (void*)msg->data; memcpy(&mou, me, sizeof(struct yutani_msg_mouse_event)); msg_type = 2; } break; case YUTANI_MSG_WELCOME: { struct yutani_msg_welcome * mw = (void*)msg->data; yutani_window_resize(y, wina, mw->display_width, mw->display_height); } break; case YUTANI_MSG_RESIZE_OFFER: { struct yutani_msg_window_resize * wr = (void*)msg->data; width = wr->width; height = wr->height; yutani_window_resize_accept(y, wina, width, height); reinit_graphics_yutani(ctx, wina); yutani_window_resize_done(y, wina); sprite_free(bg_sprite); cairo_destroy(cr); cairo_surface_destroy(cs); skip_animation = 1; goto redo_everything; } break; } free(msg); } while (!msg_type); if (msg_type == 1) { if (kbd.event.keycode == '\n') { if (focus == USERNAME_BOX) { focus = PASSWORD_BOX; continue; } else if (focus == PASSWORD_BOX) { break; } else { focus = USERNAME_BOX; continue; } } if (kbd.event.keycode == '\t') { if (focus == USERNAME_BOX) { focus = PASSWORD_BOX; } else { focus = USERNAME_BOX; } continue; } if (kbd.event.key) { if (!focus) { focus = USERNAME_BOX; } if (focus == USERNAME_BOX) { buffer_put(username, kbd.event.key); } else if (focus == PASSWORD_BOX) { buffer_put(password, kbd.event.key); } } } else if (msg_type == 2) { if ((mou.command == YUTANI_MOUSE_EVENT_DOWN && mou.buttons & YUTANI_MOUSE_BUTTON_LEFT) || (mou.command == YUTANI_MOUSE_EVENT_CLICK)) { /* Determine if we were inside of a text box */ if (mou.new_x >= lc.x + username_box.x && mou.new_x <= lc.x + username_box.x + username_box.width && mou.new_y >= lc.y + username_box.y && mou.new_y <= lc.y + username_box.y + username_box.height) { /* Ensure this box is focused. */ focus = USERNAME_BOX; continue; } else if (mou.new_x >= lc.x + password_box.x && mou.new_x <= lc.x + password_box.x + password_box.width && mou.new_y >= lc.y + password_box.y && mou.new_y <= lc.y + password_box.y + password_box.height) { /* Ensure this box is focused. */ focus = PASSWORD_BOX; continue; } else { focus = 0; continue; } } else { goto collect_events; } } } uid = toaru_auth_check_pass(username, password); if (uid >= 0) { break; } lc.show_error = 1; } memcpy(ctx->backbuffer, foo, sizeof(uint32_t) * width * height); flip(ctx); yutani_flip(y, wina); syscall_yield(); pid_t _session_pid = fork(); if (!_session_pid) { setuid(uid); toaru_auth_set_vars(); char * args[] = {"/bin/gsession", NULL}; execvp(args[0], args); } free(foo); free(buf); waitpid(_session_pid, NULL, 0); } yutani_close(y, wina); return 0; }
int main (int argc, char ** argv) { yctx = yutani_init(); win_width = 100; win_height = 100; init_decorations(); off_x = decor_left_width; off_y = decor_top_height; /* Do something with a window */ wina = yutani_window_create(yctx, win_width + decor_width(), win_height + decor_height()); yutani_window_move(yctx, wina, 300, 300); ctx = init_graphics_yutani_double_buffer(wina); draw_fill(ctx, rgb(0,0,0)); redraw_borders(); flip(ctx); yutani_flip(yctx, wina); yutani_window_advertise(yctx, wina, "Graphics Test"); pthread_t thread; pthread_create(&thread, NULL, draw_thread, NULL); while (!should_exit) { yutani_msg_t * m = yutani_poll(yctx); if (m) { switch (m->type) { case YUTANI_MSG_KEY_EVENT: { struct yutani_msg_key_event * ke = (void*)m->data; if (ke->event.action == KEY_ACTION_DOWN && ke->event.keycode == 'q') { should_exit = 1; } } break; case YUTANI_MSG_WINDOW_FOCUS_CHANGE: { struct yutani_msg_window_focus_change * wf = (void*)m->data; yutani_window_t * win = hashmap_get(yctx->windows, (void*)wf->wid); if (win) { win->focused = wf->focused; } } break; case YUTANI_MSG_SESSION_END: should_exit = 1; break; case YUTANI_MSG_RESIZE_OFFER: { struct yutani_msg_window_resize * wr = (void*)m->data; spin_lock(&draw_lock); resize_finish(wr->width, wr->height); spin_unlock(&draw_lock); } break; case YUTANI_MSG_WINDOW_MOUSE_EVENT: if (decor_handle_event(yctx, m) == DECOR_CLOSE) { should_exit = 1; } break; default: break; } free(m); } } yutani_close(yctx, wina); return 0; }
int main(int argc, char** argv) { /* default values */ char * filename = "teapot.obj"; char * diffuse = "wood.rgba"; char * sphere = "nvidia.rgba"; int c, index; chdir("/opt/examples"); /* Parse some command-line arguments */ while ((c = getopt(argc, argv, "d:e:h:s:")) != -1) { switch (c) { case 'd': diffuse = optarg; break; case 'e': sphere = optarg; break; case 's': /* Set scale */ scale = atof(optarg); break; case 'h': cam_offset = atof(optarg); break; default: /* Uh, that's it for -args */ printf("Unrecognized argument!\n"); break; } } /* Get an optional filename from the last non-- parameter */ for (index = optind; index < argc; ++index) { filename = argv[index]; } printf("Press q to exit.\n"); yctx = yutani_init(); wina = yutani_window_create(yctx, 500, 500); yutani_window_move(yctx, wina, 100, 100); ctx = init_graphics_yutani_double_buffer(wina); draw_fill(ctx, rgb(0,0,0)); yutani_window_update_shape(yctx, wina, YUTANI_SHAPE_THRESHOLD_HALF); yutani_window_advertise_icon(yctx, wina, "GL Teapot", "teapot"); OSMesaContext gl_ctx = OSMesaCreateContext(OSMESA_BGRA, NULL); if (resize(ctx, gl_ctx)) { fprintf(stderr, "%s: Something bad happened.\n", argv[0]); goto finish; } /* Load up the file, set everything else up */ init (filename, diffuse, sphere); /* XXX add a method to query if there are available packets in pex */ pthread_t thread; pthread_create(&thread, NULL, draw_thread, NULL); while (!quit) { yutani_msg_t * m = yutani_poll(yctx); if (m) { switch (m->type) { case YUTANI_MSG_KEY_EVENT: { struct yutani_msg_key_event * ke = (void*)m->data; if (ke->event.action == KEY_ACTION_DOWN) { keyboard(ke->event.keycode, 0, 0); } } break; case YUTANI_MSG_WINDOW_MOUSE_EVENT: { struct yutani_msg_window_mouse_event * me = (void*)m->data; if (me->command == YUTANI_MOUSE_EVENT_DOWN && me->buttons & YUTANI_MOUSE_BUTTON_LEFT) { yutani_window_drag_start(yctx, wina); } } break; case YUTANI_MSG_SESSION_END: quit = 1; break; default: break; } free(m); } } finish: OSMesaDestroyContext(gl_ctx); yutani_close(yctx, wina); return 0; }
int main (int argc, char ** argv) { init_sprite_png(0, "/usr/share/logo_login.png"); init_shmemfonts(); while (1) { syscall_print("Setup...\n"); setup_windowing(); int width = wins_globals->server_width; int height = wins_globals->server_height; win_width = width; win_height = height; /* Do something with a window */ window_t * wina = window_create(0,0, width, height); assert(wina); window_reorder (wina, 0); /* Disables movement */ ctx = init_graphics_window_double_buffer(wina); for (int i = 0; i < LOGO_FINAL_OFFSET; ++i) { draw_fill(ctx, rgb(39,55,113)); draw_sprite(ctx, sprites[0], center_x(sprites[0]->width), center_y(sprites[0]->height) - i); flip(ctx); } size_t buf_size = wina->width * wina->height * sizeof(uint32_t); char * buf = malloc(buf_size); uint32_t i = 0; uint32_t black = rgb(0,0,0); uint32_t white = rgb(255,255,255); uint32_t red = rgb(240, 20, 20); int x_offset = 65; int y_offset = 64; int fuzz = 3; char username[INPUT_SIZE] = {0}; char password[INPUT_SIZE] = {0}; char hostname[512]; { char _hostname[256]; syscall_gethostname(_hostname); struct tm * timeinfo; struct timeval now; syscall_gettimeofday(&now, NULL); //time(NULL); timeinfo = localtime((time_t *)&now.tv_sec); char _date[256]; strftime(_date, 256, "%a %B %d %Y", timeinfo); sprintf(hostname, "%s // %s", _hostname, _date); } char kernel_v[512]; { struct utsname u; uname(&u); /* UTF-8 Strings FTW! */ uint8_t * os_name_ = "PonyOS"; uint32_t l = snprintf(kernel_v, 512, "%s %s", os_name_, u.release); } uid = 0; #define BOX_WIDTH 272 #define BOX_HEIGHT 104 #define USERNAME_BOX 1 #define PASSWORD_BOX 2 #define EXTRA_TEXT_OFFSET 12 #define TEXTBOX_INTERIOR_LEFT 4 #define LEFT_OFFSET 80 int box_x = center_x(BOX_WIDTH); int box_y = center_y(0) + 8; int focus = USERNAME_BOX; set_font_size(11); int username_label_left = LEFT_OFFSET - 2 - draw_string_width("Username:"******"Password:"******""); for (int i = 0; i < strlen(password); ++i) { strcat(password_circles, "●"); } /* Redraw the background */ draw_fill(ctx, rgb(39,55,113)); draw_sprite(ctx, sprites[0], center_x(sprites[0]->width), center_y(sprites[0]->height) - LOGO_FINAL_OFFSET); draw_string(ctx, hostname_label_left, height - 12, white, hostname); draw_string(ctx, kernel_v_label_left, height - 12, white, kernel_v); /* Draw backdrops */ draw_box(ctx, box_x, box_y, BOX_WIDTH, BOX_HEIGHT, rgb(180,124,205)); draw_box(ctx, box_x + LEFT_OFFSET, box_y + 32, 168, 16, rgb(255,255,255)); draw_box(ctx, box_x + LEFT_OFFSET, box_y + 56, 168, 16, rgb(255,255,255)); /* Draw labels */ draw_string(ctx, box_x + username_label_left, box_y + 32 + EXTRA_TEXT_OFFSET, white, "Username:"******"Password:"******"Incorrect username or password."; draw_string(ctx, box_x + (BOX_WIDTH - draw_string_width(error_message)) / 2, box_y + 8 + EXTRA_TEXT_OFFSET, red, error_message); } if (focus == USERNAME_BOX) { draw_box_border(ctx, box_x + LEFT_OFFSET, box_y + 32, 168, 16, rgb(229, 68, 138)); } else if (focus == PASSWORD_BOX) { draw_box_border(ctx, box_x + LEFT_OFFSET, box_y + 56, 168, 16, rgb(229, 68, 138)); } flip(ctx); w_keyboard_t * kbd = NULL; do { kbd = poll_keyboard(); } while (!kbd); if (kbd->key == '\n') { if (focus == USERNAME_BOX) { free(kbd); focus = PASSWORD_BOX; continue; } else if (focus == PASSWORD_BOX) { free(kbd); break; } } if (kbd->key == '\t') { if (focus == USERNAME_BOX) { focus = PASSWORD_BOX; } else if (focus == PASSWORD_BOX) { focus = USERNAME_BOX; } free(kbd); continue; } if (focus == USERNAME_BOX) { buffer_put(username, kbd->key); } else if (focus == PASSWORD_BOX) { buffer_put(password, kbd->key); } free(kbd); } uid = checkUserPass(username, password); if (uid >= 0) { break; } show_error = 1; } draw_fill(ctx, rgb(39,55,113)); draw_sprite(ctx, sprites[0], center_x(sprites[0]->width), center_y(sprites[0]->height) - LOGO_FINAL_OFFSET); flip(ctx); teardown_windowing(); pid_t _session_pid = fork(); if (!_session_pid) { setenv("PATH", "/usr/bin:/bin", 0); syscall_setuid(uid); char * args[] = {"/bin/gsession", NULL}; execvp(args[0], args); } free(buf); free(ctx->backbuffer); free(ctx); syscall_wait(_session_pid); } return 0; }
int main (int argc, char ** argv) { char * _windowed = getenv("DISPLAY"); if (_windowed) { setup_windowing(); resize_window_callback = resize_callback; win_width = 500; win_height = 500; init_decorations(); off_x = decor_left_width; off_y = decor_top_height; /* Do something with a window */ wina = window_create(300, 300, win_width + decor_width(), win_height + decor_height()); assert(wina); ctx = init_graphics_window_double_buffer(wina); } else { ctx = init_graphics_fullscreen_double_buffer(); win_width = ctx->width; win_height = ctx->height; off_x = 0; off_y = 0; } draw_fill(ctx, rgb(0,0,0)); redraw_borders(); flip(ctx); double time; /* Generate a palette */ uint32_t palette[256]; for (int x = 0; x < 256; ++x) { palette[x] = hsv_to_rgb(x,1.0,1.0); } while (1) { if (_windowed) { w_keyboard_t * kbd = poll_keyboard_async(); if (kbd) { char ch = kbd->key; free(kbd); if (ch == 'q') { goto done; break; } } } time += 1.0; int w = win_width; int h = win_height; for (int x = 0; x < win_width; ++x) { for (int y = 0; y < win_height; ++y) { double value = sin(dist(x + time, y, 128.0, 128.0) / 8.0) + sin(dist(x, y, 64.0, 64.0) / 8.0) + sin(dist(x, y + time / 7, 192.0, 64) / 7.0) + sin(dist(x, y, 192.0, 100.0) / 8.0); GFX(ctx, x + off_x, y + off_y) = palette[(int)((value + 4) * 32)]; } } redraw_borders(); flip(ctx); } done: if (_windowed) { teardown_windowing(); } return 0; }
int main (int argc, char ** argv) { yutani_t * yctx; yutani_window_t * wina; gfx_context_t * ctx; int should_exit = 0; int blur = 0; int stopped = 0; int left = 30; int top = 30; int width = 500; int height = 500; yctx = yutani_init(); wina = yutani_window_create(yctx, width, height); yutani_window_move(yctx, wina, left, top); ctx = init_graphics_yutani_double_buffer(wina); draw_fill(ctx, rgb(0,0,0)); yutani_window_update_shape(yctx, wina, YUTANI_SHAPE_THRESHOLD_HALF); yutani_window_advertise_icon(yctx, wina, "Mesa Gears", "gears"); OSMesaContext gl_ctx = OSMesaCreateContext(OSMESA_BGRA, NULL); if (resize(ctx, gl_ctx)) { fprintf(stderr, "%s: Something bad happened.\n", argv[0]); goto finish; } init(); while (!should_exit) { yutani_msg_t * m = yutani_poll_async(yctx); if (m) { switch (m->type) { case YUTANI_MSG_KEY_EVENT: { struct yutani_msg_key_event * ke = (void*)m->data; if (ke->event.action == KEY_ACTION_DOWN) { switch (ke->event.keycode) { case 'q': should_exit = 1; free(m); goto finish; case 'b': blur = (1-blur); break; case 's': stopped = (1-stopped); break; case KEY_ARROW_LEFT: view_roty += 5.0; break; case KEY_ARROW_RIGHT: view_roty -= 5.0; break; case KEY_ARROW_UP: view_rotx += 5.0; break; case KEY_ARROW_DOWN: view_rotx -= 5.0; break; default: break; } } } break; case YUTANI_MSG_WINDOW_MOUSE_EVENT: { struct yutani_msg_window_mouse_event * me = (void*)m->data; if (me->command == YUTANI_MOUSE_EVENT_DOWN && me->buttons & YUTANI_MOUSE_BUTTON_LEFT) { yutani_window_drag_start(yctx, wina); } } break; case YUTANI_MSG_SESSION_END: should_exit = 1; break; case YUTANI_MSG_RESIZE_OFFER: { struct yutani_msg_window_resize * wr = (void*)m->data; yutani_window_resize_accept(yctx, wina, wr->width, wr->height); reinit_graphics_yutani(ctx, wina); resize(ctx, gl_ctx); draw(); yutani_window_resize_done(yctx, wina); flip(ctx); yutani_flip(yctx, wina); yutani_window_update_shape(yctx, wina, 1); /* Reset statistics */ frames = 0; start_time = 0; } default: break; } free(m); } fps(); if (!stopped) { angle += 0.2; } draw(); if (blur) { blur_context_box(ctx, 20); } flip(ctx); yutani_flip(yctx, wina); syscall_yield(); } finish: OSMesaDestroyContext(gl_ctx); yutani_close(yctx, wina); return 0; }