symbol
Block::expand_reference (const symbol key) const
{
const Frame& key_frame = find_frame (key);
daisy_assert (key_frame.is_reference (key));
const symbol var = key_frame.get_reference (key);
if (var == key)
{
error ("Value of '" + key + "' refers to itself");
throw "Reference loop";
}
const Attribute::type var_type = lookup (var);
const Attribute::type key_type = key_frame.lookup (key);
if (var_type != key_type)
{
std::ostringstream tmp;
tmp << "Value of '" << key << "' is $" << var
<< ", which is a " << Attribute::type_name (var_type)
<< ", should be " << Attribute::type_name (key_type);
error (tmp.str ());
throw "Reference type mismatch";
}
const int var_size = find_frame (var).type_size (var);
const int key_size = key_frame.type_size (key);
if (var_size != key_size
&& (key_size != Attribute::Variable
|| var_size == Attribute::Singleton))
// Matching dimension.
{
std::ostringstream tmp;
tmp << "Value of '" << key << "' is $" << var
<< ", a " << Attribute::size_name (var_size)
<< ", should be " << Attribute::size_name (key_size);
error (tmp.str ());
throw "Reference size mismatch";
}
if (var_type == Attribute::Number)
{
daisy_assert (key_type == Attribute::Number);
const symbol var_dim = find_frame (var).dimension (var);
const symbol key_dim = key_frame.dimension (key);
if (var_dim != key_dim)
{
std::ostringstream tmp;
tmp << "Value of '" << key << "' is $" << var
<< ", which is a " << var_dim << ", should be " << key_dim;
error (tmp.str ());
throw "Reference unit mismatch";
}
}
return var;
}
point
edit_graphics_rep::adjust (point p) {
frame f= find_frame ();
grid g= find_grid ();
if (!is_nil (g) && !is_nil (gr0) &&
(g != gr0 || p[0] != p_x || p[1] != p_y)) {
graphical_select (p[0], p[1]);
g= gr0;
p[0]= p_x;
p[1]= p_y;
}
if (is_nil (g)) return p;
point res;
gr_selections sels= copy (gs);
frame f2= find_frame (true);
if (is_nil (f2)) return p;
point fp= f2 (p);
if ((tree) g != "empty_grid") {
point q= g->find_point_around (p, snap_distance, f);
point fq= f2 (q);
if (norm (fq - fp) < snap_distance) {
gr_selection sel;
sel->type= "grid-point";
sel->p = fq;
sel->dist= (SI) norm (fq - fp);
sels << sel;
}
array<grid_curve> gc=
g->get_curves_around (p, snap_distance, f);
for (int i=0; i<N(gc); i++) {
point fc= closest (f2 (gc[i]->c), fp);
if (norm (fc - fp) < snap_distance) {
gr_selection sel;
sel->type= "grid-curve-point";
sel->p = fc;
sel->dist= (SI) norm (fc - fp);
sel->c = f2 (gc[i]->c);
sels << sel;
}
}
}
double eps= get_pixel_size () / 10.0;
gr_selection snap= snap_to_guide (fp, sels, eps);
//cout << "Snap " << fp << " to " << snap << ", " << snap->p << "\n";
point snapped= f2[snap->p];
if (N(snapped) == 2) return snapped;
return p;
// FIXME: why can snapped be an invalid point?
}
bool
Block::flag (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return flag (expand_reference (key));
//Handle primitive flags.
Attribute::type type = lookup (key);
if (type != Attribute::Model)
return frame.flag (key);
// Handle boolean objects.
daisy_assert (type == Attribute::Model);
daisy_assert (frame.component (key) == Boolean::component);
daisy_assert (frame.check (*this));
std::unique_ptr<Boolean> boolean (Librarian::build_frame<Boolean>
(*this, frame.model (key), key));
daisy_assert (boolean.get ());
daisy_assert (boolean->initialize (units (), *this, msg ()));
daisy_assert (boolean->check (units (), *this, msg ()));
boolean->tick (units (), *this, msg ());
daisy_assert (!boolean->missing (*this));
return boolean->value (*this);
}
symbol
Block::name (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return name (expand_reference (key));
//Handle primitive names.
Attribute::type type = lookup (key);
if (type != Attribute::Model)
return expand_string (frame.name (key));
// Handle stringer objects.
daisy_assert (type == Attribute::Model);
daisy_assert (frame.component (key) == Stringer::component);
daisy_assert (frame.check (*this));
std::unique_ptr<Stringer> stringer (Librarian::build_frame<Stringer>
(*this, frame.model (key), key));
daisy_assert (stringer.get ());
daisy_assert (stringer->initialize (units (), *this, msg ()));
daisy_assert (stringer->check (units (), *this, msg ()));
stringer->tick (units (), *this, msg ());
daisy_assert (!stringer->missing (*this));
return symbol (stringer->value (*this));
}
void
edit_graphics_rep::set_graphical_object (tree t) {
go_box= box ();
graphical_object= t;
if (N (graphical_object) == 0) return;
edit_env env= get_typesetter ()->env;
//tree old_fr= env->local_begin (GR_FRAME, (tree) find_frame ());
frame f_env= env->fr;
env->fr= find_frame ();
if (!is_nil (env->fr)) {
int i,n=0;
go_box= typeset_as_concat (env, t, path (0));
for (i=0; i<N(go_box); i++)
if (go_box[i]!="") n++;
if (n) {
array<box> bx(n);
n=0;
for (i=0; i<N(go_box); i++) if (go_box[i]!="") {
array<box> bx2(1);
array<SI> spc2(1);
bx2[0]= go_box[i];
spc2[0]=0;
bx[n]= concat_box (path (0), bx2, spc2);
n++;
}
go_box= composite_box (path (0), bx);
}
}
env->fr= f_env;
//env->local_end (GR_FRAME, old_fr);
}
void add_signal(struct frame_struct *db, int frameId, char *signalName, int startBit, int signalLength, int is_big_endian, int signedState, float factor, float offset, float min, float max, char *unit, char *receiverList, unsigned char isMultiplexer, unsigned char muxId)
{
struct frame_struct *frame;
struct signal_struct *newSignal;
frame = find_frame(db, frameId);
newSignal = malloc(sizeof(struct signal_struct));
strcpy(newSignal->name, signalName);
newSignal->startBit = startBit;
newSignal->signalLength = signalLength;
newSignal->is_big_endian = is_big_endian;
newSignal->is_signed = signedState;
newSignal->factor = factor;
newSignal->offset = offset;
newSignal->min = min;
newSignal->max = max;
if(isMultiplexer > 0)
{
frame->isMultiplexed = 1;
}
newSignal->isMultiplexer = isMultiplexer;
newSignal->muxId = muxId;
strcpy(newSignal->unit, unit);
strcpy(newSignal->receiverList, receiverList);
HASH_ADD_STR( frame->signals, name, newSignal );
}
tree
edit_graphics_rep::graphical_select (double x, double y) {
frame f= find_frame ();
if (is_nil (f)) return tuple ();
gr_selections sels;
point p0 = point (x, y);
point p = f (p0);
sels= eb->graphical_select ((SI)p[0], (SI)p[1], 10*get_pixel_size ());
gs= sels;
pts= array<point> (0);
ci= array<point> (0);
cgi= array<point> (0);
gr0= empty_grid ();
grid g= find_grid ();
frame f2= find_frame (true);
if (!is_nil (g) && !is_nil (f2)) {
gr0= g;
p = f2 (point (x, y));
int i, j, n= N(sels);
for (i=0; i<n; i++) {
array<point> pts2= sels[i]->pts;
if (N(pts2)>0 && norm (pts2[0] - p) <= 10*get_pixel_size ())
pts= pts << pts2[0];
if (N(pts2)>1 && norm (pts2[1] - p) <= 10*get_pixel_size ())
pts= pts << pts2[1];
}
double eps= get_pixel_size () / 10.0;
for (i=0; i<n; i++) {
for (j=0; j<n; j++)
if (i<j) {
curve c1= sels[i]->c;
curve c2= sels[j]->c;
if (!is_nil (c1) && !is_nil (c2))
ci= ci << intersection (c1, c2, p, eps);
}
}
array<grid_curve> gc= g->get_curves_around (p0, 10*get_pixel_size (), f);
//FIXME: Too slow
for (i=0; i<N(gc); i++) {
curve c= f2 (gc[i]->c);
for (j=0; j<n; j++)
if (!is_nil (sels[j]->c))
cgi= cgi << intersection (c, sels[j]->c, p, eps);
}
}
return as_tree (sels);
}
int
Block::integer (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return integer (expand_reference (key));
return frame.integer (key);
}
boost::shared_ptr<const FrameSubmodel>
Block::submodel_ptr (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return submodel_ptr (expand_reference (key));
return frame.submodel_ptr (key);
}
boost::shared_ptr<const PLF>
Block::plf_ptr (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return plf_ptr (expand_reference (key));
return frame.plf_ptr (key);
}
bool
Block::flag (const symbol key, bool default_value) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return flag (expand_reference (key), default_value);
return frame.flag (key, default_value);
}
symbol
Block::name (const symbol key, const symbol default_value) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return name (expand_reference (key), default_value);
return expand_string (frame.name (key, default_value));
}
double
Block::number (const symbol key, double default_value) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return number (expand_reference (key), default_value);
return frame.number (key, default_value);
}
int
Block::integer (const symbol key, int default_value) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return integer (expand_reference (key), default_value);
return frame.integer (key, default_value);
}
const std::vector<double>&
Block::number_sequence (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return number_sequence (expand_reference (key));
return frame.number_sequence (key);
}
const std::vector<boost::shared_ptr<const PLF>/**/>&
Block::plf_sequence (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return plf_sequence (expand_reference (key));
return frame.plf_sequence (key);
}
const std::vector<int>&
Block::integer_sequence (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return integer_sequence (expand_reference (key));
return frame.integer_sequence (key);
}
const std::vector<bool>&
Block::flag_sequence (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return flag_sequence (expand_reference (key));
return frame.flag_sequence (key);
}
value_t* get_binding( const frame_t* f, const int frameindex, const int varindex )
{
frame_t* correctframe = find_frame( f, frameindex );
if ( varindex < 0 && varindex >= sizeof( correctframe->values ) ) {
fatal_error( "binding not found in frame" );
}
return correctframe->values[varindex];
}
void set_binding( frame_t* f, const int frameindex, const int varindex, value_t* value )
{
frame_t* correctframe = find_frame( f, frameindex );
if ( varindex < 0 && varindex >= sizeof( correctframe->values ) ) {
fatal_error( "binding not found in frame" );
}
correctframe->values[varindex] = value;
}
tree
edit_graphics_rep::graphical_select (
double x1, double y1, double x2, double y2)
{
frame f= find_frame ();
if (is_nil (f)) return tuple ();
gr_selections sels;
point p1 = f (point (x1, y1)), p2= f (point (x2, y2));
sels= eb->graphical_select ((SI)p1[0], (SI)p1[1], (SI)p2[0], (SI)p2[1]);
return as_tree (sels);
}
bool
edit_graphics_rep::find_graphical_region (SI& x1, SI& y1, SI& x2, SI& y2) {
point lim1, lim2;
find_limits (lim1, lim2);
if (lim1 == point ()) return false;
frame f= find_frame ();
if (is_nil (f)) return false;
point p1= f (point (lim1[0], lim1[1]));
point p2= f (point (lim2[0], lim2[1]));
x1= (SI) p1[0]; y1= (SI) p1[1];
x2= (SI) p2[0]; y2= (SI) p2[1];
return true;
}
const std::vector<symbol>
Block::name_sequence (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return name_sequence (expand_reference (key));
const std::vector<symbol>& value = frame.name_sequence (key);
std::vector<symbol> result;
for (size_t i = 0; i < value.size (); i++)
result.push_back (expand_string (value[i]));
return result;
}
bool
edit_graphics_rep::mouse_graphics (string type, SI x, SI y, int m, time_t t) {
//cout << type << ", " << x << ", " << y << ", " << m << ", " << t << "\n";
//cout << "et= " << et << "\n";
//cout << "tp= " << tp << "\n";
//cout << "gp= " << graphics_path () << "\n";
(void) t;
// apply_changes (); // FIXME: remove after review of synchronization
frame f= find_frame ();
if (!is_nil (f)) {
if (!over_graphics (x, y))
return false;
if (type == "move" || type == "dragging-left")
if (check_event (MOTION_EVENT))
return true;
point p = f [point (x, y)];
graphical_select (p[0], p[1]); // init the caching for adjust().
p= adjust (p);
gr_x= p[0];
gr_y= p[1];
string sx= as_string (p[0]);
string sy= as_string (p[1]);
invalidate_graphical_object ();
call ("set-keyboard-modifiers", object (m));
if (type == "move")
call ("graphics-move", sx, sy);
else if (type == "release-left" || type == "double-left")
call ("graphics-release-left", sx, sy);
else if (type == "release-middle")
call ("graphics-release-middle", sx, sy);
else if (type == "release-right" || type == "double-right")
call ("graphics-release-right", sx, sy);
else if (type == "start-drag-left")
call ("graphics-start-drag-left", sx, sy);
else if (type == "dragging-left")
call ("graphics-dragging-left", sx, sy);
else if (type == "end-drag-left")
call ("graphics-end-drag-left", sx, sy);
else if (type == "start-drag-right")
call ("graphics-start-drag-right", sx, sy);
else if (type == "dragging-right")
call ("graphics-dragging-right", sx, sy);
else if (type == "end-drag-right")
call ("graphics-end-drag-right", sx, sy);
invalidate_graphical_object ();
notify_change (THE_CURSOR);
return true;
}
//cout << "No frame " << tp << ", " << subtree (et, path_up (tp)) << "\n";
return false;
}
bool
edit_graphics_rep::over_graphics (SI x, SI y) {
frame f= find_frame ();
if (!is_nil (f)) {
point lim1, lim2;
find_limits (lim1, lim2);
point p = adjust (f [point (x, y)]);
// cout << type << " at " << p << " [" << lim1 << ", " << lim2 << "]\n";
if (N(lim1) == 2)
if ((p[0]<lim1[0]) || (p[0]>lim2[0]) || (p[1]<lim1[1]) || (p[1]>lim2[1]))
return false;
return true;
}
return false;
}
tree
edit_graphics_rep::graphical_select (double x, double y) {
frame f= find_frame ();
if (is_nil (f)) return tuple ();
gr_selections pre_sels, sels;
point p0 = point (x, y);
point p = f (p0);
pre_sels= eb->graphical_select ((SI)p[0], (SI)p[1], snap_distance);
for (int i=0; i<N(pre_sels); i++)
if (admissible_selection (pre_sels[i]))
sels << pre_sels[i];
//for (int i=0; i<N(sels); i++)
// cout << i << ":\t" << sels[i] << "\n";
gs= sels;
gr0= empty_grid ();
grid g= find_grid ();
frame f2= find_frame (true);
if (!is_nil (g) && !is_nil (f2)) {
gr0= g;
p_x= x;
p_y= y;
}
return as_tree (sels);
}
bool
edit_graphics_rep::mouse_graphics (string type, SI x, SI y, int m, time_t t) {
(void) t;
// apply_changes (); // FIXME: remove after review of synchronization
frame f= find_frame ();
if (!is_nil (f)) {
if (!over_graphics (x, y)) return false;
if (type == "move" || type == "dragging")
if (check_event (MOTION_EVENT))
return true;
point p = f [point (x, y)];
graphical_select (p[0], p[1]); // init the caching for adjust().
p = adjust (p);
gr_x= p[0];
gr_y= p[1];
string sx= as_string (p[0]);
string sy= as_string (p[1]);
invalidate_graphical_object ();
call ("set-keyboard-modifiers", object (m));
if (type == "move")
call ("graphics-move-point", sx, sy);
else if (type == "release-left")
call ("graphics-insert-point", sx, sy);
else if (type == "release-middle")
call ("graphics-remove-point", sx, sy);
else if (type == "release-right")
call ("graphics-last-point", sx, sy);
else if (type == "start-drag")
call ("graphics-start-drag", sx, sy);
else if (type == "dragging")
call ("graphics-dragging", sx, sy);
else if (type == "end-drag")
call ("graphics-end-drag", sx, sy);
else if (type == "start-right-drag")
call ("graphics-start-right-drag", sx, sy);
else if (type == "right-dragging")
call ("graphics-right-dragging", sx, sy);
else if (type == "end-right-drag")
call ("graphics-end-right-drag", sx, sy);
invalidate_graphical_object ();
notify_change (THE_CURSOR);
return true;
}
return false;
}
std::string operator[] (const char* name ) const
{
std::string ret;
field f = m_remap[ name ];
if( !f.mapped )
throw bad_ident();
if (m_header->version_major>3 && !strcmp(name, "YEAR"))
f=field("TDRC", text);
if( const id3v2_frame* frame = find_frame( f.mapped ) )
{
if( f.pfn )
ret = f.pfn( frame, m_header, !!g_utf8 );
if( !ret.empty() )
return ret;
}
return "";
}
bool
Block::check (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.lookup (key) == Attribute::Error)
// Why are we asking? No such attribute is defined.
return false;
if (!frame.is_reference (key))
// Just a normal attribute.
return frame.check (key);
// A reference.
const symbol var = frame.get_reference (key);
if (key == var)
{
error ("Self reference: '" + key + "'");
return false;
}
// Try expanded version.
return this->check (var);
}
double
Block::number (const symbol key) const
{
const Frame& frame = find_frame (key);
if (frame.is_reference (key))
return number (expand_reference (key));
Attribute::type type = lookup (key);
if (type != Attribute::Model)
return frame.number (key);
// Handle number objects.
daisy_assert (type == Attribute::Model);
daisy_assert (frame.component (key) == Number::component);
daisy_assert (frame.check (*this));
std::unique_ptr<Number> number (Librarian::build_frame<Number>
(*this, frame.model (key), key));
daisy_assert (number.get ());
daisy_assert (number->initialize (units (), *this, msg ()));
daisy_assert (number->check (units (), *this, msg ()));
number->tick (units (), *this, msg ());
daisy_assert (!number->missing (*this));
return number->value (*this);
}
