static void blink_screen()
{
if (animation.is_animating == true) return;
if (get_enable_blink_value() == false)
{
now = get_time_value();
for (int i = 0; i < LAYER_COUNT; i++)
{
bool has_changed = check_text(&layers[i], false);
if (has_changed == true)
{
if (animation.is_animating == false) layer_update(&layers[i]);
}
}
}
else
{
animation.current_flag = false;
animation.index = 0;
animation.is_animating = true;
timer = app_timer_register(animation.duration, handle_timer, NULL);
}
}
bool ConditionConverter::is_valid_time_value(const Item_field *field_item,
Item *value_item) {
MRN_DBUG_ENTER_METHOD();
MYSQL_TIME mysql_time;
bool error = get_time_value(field_item, value_item, &mysql_time);
DBUG_RETURN(!error);
}
ParticleList& BeamEmitter::emit(Scalar _t, Scalar dt, Species* species_to_push)
{
t = _t;
if (species==species_to_push){
dt *= species->get_subcycleIndex()/(Scalar)species->get_supercycleIndex(); // expand dt for subcycled particles
if (init) initialize();
if (points!=0) return obliqueEmit(t, dt);
Scalar nPer_dt;
switch (get_xtFlag()) {
case 0:
case 1:
fAvg = get_time_value(t);
// FTotal = get_time_value(t);
break;
case 2:
break;
case 3:
case 4:
if(!Farray_compute) computeLocationArray();
Farray_compute = FALSE;
break;
}
nPer_dt = fAvg*emissionRate*dt;
// nPer_dt = FTotal*emissionRate*dt;
extra += nPer_dt;
if (extra < 1) return particleList; // < 1 particle to emit
Scalar del_t = dt/nPer_dt;
Vector2 xMKS;
while (extra >= 1){
extra -= 1;
xMKS = computeLocation();
/* if (alongx1()||!rweight)
xMKS = p1 + frand()*(p2 - p1);
else {
xMKS = Vector2(0.5*(p1.e1() + p2.e1()),
sqrt(rMin*rMin + (rMax*rMax - rMin*rMin)*frand()));
}
*/
Vector2 x = fields->getGridCoords(xMKS);
x+=delta; //make sure the particle isn't on the boundary
Vector3 u;
if (thetaDot.e3()){
// only correct if r*thetaDot << vz
Vector3 v = maxwellian->get_V(normal);
if (rweight) v+=xMKS.e2()*thetaDot;
u = v/sqrt(1-v*v*iSPEED_OF_LIGHT_SQ);
}
else
u = maxwellian->get_U(normal);
Particle* p = new Particle(x, u, species, np2c);
Boundary* bPtr = initialPush(del_t*extra, dt, *p);
if (!bPtr) particleList.add(p);
}
}
return particleList;
}
static void
cb_metadata_foreach(gpointer key, gpointer value, gpointer user_data)
{
const gchar *name = key;
GsfDocProp *property = value;
ChupaMetadata *metadata = user_data;
const GValue *property_value;
GType value_type;
property_value = gsf_doc_prop_get_val(property);
value_type = G_VALUE_TYPE(property_value);
#define EQUAL_NAME(property_name) \
(chupa_utils_string_equal(name, property_name))
if (EQUAL_NAME("meta:creation-date")) {
GTimeVal time_value;
if (get_time_value(name, property_value, &time_value)) {
chupa_metadata_set_creation_time(metadata, &time_value);
}
} else if (EQUAL_NAME("dc:creator")) {
chupa_metadata_set_author(metadata, g_value_get_string(property_value));
} else if (EQUAL_NAME("dc:date")) {
GTimeVal time_value;
if (get_time_value(name, property_value, &time_value)) {
chupa_metadata_set_modification_time(metadata, &time_value);
}
} else if (EQUAL_NAME("msole:codepage")) {
if (!chupa_metadata_get_original_encoding(metadata)) {
gint code_page;
gchar *encoding;
code_page = g_value_get_int(property_value);
encoding = code_page_to_encoding(code_page);
chupa_metadata_set_original_encoding(metadata, encoding);
g_free(encoding);
}
} else {
chupa_info("[decomposer][excel][metdata][unsupported][%s][%s]",
name, g_type_name(value_type));
}
#undef EQUAL_NAME
}
void Equipotential::applyFields(Scalar t,Scalar dt)
{
int j,k,J=fields->getJ(),K=fields->getK();
Scalar **Phi=fields->getphi();
V=get_time_value(t);
// This applies the laplace solution at time t, scaled by the current voltage
for(j=0;j<=J;j++) for(k=0;k<=K;k++)
Phi[j][k]+=LaplaceSolution[j][k]*V;
// applyBC(Phi);
// setQ(0.0,0);
}
//for each tick of the timer, walk through the flag list of the animation class
//a false flag will show the original layers, while a true flag will show the blank layer
//do not do anything if the flag has not changed from the last iteration
//at the end of the flag list, stop the animation
// if the animation is for the splash screen,
// force a redraw of the the main screen since the minute tick may still be a while
static void handle_timer(void *data)
{
if(animation.index >= (int) sizeof(animation.flags))
{
if(animation.current_flag == true)
{
for (int i = 0; i < LAYER_COUNT; i++)
{
layer_set_hidden(text_layer_get_layer(layers[i].layer), false);
}
}
animation.is_animating = false;
app_timer_cancel(timer);
if(is_splash_showing == true) is_splash_showing = false;
//blink animation has just ended
//so draw the main watch face even if the minute did not tick yet
//this is to clear the previous screen and show the time immediately
now = get_time_value();
for (int i = 0; i < LAYER_COUNT; i++)
{
bool has_changed = check_text(&layers[i], false);
if (has_changed == true)
{
if (animation.is_animating == false) layer_update(&layers[i]);
}
}
return;
}
if(animation.current_flag != animation.flags[animation.index])
{
animation.current_flag = animation.flags[animation.index];
for (int i = 0; i < LAYER_COUNT; i++)
{
layer_set_hidden(text_layer_get_layer(layers[i].layer), animation.current_flag);
}
}
animation.index++;
timer = app_timer_register(animation.duration, handle_timer, NULL);
}
void ConditionConverter::append_const_item(const Item_field *field_item,
Item *const_item,
grn_obj *expression) {
MRN_DBUG_ENTER_METHOD();
enum_field_types field_type = field_item->field_type();
NormalizedType normalized_type = normalize_field_type(field_type);
switch (normalized_type) {
case STRING_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_TEXT, 0);
{
String *string;
string = const_item->val_str(NULL);
GRN_TEXT_SET(ctx_, &value_, string->ptr(), string->length());
}
break;
case INT_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_INT64, 0);
GRN_INT64_SET(ctx_, &value_, const_item->val_int());
break;
case TIME_TYPE:
grn_obj_reinit(ctx_, &value_, GRN_DB_TIME, 0);
{
MYSQL_TIME mysql_time;
get_time_value(field_item, const_item, &mysql_time);
bool truncated = false;
TimeConverter time_converter;
long long int time =
time_converter.mysql_time_to_grn_time(&mysql_time, &truncated);
GRN_TIME_SET(ctx_, &value_, time);
}
break;
case UNSUPPORTED_TYPE:
// Should not be occurred.
DBUG_PRINT("error",
("mroonga: append_const_item: unsupported type: <%d> "
"This case should not be occurred.",
field_type));
grn_obj_reinit(ctx_, &value_, GRN_DB_VOID, 0);
break;
}
grn_expr_append_const(ctx_, expression, &value_, GRN_OP_PUSH, 1);
DBUG_VOID_RETURN;
}
ParticleList& BeamEmitter::obliqueEmit(Scalar t, Scalar dt)
{
Vector2 xMKS;
for (int j=0; j < 4*(j2 - j1) + 2; j += 2){
int index = j/2;
int jl = points[j];
int kl = points[j+1];
int jh = points[j+2];
int kh = points[j+3];
if (jh == jl && kh == kl) continue; // if this is a duplicate point, get next
Vector2 p1 = fields->getMKS(jl, kl); // note these are local to this segment
Vector2 p2 = fields->getMKS(jh, kh);
Scalar localRate = emissionRate*dt*get_time_value(t)*area[index]/totalArea;
oblExtra[index] += localRate;
if (oblExtra[index] < 1) continue; // not enough to emit in this cell
Scalar del_t = dt/localRate;
while (oblExtra[index] >= 1) {
oblExtra[index] -= 1;
if (kl == kh || !rweight)
xMKS = p1 + frand()*(p2 - p1);
else {
Scalar r_min = p1.e2();
Scalar r_max = p2.e2();
xMKS = Vector2(0.5*(p1.e1() + p2.e1()),
sqrt(r_min*r_min + (r_max*r_max - r_min*r_min)*frand()));
}
Vector2 x = fields->getGridCoords(xMKS);
if (kl == kh) { // horizontal
// x += deltaHorizontal; // perturb particles off boundary
normal = Vector3(0, 1, 0)*get_normal();
}
else if (k2 > k1) { // up and right
// x -= deltaVertical;
normal = Vector3(-1, 0, 0)*get_normal();
}
else { // down and right
// x += deltaVertical;
normal = Vector3(1, 0, 0)*get_normal();
}
Vector3 u;
if (thetaDot.e3()){
// only correct if r*thetaDot << vz
// thetaDot is yDot for ZXgeometry
Vector3 v = maxwellian->get_V(normal);
if (rweight) v+=xMKS.e2()*thetaDot;
u = v/sqrt(1-v*v*iSPEED_OF_LIGHT_SQ);
}
else
u = maxwellian->get_U(normal);
x += delta;
Particle* p = new Particle(x, u, species, np2c);
Boundary* bPtr = initialPush(del_t*oblExtra[index], dt, *p);
if (!bPtr) particleList.add(p);
}
}
return particleList;
}
static int cmdir_convert_RX(unsigned char *orig_rxbuffer)
{
unsigned char tmp_char_buffer[80];
unsigned int tmp_int_buffer[20];
unsigned int final_data_buffer[20];
unsigned int num_data_values = 0;
unsigned char num_data_bytes = 0;
unsigned int orig_index = 0;
int i;
for (i = 0; i < 80; i++)
tmp_char_buffer[i] = 0;
for (i = 0; i < 20; i++)
tmp_int_buffer[i] = 0;
/*
* get number of data bytes that follow the control bytes
* (NOT including them)
*/
num_data_bytes = orig_rxbuffer[1];
/* check if num_bytes is multiple of 3; if not, error */
if (num_data_bytes % 3 > 0)
return -1;
if (num_data_bytes > 60)
return -3;
if (num_data_bytes < 3)
return -2;
/*
* get number of ints to be returned; num_data_bytes does
* NOT include control bytes
*/
num_data_values = num_data_bytes/3;
for (i = 0; i < num_data_values; i++) {
tmp_char_buffer[i*4] = orig_rxbuffer[(i+1)*3];
tmp_char_buffer[i*4+1] = orig_rxbuffer[(i+1)*3+1];
tmp_char_buffer[i*4+2] = 0;
tmp_char_buffer[i*4+3] = 0;
}
/* convert to int array */
memcpy((unsigned char *)tmp_int_buffer, tmp_char_buffer,
(num_data_values*4));
if (orig_rxbuffer[5] < 255) {
/* space */
final_data_buffer[0] = get_time_value(last_mc_time,
tmp_int_buffer[0],
orig_rxbuffer[5]);
} else { /* is pulse */
final_data_buffer[0] = get_time_value(last_mc_time,
tmp_int_buffer[0],
0);
final_data_buffer[0] |= PULSE_BIT;
}
for (i = 1; i < num_data_values; i++) {
/*
* index of orig_rxbuffer that corresponds to
* overflow/pulse/space
*/
orig_index = (i + 1)*3 + 2;
if (orig_rxbuffer[orig_index] < 255) {
final_data_buffer[i] =
get_time_value(tmp_int_buffer[i - 1],
tmp_int_buffer[i],
orig_rxbuffer[orig_index]);
} else {
final_data_buffer[i] =
get_time_value(tmp_int_buffer[i - 1],
tmp_int_buffer[i],
0);
final_data_buffer[i] |= PULSE_BIT;
}
}
last_mc_time = tmp_int_buffer[num_data_values - 1];
if (lirc_buffer_full(&rbuf)) {
printk(KERN_ERR LIRC_DRIVER_NAME ": lirc_buffer is full\n");
return -EOVERFLOW;
}
lirc_buffer_write_n(&rbuf, (char *)final_data_buffer, num_data_values);
return 0;
}
{
for (int x = 0; x < FONT_COUNT; x++)
{
if (x == 0) fonts[x] = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_CUTIEPATOOTIE_40));
else if (x == 1) fonts[x] = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_CUTIEPATOOTIE_30));
else if (x == 2) fonts[x] = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_CUTIEPATOOTIE_25));
else if (x == 3) fonts[x] = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_CUTIEPATOOTIE_20));
else fonts[x] = fonts_load_custom_font(resource_get_handle(RESOURCE_ID_FONT_CUTIEPATOOTIE_40));
}
thincfg_init();
thincfg_subscribe((ThinCFGCallbacks) { .field_changed = field_changed, });
btmonitor_init(get_bt_notification_value());
now = get_time_value();
current_day = 0;
is_holiday = false;
for (int i = 0; i < LAYER_COUNT; i++)
{
/*
The layers are initially 1/3 of the screen
Layer 1 height is adjusted to -20px
Layer 2 height is not adjusted
Layer 3 height is adjusted to +20px
Layer 2 y-offset is adjusted to follow Layer 1 height
Layer 3 y-offset is adjusted to follow Layer 1 height + Layer 2 height
Layer 1 height = x - 20
Layer 2 height = x
Layer 3 height = Layer 1 height + Layer 2 height
