void meta_frame_sync_to_window (MetaFrame *frame, int resize_gravity, gboolean need_move, gboolean need_resize) { if (!(need_move || need_resize)) { update_shape (frame); return; } meta_topic (META_DEBUG_GEOMETRY, "Syncing frame geometry %d,%d %dx%d (SE: %d,%d)\n", frame->rect.x, frame->rect.y, frame->rect.width, frame->rect.height, frame->rect.x + frame->rect.width, frame->rect.y + frame->rect.height); /* set bg to none to avoid flicker */ if (need_resize) { meta_ui_unflicker_frame_bg (frame->window->screen->ui, frame->xwindow, frame->rect.width, frame->rect.height); /* we need new shape if we're resized */ frame->need_reapply_frame_shape = TRUE; } /* Done before the window resize, because doing it before means * part of the window being resized becomes unshaped, which may * be sort of hard to see with bg = None. If we did it after * window resize, part of the window being resized would become * shaped, which might be more visible. */ update_shape (frame); meta_ui_move_resize_frame (frame->window->screen->ui, frame->xwindow, frame->rect.x, frame->rect.y, frame->rect.width, frame->rect.height); if (need_resize) { meta_ui_reset_frame_bg (frame->window->screen->ui, frame->xwindow); /* If we're interactively resizing the frame, repaint * it immediately so we don't start to lag. */ if (frame->window->display->grab_window == frame->window) meta_ui_repaint_frame (frame->window->screen->ui, frame->xwindow); } }
static void paint_window(GtkWidget *widget, WindowData *windata) { cairo_t *context; cairo_surface_t *surface; cairo_t *cr; if (windata->width == 0 || windata->height == 0) { windata->width = MAX (windata->win->allocation.width, 1); windata->height = MAX (windata->win->allocation.height, 1); } context = gdk_cairo_create (widget->window); cairo_set_operator (context, CAIRO_OPERATOR_SOURCE); surface = cairo_surface_create_similar (cairo_get_target (context), CAIRO_CONTENT_COLOR_ALPHA, widget->allocation.width, widget->allocation.height); cr = cairo_create (surface); fill_background (widget, windata, cr); cairo_destroy (cr); cairo_set_source_surface (context, surface, 0, 0); cairo_paint (context); cairo_surface_destroy (surface); cairo_destroy (context); update_shape (windata); }
void TimeFrontWindow::create_objects() { int x = 10, y = 10; BC_Title *title; add_subwindow(title = new BC_Title(x, y, _("Type:"))); add_subwindow(shape = new TimeFrontShape(plugin, this, x + title->get_w() + 10, y)); shape->create_objects(); y += 40; shape_x = x; shape_y = y; y += 140; add_subwindow(title = new BC_Title(x, y, _("Time range:"))); add_subwindow(frame_range = new TimeFrontFrameRange(plugin, x + title->get_w() + 10, y)); frame_range_x = x + frame_range->get_w() + 10; frame_range_y = y; y += 35; update_shape(); add_subwindow(invert = new TimeFrontInvert(plugin, x, y)); add_subwindow(show_grayscale = new TimeFrontShowGrayscale(plugin, x+ 100, y)); show_window(); flush(); }
static void timeline_frame_cb (GsdTimeline *timeline, gdouble progress, gpointer user_data) { GsdLocatePointerData *data = (GsdLocatePointerData *) user_data; GdkScreen *screen; gint cursor_x, cursor_y; if (gtk_widget_is_composited (data->widget)) { gdk_window_invalidate_rect (data->window, NULL, FALSE); data->progress = progress; } else if (progress >= data->progress + CIRCLES_PROGRESS_INTERVAL) { /* only invalidate window each circle interval */ update_shape (data); gdk_window_invalidate_rect (data->window, NULL, FALSE); data->progress += CIRCLES_PROGRESS_INTERVAL; } screen = gdk_drawable_get_screen (data->window); gdk_window_get_pointer (gdk_screen_get_root_window (screen), &cursor_x, &cursor_y, NULL); gdk_window_move (data->window, cursor_x - WINDOW_SIZE / 2, cursor_y - WINDOW_SIZE / 2); }
void composited_changed_handler (GtkWidget* window, gpointer data) { g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window)); update_shape (window, (gint) CORNER_RADIUS, (gint) BUBBLE_SHADOW_SIZE); }
ENTRYPOINT void draw_jigglypuff(ModeInfo *mi) { jigglystruct *js = &jss[MI_SCREEN(mi)]; glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(js->glx_context)); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0,0,-10); # ifdef HAVE_MOBILE /* Keep it the same relative size when rotated. */ { GLfloat h = MI_HEIGHT(mi) / (GLfloat) MI_WIDTH(mi); int o = (int) current_device_rotation(); if (o != 0 && o != 180 && o != -180) glScalef (1/h, 1/h, 1/h); } # endif glRotatef(js->angle, sin(js->axis), cos(js->axis), -sin(js->axis)); glTranslatef(0, 0, 5); if(!(js->button_down)) { if((js->angle += js->speed) >= 360.0f ) { js->angle -= 360.0f; } if((js->axis+=0.01f) >= 2*M_PI ) { js->axis -= 2*M_PI; } } gltrackball_rotate(js->trackball); if(js->color_style == COLOR_STYLE_CYCLE) { int i; vector_add(js->jiggly_color, js->color_dir, js->jiggly_color); for(i=0; i<3; i++) { if(js->jiggly_color[i] > 1.0 || js->jiggly_color[i] < 0.3) { js->color_dir[i] = (-js->color_dir[i]); js->jiggly_color[i] += js->color_dir[i]; } } glColor4fv(js->jiggly_color); } mi->polygon_count = jigglypuff_render(js); if(MI_IS_FPS(mi)) do_fps(mi); glFinish(); update_shape(js); glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi)); }
static void prefs_changed_callback (MetaPreference preference, gpointer data) { MetaFrame *frame = (MetaFrame *) data; switch (preference) { case META_PREF_COMPOSITING_MANAGER: frame->need_reapply_frame_shape = TRUE; update_shape (frame); break; case META_PREF_MOUSE_BUTTON_MODS: case META_PREF_FOCUS_MODE: case META_PREF_FOCUS_NEW_WINDOWS: case META_PREF_ATTACH_MODAL_DIALOGS: case META_PREF_RAISE_ON_CLICK: case META_PREF_ACTION_DOUBLE_CLICK_TITLEBAR: case META_PREF_ACTION_MIDDLE_CLICK_TITLEBAR: case META_PREF_ACTION_RIGHT_CLICK_TITLEBAR: case META_PREF_AUTO_RAISE: case META_PREF_AUTO_RAISE_DELAY: case META_PREF_THEME: case META_PREF_TITLEBAR_FONT: case META_PREF_NUM_WORKSPACES: case META_PREF_KEYBINDINGS: case META_PREF_DISABLE_WORKAROUNDS: case META_PREF_BUTTON_LAYOUT: case META_PREF_WORKSPACE_NAMES: case META_PREF_VISUAL_BELL: case META_PREF_AUDIBLE_BELL: case META_PREF_VISUAL_BELL_TYPE: case META_PREF_REDUCED_RESOURCES: case META_PREF_GNOME_ACCESSIBILITY: case META_PREF_GNOME_ANIMATIONS: case META_PREF_CURSOR_THEME: case META_PREF_CURSOR_SIZE: case META_PREF_RESIZE_WITH_RIGHT_BUTTON: case META_PREF_EDGE_TILING: case META_PREF_FORCE_FULLSCREEN: case META_PREF_PLACEMENT_MODE: case META_PREF_ALT_TAB_THUMBNAILS: break; default: break; } }
ENTRYPOINT void draw_jigglypuff(ModeInfo *mi) { jigglystruct *js = &jss[MI_SCREEN(mi)]; glXMakeCurrent(MI_DISPLAY(mi), MI_WINDOW(mi), *(js->glx_context)); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); glTranslatef(0,0,-10); glRotatef(js->angle, sin(js->axis), cos(js->axis), -sin(js->axis)); glTranslatef(0, 0, 5); if(!(js->button_down)) { if((js->angle += js->speed) >= 360.0f ) { js->angle -= 360.0f; } if((js->axis+=0.01f) >= 2*M_PI ) { js->axis -= 2*M_PI; } } /* Do it twice because we don't track the device's orientation. */ glRotatef( current_device_rotation(), 0, 0, 1); gltrackball_rotate(js->trackball); glRotatef(-current_device_rotation(), 0, 0, 1); if(js->color_style == COLOR_STYLE_CYCLE) { int i; vector_add(js->jiggly_color, js->color_dir, js->jiggly_color); for(i=0; i<3; i++) { if(js->jiggly_color[i] > 1.0 || js->jiggly_color[i] < 0.3) { js->color_dir[i] = (-js->color_dir[i]); js->jiggly_color[i] += js->color_dir[i]; } } glColor4fv(js->jiggly_color); } mi->polygon_count = jigglypuff_render(js); if(MI_IS_FPS(mi)) do_fps(mi); glFinish(); update_shape(js); glXSwapBuffers(MI_DISPLAY(mi), MI_WINDOW(mi)); }
// Called from the constructor. // Create a panel for a rectangular / circular / custom bed shape. ConfigOptionsGroupShp BedShapePanel::init_shape_options_page(wxString title){ auto panel = new wxPanel(m_shape_options_book); ConfigOptionsGroupShp optgroup; optgroup = std::make_shared<ConfigOptionsGroup>(panel, _(L("Settings"))); optgroup->label_width = 100; optgroup->m_on_change = [this](t_config_option_key opt_key, boost::any value){ update_shape(); }; m_optgroups.push_back(optgroup); panel->SetSizerAndFit(optgroup->sizer); m_shape_options_book->AddPage(panel, title); return optgroup; }
int GradientWindow::create_objects() { int x = 10, y = 10; BC_Title *title; add_subwindow(title = new BC_Title(x, y, _("Shape:"))); add_subwindow(shape = new GradientShape(plugin, this, x + title->get_w() + 10, y)); shape->create_objects(); y += 40; shape_x = x; shape_y = y; y += 40; add_subwindow(title = new BC_Title(x, y, _("Rate:"))); add_subwindow(rate = new GradientRate(plugin, x + title->get_w() + 10, y)); rate->create_objects(); y += 40; add_subwindow(title = new BC_Title(x, y, _("Inner radius:"))); add_subwindow(in_radius = new GradientInRadius(plugin, x + title->get_w() + 10, y)); y += 30; add_subwindow(title = new BC_Title(x, y, _("Outer radius:"))); add_subwindow(out_radius = new GradientOutRadius(plugin, x + title->get_w() + 10, y)); y += 35; add_subwindow(in_color = new GradientInColorButton(plugin, this, x, y)); in_color_x = x + in_color->get_w() + 10; in_color_y = y; y += 35; add_subwindow(out_color = new GradientOutColorButton(plugin, this, x, y)); out_color_x = x + out_color->get_w() + 10; out_color_y = y; in_color_thread = new GradientInColorThread(plugin, this); out_color_thread = new GradientOutColorThread(plugin, this); update_in_color(); update_out_color(); update_shape(); show_window(); flush(); return 0; }
static gboolean gtk_tooltip_paint_window (GtkTooltip *tooltip) { guchar tooltip_alpha; gint tooltip_radius; gtk_widget_style_get (tooltip->window, "tooltip-alpha", &tooltip_alpha, "tooltip-radius", &tooltip_radius, NULL); if (tooltip_alpha != 255 || tooltip_radius != 0) { cairo_t *cr; cr = gdk_cairo_create (tooltip->window->window); fill_background (tooltip->window, cr, &tooltip->window->style->bg [GTK_STATE_NORMAL], &tooltip->window->style->bg [GTK_STATE_SELECTED], tooltip_alpha); cairo_destroy (cr); update_shape (tooltip); } else { gtk_paint_flat_box (tooltip->window->style, tooltip->window->window, GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, tooltip->window, "tooltip", 0, 0, tooltip->window->allocation.width, tooltip->window->allocation.height); } return FALSE; }
static void timeline_frame_cb (GsdTimeline *timeline, gdouble progress, gpointer user_data) { GsdLocatePointerData *data = (GsdLocatePointerData *) user_data; gint cursor_x, cursor_y; if (gtk_widget_is_composited (data->widget)) { gdk_window_invalidate_rect (data->window, NULL, FALSE); data->progress = progress; } else if (progress >= data->progress + CIRCLES_PROGRESS_INTERVAL) { /* only invalidate window each circle interval */ update_shape (data); gdk_window_invalidate_rect (data->window, NULL, FALSE); data->progress += CIRCLES_PROGRESS_INTERVAL; } // // gdk_window_get_pointer (gdk_screen_get_root_window (screen), // &cursor_x, &cursor_y, NULL); // use gdk_device_get_position instead of gdk_window_get_device_position // 'coz we use root window here. GdkDisplay *display; GdkDeviceManager * device_manager; GdkDevice* pointer_device; display = gdk_window_get_display (data->window); device_manager = gdk_display_get_device_manager (display); pointer_device = gdk_device_manager_get_client_pointer (device_manager); gdk_device_get_position (pointer_device, NULL, &cursor_x, &cursor_y); // gdk_window_move (data->window, cursor_x - WINDOW_SIZE / 2, cursor_y - WINDOW_SIZE / 2); }
static void on_realized (GtkWidget *window, GtkTooltip *tooltip) { update_shape (tooltip); }
void SPF::learn() { double old_likelihood, delta_likelihood, likelihood = -1e10; int likelihood_decreasing_count = 0; time_t start_time, end_time; int iteration = 0; char iter_as_str[4]; bool converged = false; bool on_final_pass = false; while (!converged) { time(&start_time); iteration++; printf("iteration %d\n", iteration); reset_helper_params(); // update rate for user preferences b_theta.each_col() += sum(beta, 1); set<int> items; int user = -1, item, rating; for (int i = 0; i < settings->sample_size; i++) { if (on_final_pass && settings->final_pass_test) { user++; while (data->test_users.count(user)==0) { user++; } } else if (settings->svi) { user = gsl_rng_uniform_int(rand_gen, data->user_count()); } else { user = i; } bool user_converged = false; int user_iters = 0; while (!user_converged) { user_iters++; a_beta_user.zeros(); a_delta_user.zeros(); // look at all the user's items for (int j = 0; j < data->item_count(user); j++) { item = data->get_item(user, j); items.insert(item); rating = 1; //TODO: rating = data->get_train_rating(i); update_shape(user, item, rating); } // update per-user parameters double user_change = 0; if (!settings->factor_only && !settings->fix_influence) user_change += update_tau(user); if (!settings->social_only) user_change += update_theta(user); if (!settings->social_only && !settings->factor_only && !settings->fix_influence) { user_change /= 2; // if the updates are less than 1% change, the local params have converged if (user_change < 0.01) user_converged = true; } else { // if we're only looking at social or factor (not combined) // then the user parameters will always have converged with // a single pass (since there's nothing to balance against) user_converged = true; } } if (settings->verbose) printf("%d\tuser %d took %d iters to converge\n", iteration, user, user_iters); a_beta += a_beta_user; a_delta += a_delta_user; } if (!settings->social_only) { // update rate for item attributes b_beta.each_col() += sum(theta, 1); // update per-item parameters set<int>::iterator it; for (it = items.begin(); it != items.end(); it++) { item = *it; if (iter_count[item] == 0) iter_count[item] = 0; iter_count[item]++; update_beta(item); if (settings->item_bias) update_delta(item); } } else if (settings->item_bias) { set<int>::iterator it; for (it = items.begin(); it != items.end(); it++) { item = *it; if (iter_count[item] == 0) iter_count[item] = 0; iter_count[item]++; if (settings->item_bias) update_delta(item); } } // check for convergence if (on_final_pass) { printf("Final pass complete\n"); converged = true; old_likelihood = likelihood; likelihood = get_ave_log_likelihood(); delta_likelihood = abs((old_likelihood - likelihood) / old_likelihood); log_convergence(iteration, likelihood, delta_likelihood); } else if (iteration >= settings->max_iter) { printf("Reached maximum number of iterations.\n"); converged = true; old_likelihood = likelihood; likelihood = get_ave_log_likelihood(); delta_likelihood = abs((old_likelihood - likelihood) / old_likelihood); log_convergence(iteration, likelihood, delta_likelihood); } else if (iteration % settings->conv_freq == 0) { old_likelihood = likelihood; likelihood = get_ave_log_likelihood(); if (likelihood < old_likelihood) likelihood_decreasing_count += 1; else likelihood_decreasing_count = 0; delta_likelihood = abs((old_likelihood - likelihood) / old_likelihood); log_convergence(iteration, likelihood, delta_likelihood); if (settings->verbose) { printf("delta: %f\n", delta_likelihood); printf("old: %f\n", old_likelihood); printf("new: %f\n", likelihood); } if (iteration >= settings->min_iter && delta_likelihood < settings->likelihood_delta) { printf("Model converged.\n"); converged = true; } else if (iteration >= settings->min_iter && likelihood_decreasing_count >= 2) { printf("Likelihood decreasing.\n"); converged = true; } } // save intermediate results if (!converged && settings->save_freq > 0 && iteration % settings->save_freq == 0) { printf(" saving\n"); sprintf(iter_as_str, "%04d", iteration); save_parameters(iter_as_str); } // intermediate evaluation if (!converged && settings->eval_freq > 0 && iteration % settings->eval_freq == 0) { sprintf(iter_as_str, "%04d", iteration); evaluate(iter_as_str); } time(&end_time); log_time(iteration, difftime(end_time, start_time)); if (converged && !on_final_pass && (settings->final_pass || settings->final_pass_test)) { printf("final pass on all users.\n"); on_final_pass = true; converged = false; // we need to modify some settings for the final pass // things should look exactly like batch for all users if (settings->final_pass) { settings->set_stochastic_inference(false); settings->set_sample_size(data->user_count()); scale = 1; } else { settings->set_sample_size(data->test_users.size()); scale = data->user_count() / settings->sample_size; } } } save_parameters("final"); }
pulsesequence() { // Define Variables and Objects and Get Parameter Values SHAPE p1 = getpulse("90H",0.0,0.0,1,0); strncpy(p1.pars.ch,"dec",3); putCmd("chH90='dec'\n"); p1.pars.array = disarry("xx", p1.pars.array); p1 = update_shape(p1,0.0,0.0,1); MPSEQ ph = getpmlgxmx("pmlgH",0,0.0,0.0,1,0); strncpy(ph.ch,"dec",3); putCmd("chHpmlg='dec'\n"); double pwHpmlg = getval("pwHpmlg"); ph.nelem = (int) (d2/(2.0*pwHpmlg) + 0.1); ph.array = disarry("xx", ph.array); ph = update_mpseq(ph,0,p1.pars.phAccum,p1.pars.phInt,1); SHAPE p2 = getpulse("90H",0.0,0.0,2,0); strncpy(p2.pars.ch,"dec",3); putCmd("chH90='dec'\n"); p2.pars.array = disarry("xx", p2.pars.array); p2 = update_shape(p2,ph.phAccum,ph.phInt,2); double pwX180 = getval("pwX180"); double d22 = ph.t/2.0 - pwX180/2.0; if (d22 < 0.0) d22 = 0.0; // CP hx and DSEQ dec Return to the Reference Phase CP hx = getcp("HX",0.0,0.0,0,1); strncpy(hx.fr,"dec",3); strncpy(hx.to,"obs",3); putCmd("frHX='dec'\n"); putCmd("toHX='obs'\n"); DSEQ dec = getdseq("H"); strncpy(dec.t.ch,"dec",3); putCmd("chHtppm='dec'\n"); strncpy(dec.s.ch,"dec",3); putCmd("chHspinal='dec'\n"); // Set Constant-time Period for d2. if (d2_index == 0) d2_init = getval("d2"); double d2_ = (ni - 1)/sw1 + d2_init; putCmd("d2acqret = %f\n",roundoff(d2_,12.5e-9)); putCmd("d2dwret = %f\n",roundoff(1.0/sw1,12.5e-9)); //-------------------------------------- // Copy Current Parameters to Processed //------------------------------------- putCmd("groupcopy('current','processed','acquisition')"); // Dutycycle Protection DUTY d = init_dutycycle(); d.dutyon = p1.pars.t + d2_ + p2.pars.t + getval("pwH90") + getval("pwHtilt") + getval("tHX"); d.dutyoff = d1 + 4.0e-6 + getval("tHmix"); d.c1 = d.c1 + (!strcmp(dec.seq,"tppm")); d.c1 = d.c1 + ((!strcmp(dec.seq,"tppm")) && (dec.t.a > 0.0)); d.t1 = getval("rd") + getval("ad") + at; d.c2 = d.c2 + (!strcmp(dec.seq,"spinal")); d.c2 = d.c2 + ((!strcmp(dec.seq,"spinal")) && (dec.s.a > 0.0)); d.t2 = getval("rd") + getval("ad") + at; d = update_dutycycle(d); abort_dutycycle(d,10.0); // Set Phase Tables settable(ph1H90,4,table1); settable(phHpmlg,4,table2); settable(ph2H90,4,table3); settable(ph3H90,4,table4); settable(phHtilt,4,table5); settable(phXhx,4,table6); settable(phHhx,4,table7); settable(phRec,4,table8); //Add STATES TPPI ("States with "FAD") tsadd(phRec,2*d2_index,4); if (phase1 == 2) { tsadd(ph2H90,2*d2_index+3,4); } else { tsadd(ph2H90,2*d2_index,4); } setreceiver(phRec); // Begin Sequence txphase(phXhx); decphase(ph1H90); obspwrf(getval("aX180")); decpwrf(getval("aH90")); obsunblank();decunblank(); _unblank34(); delay(d1); sp1on(); delay(2.0e-6); sp1off(); delay(2.0e-6); // Offset H Preparation with a Tilt Pulse _shape(p1,ph1H90); // Offset SAMn Spinlock on H During F1 with Optional pwX180 _mpseqon(ph,phHpmlg); delay(d22); rgpulse(pwX180,zero,0.0,0.0); obspwrf(getval("aX90")); txphase(phXhx); delay(d22); _mpseqoff(ph); // Offset 90-degree Pulse to Zed and Spin-Diffusion Mix _shape(p2,ph2H90); decpwrf(getval("aH90")); delay(getval("tHmix")); // H90, 35-degree Tilt and H-to-X Cross Polarization with LG Offset decrgpulse(getval("pwH90"),ph3H90,0.0,0.0); decunblank(); decrgpulse(getval("pwHtilt"),phHtilt,0.0,0.0); decphase(phHhx); _cp_(hx,phHhx,phXhx); // Begin Acquisition obsblank(); _blank34(); _dseqon(dec); delay(getval("rd")); startacq(getval("ad")); acquire(np, 1/sw); endacq(); _dseqoff(dec); obsunblank(); decunblank(); _unblank34(); }
int main (int argc, char** argv) { GtkWidget* window; guint pointer_update_id; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); if (!window) return 0; gtk_window_set_type_hint (GTK_WINDOW (window), GDK_WINDOW_TYPE_HINT_DOCK); gtk_widget_add_events (window, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK); // hook up input/event handlers to window g_signal_connect (G_OBJECT (window), "screen-changed", G_CALLBACK (screen_changed_handler), NULL); g_signal_connect (G_OBJECT (window), "composited-changed", G_CALLBACK (composited_changed_handler), NULL); gtk_window_move (GTK_WINDOW (window), POS_X, POS_Y); // make sure the window opens with a RGBA-visual screen_changed_handler (window, NULL, NULL); gtk_widget_realize (window); gdk_window_set_back_pixmap (gtk_widget_get_window (window), NULL, FALSE); // hook up window-event handlers to window g_signal_connect (G_OBJECT (window), "expose-event", G_CALLBACK (expose_handler), NULL); // FIXME: read out current mouse-pointer position every 1/25 second pointer_update_id = g_timeout_add (1000/40, (GSourceFunc) pointer_update, (gpointer) window); g_timeout_add (10000, (GSourceFunc) quit, NULL); g_timeout_add (1000/40, (GSourceFunc) grow, (gpointer) window); // "clear" input-mask, set title/icon/attributes gtk_widget_set_app_paintable (window, TRUE); gtk_window_set_decorated (GTK_WINDOW (window), FALSE); gtk_window_set_keep_above (GTK_WINDOW (window), TRUE); gtk_window_set_resizable (GTK_WINDOW (window), FALSE); gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE); gtk_window_set_opacity (GTK_WINDOW (window), 1.0f); gtk_widget_set_size_request (window, (gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE), (gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE)); gtk_widget_show (window); g_composited = gdk_screen_is_composited(gtk_widget_get_screen (window)); update_input_shape (window, 1, 1); update_shape (window, (gint) CORNER_RADIUS, (gint) BUBBLE_SHADOW_SIZE); set_bg_blur (window, TRUE); setup_tile ((gint) (BUBBLE_WIDTH + 2.0f * BUBBLE_SHADOW_SIZE), (gint) (BUBBLE_HEIGHT + 2.0f * BUBBLE_SHADOW_SIZE)); g_print ("This test will run for 10 seconds and then quit.\n"); gtk_main (); tile_destroy (g_tile); return 0; }
// Called from the constructor. // Set the initial bed shape from a list of points. // Deduce the bed shape type(rect, circle, custom) // This routine shall be smart enough if the user messes up // with the list of points in the ini file directly. void BedShapePanel::set_shape(ConfigOptionPoints* points) { auto polygon = Polygon::new_scale(points->values); // is this a rectangle ? if (points->size() == 4) { auto lines = polygon.lines(); if (lines[0].parallel_to(lines[2]) && lines[1].parallel_to(lines[3])) { // okay, it's a rectangle // find origin // the || 0 hack prevents "-0" which might confuse the user int x_min, x_max, y_min, y_max; x_max = x_min = points->values[0].x; y_max = y_min = points->values[0].y; for (auto pt : points->values){ if (x_min > pt.x) x_min = pt.x; if (x_max < pt.x) x_max = pt.x; if (y_min > pt.y) y_min = pt.y; if (y_max < pt.y) y_max = pt.y; } if (x_min < 0) x_min = 0; if (x_max < 0) x_max = 0; if (y_min < 0) y_min = 0; if (y_max < 0) y_max = 0; auto origin = new ConfigOptionPoints{ Pointf(-x_min, -y_min) }; m_shape_options_book->SetSelection(SHAPE_RECTANGULAR); auto optgroup = m_optgroups[SHAPE_RECTANGULAR]; optgroup->set_value("rect_size", new ConfigOptionPoints{ Pointf(x_max - x_min, y_max - y_min) });//[x_max - x_min, y_max - y_min]); optgroup->set_value("rect_origin", origin); update_shape(); return; } } // is this a circle ? { // Analyze the array of points.Do they reside on a circle ? auto center = polygon.bounding_box().center(); std::vector<double> vertex_distances; double avg_dist = 0; for (auto pt: polygon.points) { double distance = center.distance_to(pt); vertex_distances.push_back(distance); avg_dist += distance; } bool defined_value = true; for (auto el: vertex_distances) { if (abs(el - avg_dist) > 10 * SCALED_EPSILON) defined_value = false; break; } if (defined_value) { // all vertices are equidistant to center m_shape_options_book->SetSelection(SHAPE_CIRCULAR); auto optgroup = m_optgroups[SHAPE_CIRCULAR]; boost::any ret = wxNumberFormatter::ToString(unscale(avg_dist * 2), 0); optgroup->set_value("diameter", ret); update_shape(); return; } } if (points->size() < 3) { // Invalid polygon.Revert to default bed dimensions. m_shape_options_book->SetSelection(SHAPE_RECTANGULAR); auto optgroup = m_optgroups[SHAPE_RECTANGULAR]; optgroup->set_value("rect_size", new ConfigOptionPoints{ Pointf(200, 200) }); optgroup->set_value("rect_origin", new ConfigOptionPoints{ Pointf(0, 0) }); update_shape(); return; } // This is a custom bed shape, use the polygon provided. m_shape_options_book->SetSelection(SHAPE_CUSTOM); // Copy the polygon to the canvas, make a copy of the array. m_canvas->m_bed_shape = points->values; update_shape(); }
void BedShapePanel::build_panel(ConfigOptionPoints* default_pt) { // on_change(nullptr); auto box = new wxStaticBox(this, wxID_ANY, _(L("Shape"))); auto sbsizer = new wxStaticBoxSizer(box, wxVERTICAL); // shape options m_shape_options_book = new wxChoicebook(this, wxID_ANY, wxDefaultPosition, wxSize(300, -1), wxCHB_TOP); sbsizer->Add(m_shape_options_book); auto optgroup = init_shape_options_page(_(L("Rectangular"))); ConfigOptionDef def; def.type = coPoints; def.default_value = new ConfigOptionPoints{ Pointf(200, 200) }; def.label = L("Size"); def.tooltip = L("Size in X and Y of the rectangular plate."); Option option(def, "rect_size"); optgroup->append_single_option_line(option); def.type = coPoints; def.default_value = new ConfigOptionPoints{ Pointf(0, 0) }; def.label = L("Origin"); def.tooltip = L("Distance of the 0,0 G-code coordinate from the front left corner of the rectangle."); option = Option(def, "rect_origin"); optgroup->append_single_option_line(option); optgroup = init_shape_options_page(_(L("Circular"))); def.type = coFloat; def.default_value = new ConfigOptionFloat(200); def.sidetext = L("mm"); def.label = L("Diameter"); def.tooltip = L("Diameter of the print bed. It is assumed that origin (0,0) is located in the center."); option = Option(def, "diameter"); optgroup->append_single_option_line(option); optgroup = init_shape_options_page(_(L("Custom"))); Line line{ "", "" }; line.full_width = 1; line.widget = [this](wxWindow* parent) { auto btn = new wxButton(parent, wxID_ANY, _(L("Load shape from STL...")), wxDefaultPosition, wxDefaultSize); auto sizer = new wxBoxSizer(wxHORIZONTAL); sizer->Add(btn); btn->Bind(wxEVT_BUTTON, ([this](wxCommandEvent e) { load_stl(); })); return sizer; }; optgroup->append_line(line); Bind(wxEVT_CHOICEBOOK_PAGE_CHANGED, ([this](wxCommandEvent e) { update_shape(); })); // right pane with preview canvas m_canvas = new Bed_2D(this); m_canvas->m_bed_shape = default_pt->values; // main sizer auto top_sizer = new wxBoxSizer(wxHORIZONTAL); top_sizer->Add(sbsizer, 0, wxEXPAND | wxLeft | wxTOP | wxBOTTOM, 10); if (m_canvas) top_sizer->Add(m_canvas, 1, wxEXPAND | wxALL, 10) ; SetSizerAndFit(top_sizer); set_shape(default_pt); update_preview(); }
static void on_composited_changed (GtkWidget *window, GtkTooltip *tooltip) { update_shape (tooltip); }
static void on_composited_changed(GtkWidget* window, WindowData* windata) { windata->composited = gdk_screen_is_composited(gtk_widget_get_screen(window)); update_shape(windata); }
void osd_set_text(Osd * self, const gchar * text) { update_layout(self, text); update_image(self); update_shape(self); }