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);
}
