00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #include <interfaces/VisualDisplay2DInterface.h>
00025
00026 #include <core/exceptions/software.h>
00027
00028 #include <cstring>
00029 #include <cstdlib>
00030
00031 namespace fawkes {
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057 VisualDisplay2DInterface::VisualDisplay2DInterface() : Interface()
00058 {
00059 data_size = sizeof(VisualDisplay2DInterface_data_t);
00060 data_ptr = malloc(data_size);
00061 data = (VisualDisplay2DInterface_data_t *)data_ptr;
00062 data_ts = (interface_data_ts_t *)data_ptr;
00063 memset(data_ptr, 0, data_size);
00064 add_fieldinfo(IFT_UINT32, "counter", 1, &data->counter);
00065 add_messageinfo("AddCartLineMessage");
00066 add_messageinfo("AddCartCircleMessage");
00067 add_messageinfo("AddCartRectMessage");
00068 add_messageinfo("AddCartTextMessage");
00069 add_messageinfo("DeleteObjectMessage");
00070 add_messageinfo("DeleteAllMessage");
00071 unsigned char tmp_hash[] = {0xd9, 0x2, 0xad, 0xbb, 0x7a, 0x47, 0x40, 0x6a, 0x4f, 0x6d, 0xfa, 0xa, 0x20, 0x35, 0xe6, 0x1};
00072 set_hash(tmp_hash);
00073 }
00074
00075
00076 VisualDisplay2DInterface::~VisualDisplay2DInterface()
00077 {
00078 free(data_ptr);
00079 }
00080
00081
00082
00083
00084 const char *
00085 VisualDisplay2DInterface::tostring_LineStyle(LineStyle value) const
00086 {
00087 switch (value) {
00088 case LS_SOLID: return "LS_SOLID";
00089 case LS_DASHED: return "LS_DASHED";
00090 case LS_DOTTED: return "LS_DOTTED";
00091 case LS_DASH_DOTTED: return "LS_DASH_DOTTED";
00092 default: return "UNKNOWN";
00093 }
00094 }
00095
00096
00097
00098
00099 const char *
00100 VisualDisplay2DInterface::tostring_Anchor(Anchor value) const
00101 {
00102 switch (value) {
00103 case CENTERED: return "CENTERED";
00104 case NORTH: return "NORTH";
00105 case EAST: return "EAST";
00106 case SOUTH: return "SOUTH";
00107 case WEST: return "WEST";
00108 case NORTH_EAST: return "NORTH_EAST";
00109 case SOUTH_EAST: return "SOUTH_EAST";
00110 case SOUTH_WEST: return "SOUTH_WEST";
00111 case NORTH_WEST: return "NORTH_WEST";
00112 default: return "UNKNOWN";
00113 }
00114 }
00115
00116
00117
00118
00119
00120 uint32_t
00121 VisualDisplay2DInterface::counter() const
00122 {
00123 return data->counter;
00124 }
00125
00126
00127
00128
00129
00130 size_t
00131 VisualDisplay2DInterface::maxlenof_counter() const
00132 {
00133 return 1;
00134 }
00135
00136
00137
00138
00139
00140 void
00141 VisualDisplay2DInterface::set_counter(const uint32_t new_counter)
00142 {
00143 data->counter = new_counter;
00144 data_changed = true;
00145 }
00146
00147
00148 Message *
00149 VisualDisplay2DInterface::create_message(const char *type) const
00150 {
00151 if ( strncmp("AddCartLineMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00152 return new AddCartLineMessage();
00153 } else if ( strncmp("AddCartCircleMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00154 return new AddCartCircleMessage();
00155 } else if ( strncmp("AddCartRectMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00156 return new AddCartRectMessage();
00157 } else if ( strncmp("AddCartTextMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00158 return new AddCartTextMessage();
00159 } else if ( strncmp("DeleteObjectMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00160 return new DeleteObjectMessage();
00161 } else if ( strncmp("DeleteAllMessage", type, __INTERFACE_MESSAGE_TYPE_SIZE) == 0 ) {
00162 return new DeleteAllMessage();
00163 } else {
00164 throw UnknownTypeException("The given type '%s' does not match any known "
00165 "message type for this interface type.", type);
00166 }
00167 }
00168
00169
00170
00171
00172
00173 void
00174 VisualDisplay2DInterface::copy_values(const Interface *other)
00175 {
00176 const VisualDisplay2DInterface *oi = dynamic_cast<const VisualDisplay2DInterface *>(other);
00177 if (oi == NULL) {
00178 throw TypeMismatchException("Can only copy values from interface of same type (%s vs. %s)",
00179 type(), other->type());
00180 }
00181 memcpy(data, oi->data, sizeof(VisualDisplay2DInterface_data_t));
00182 }
00183
00184 const char *
00185 VisualDisplay2DInterface::enum_tostring(const char *enumtype, int val) const
00186 {
00187 if (strcmp(enumtype, "LineStyle") == 0) {
00188 return tostring_LineStyle((LineStyle)val);
00189 }
00190 if (strcmp(enumtype, "Anchor") == 0) {
00191 return tostring_Anchor((Anchor)val);
00192 }
00193 throw UnknownTypeException("Unknown enum type %s", enumtype);
00194 }
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210 VisualDisplay2DInterface::AddCartLineMessage::AddCartLineMessage(const float * ini_x, const float * ini_y, const LineStyle ini_style, const uint8_t * ini_color) : Message("AddCartLineMessage")
00211 {
00212 data_size = sizeof(AddCartLineMessage_data_t);
00213 data_ptr = malloc(data_size);
00214 memset(data_ptr, 0, data_size);
00215 data = (AddCartLineMessage_data_t *)data_ptr;
00216 data_ts = (message_data_ts_t *)data_ptr;
00217 memcpy(data->x, ini_x, sizeof(float) * 2);
00218 memcpy(data->y, ini_y, sizeof(float) * 2);
00219 data->style = ini_style;
00220 memcpy(data->color, ini_color, sizeof(uint8_t) * 4);
00221 add_fieldinfo(IFT_FLOAT, "x", 2, &data->x);
00222 add_fieldinfo(IFT_FLOAT, "y", 2, &data->y);
00223 add_fieldinfo(IFT_ENUM, "style", 1, &data->style, "LineStyle");
00224 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
00225 }
00226
00227 VisualDisplay2DInterface::AddCartLineMessage::AddCartLineMessage() : Message("AddCartLineMessage")
00228 {
00229 data_size = sizeof(AddCartLineMessage_data_t);
00230 data_ptr = malloc(data_size);
00231 memset(data_ptr, 0, data_size);
00232 data = (AddCartLineMessage_data_t *)data_ptr;
00233 data_ts = (message_data_ts_t *)data_ptr;
00234 add_fieldinfo(IFT_FLOAT, "x", 2, &data->x);
00235 add_fieldinfo(IFT_FLOAT, "y", 2, &data->y);
00236 add_fieldinfo(IFT_ENUM, "style", 1, &data->style, "LineStyle");
00237 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
00238 }
00239
00240
00241 VisualDisplay2DInterface::AddCartLineMessage::~AddCartLineMessage()
00242 {
00243 free(data_ptr);
00244 }
00245
00246
00247
00248
00249 VisualDisplay2DInterface::AddCartLineMessage::AddCartLineMessage(const AddCartLineMessage *m) : Message("AddCartLineMessage")
00250 {
00251 data_size = m->data_size;
00252 data_ptr = malloc(data_size);
00253 memcpy(data_ptr, m->data_ptr, data_size);
00254 data = (AddCartLineMessage_data_t *)data_ptr;
00255 data_ts = (message_data_ts_t *)data_ptr;
00256 }
00257
00258
00259
00260
00261
00262
00263 float *
00264 VisualDisplay2DInterface::AddCartLineMessage::x() const
00265 {
00266 return data->x;
00267 }
00268
00269
00270
00271
00272
00273
00274
00275 float
00276 VisualDisplay2DInterface::AddCartLineMessage::x(unsigned int index) const
00277 {
00278 if (index > 2) {
00279 throw Exception("Index value %u out of bounds (0..2)", index);
00280 }
00281 return data->x[index];
00282 }
00283
00284
00285
00286
00287
00288 size_t
00289 VisualDisplay2DInterface::AddCartLineMessage::maxlenof_x() const
00290 {
00291 return 2;
00292 }
00293
00294
00295
00296
00297
00298 void
00299 VisualDisplay2DInterface::AddCartLineMessage::set_x(const float * new_x)
00300 {
00301 memcpy(data->x, new_x, sizeof(float) * 2);
00302 }
00303
00304
00305
00306
00307
00308
00309 void
00310 VisualDisplay2DInterface::AddCartLineMessage::set_x(unsigned int index, const float new_x)
00311 {
00312 if (index > 2) {
00313 throw Exception("Index value %u out of bounds (0..2)", index);
00314 }
00315 data->x[index] = new_x;
00316 }
00317
00318
00319
00320
00321
00322 float *
00323 VisualDisplay2DInterface::AddCartLineMessage::y() const
00324 {
00325 return data->y;
00326 }
00327
00328
00329
00330
00331
00332
00333
00334
00335 float
00336 VisualDisplay2DInterface::AddCartLineMessage::y(unsigned int index) const
00337 {
00338 if (index > 2) {
00339 throw Exception("Index value %u out of bounds (0..2)", index);
00340 }
00341 return data->y[index];
00342 }
00343
00344
00345
00346
00347
00348 size_t
00349 VisualDisplay2DInterface::AddCartLineMessage::maxlenof_y() const
00350 {
00351 return 2;
00352 }
00353
00354
00355
00356
00357
00358
00359 void
00360 VisualDisplay2DInterface::AddCartLineMessage::set_y(const float * new_y)
00361 {
00362 memcpy(data->y, new_y, sizeof(float) * 2);
00363 }
00364
00365
00366
00367
00368
00369
00370
00371 void
00372 VisualDisplay2DInterface::AddCartLineMessage::set_y(unsigned int index, const float new_y)
00373 {
00374 if (index > 2) {
00375 throw Exception("Index value %u out of bounds (0..2)", index);
00376 }
00377 data->y[index] = new_y;
00378 }
00379
00380
00381
00382
00383 VisualDisplay2DInterface::LineStyle
00384 VisualDisplay2DInterface::AddCartLineMessage::style() const
00385 {
00386 return data->style;
00387 }
00388
00389
00390
00391
00392
00393 size_t
00394 VisualDisplay2DInterface::AddCartLineMessage::maxlenof_style() const
00395 {
00396 return 1;
00397 }
00398
00399
00400
00401
00402
00403 void
00404 VisualDisplay2DInterface::AddCartLineMessage::set_style(const LineStyle new_style)
00405 {
00406 data->style = new_style;
00407 }
00408
00409
00410
00411
00412
00413 uint8_t *
00414 VisualDisplay2DInterface::AddCartLineMessage::color() const
00415 {
00416 return data->color;
00417 }
00418
00419
00420
00421
00422
00423
00424
00425 uint8_t
00426 VisualDisplay2DInterface::AddCartLineMessage::color(unsigned int index) const
00427 {
00428 if (index > 4) {
00429 throw Exception("Index value %u out of bounds (0..4)", index);
00430 }
00431 return data->color[index];
00432 }
00433
00434
00435
00436
00437
00438 size_t
00439 VisualDisplay2DInterface::AddCartLineMessage::maxlenof_color() const
00440 {
00441 return 4;
00442 }
00443
00444
00445
00446
00447
00448 void
00449 VisualDisplay2DInterface::AddCartLineMessage::set_color(const uint8_t * new_color)
00450 {
00451 memcpy(data->color, new_color, sizeof(uint8_t) * 4);
00452 }
00453
00454
00455
00456
00457
00458
00459 void
00460 VisualDisplay2DInterface::AddCartLineMessage::set_color(unsigned int index, const uint8_t new_color)
00461 {
00462 if (index > 4) {
00463 throw Exception("Index value %u out of bounds (0..4)", index);
00464 }
00465 data->color[index] = new_color;
00466 }
00467
00468
00469
00470
00471
00472 Message *
00473 VisualDisplay2DInterface::AddCartLineMessage::clone() const
00474 {
00475 return new VisualDisplay2DInterface::AddCartLineMessage(this);
00476 }
00477
00478
00479
00480
00481
00482
00483
00484
00485
00486
00487
00488
00489
00490
00491 VisualDisplay2DInterface::AddCartCircleMessage::AddCartCircleMessage(const float ini_x, const float ini_y, const float ini_radius, const LineStyle ini_style, const uint8_t * ini_color) : Message("AddCartCircleMessage")
00492 {
00493 data_size = sizeof(AddCartCircleMessage_data_t);
00494 data_ptr = malloc(data_size);
00495 memset(data_ptr, 0, data_size);
00496 data = (AddCartCircleMessage_data_t *)data_ptr;
00497 data_ts = (message_data_ts_t *)data_ptr;
00498 data->x = ini_x;
00499 data->y = ini_y;
00500 data->radius = ini_radius;
00501 data->style = ini_style;
00502 memcpy(data->color, ini_color, sizeof(uint8_t) * 4);
00503 add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
00504 add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
00505 add_fieldinfo(IFT_FLOAT, "radius", 1, &data->radius);
00506 add_fieldinfo(IFT_ENUM, "style", 1, &data->style, "LineStyle");
00507 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
00508 }
00509
00510 VisualDisplay2DInterface::AddCartCircleMessage::AddCartCircleMessage() : Message("AddCartCircleMessage")
00511 {
00512 data_size = sizeof(AddCartCircleMessage_data_t);
00513 data_ptr = malloc(data_size);
00514 memset(data_ptr, 0, data_size);
00515 data = (AddCartCircleMessage_data_t *)data_ptr;
00516 data_ts = (message_data_ts_t *)data_ptr;
00517 add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
00518 add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
00519 add_fieldinfo(IFT_FLOAT, "radius", 1, &data->radius);
00520 add_fieldinfo(IFT_ENUM, "style", 1, &data->style, "LineStyle");
00521 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
00522 }
00523
00524
00525 VisualDisplay2DInterface::AddCartCircleMessage::~AddCartCircleMessage()
00526 {
00527 free(data_ptr);
00528 }
00529
00530
00531
00532
00533 VisualDisplay2DInterface::AddCartCircleMessage::AddCartCircleMessage(const AddCartCircleMessage *m) : Message("AddCartCircleMessage")
00534 {
00535 data_size = m->data_size;
00536 data_ptr = malloc(data_size);
00537 memcpy(data_ptr, m->data_ptr, data_size);
00538 data = (AddCartCircleMessage_data_t *)data_ptr;
00539 data_ts = (message_data_ts_t *)data_ptr;
00540 }
00541
00542
00543
00544
00545
00546
00547 float
00548 VisualDisplay2DInterface::AddCartCircleMessage::x() const
00549 {
00550 return data->x;
00551 }
00552
00553
00554
00555
00556
00557 size_t
00558 VisualDisplay2DInterface::AddCartCircleMessage::maxlenof_x() const
00559 {
00560 return 1;
00561 }
00562
00563
00564
00565
00566
00567 void
00568 VisualDisplay2DInterface::AddCartCircleMessage::set_x(const float new_x)
00569 {
00570 data->x = new_x;
00571 }
00572
00573
00574
00575
00576
00577 float
00578 VisualDisplay2DInterface::AddCartCircleMessage::y() const
00579 {
00580 return data->y;
00581 }
00582
00583
00584
00585
00586
00587 size_t
00588 VisualDisplay2DInterface::AddCartCircleMessage::maxlenof_y() const
00589 {
00590 return 1;
00591 }
00592
00593
00594
00595
00596
00597 void
00598 VisualDisplay2DInterface::AddCartCircleMessage::set_y(const float new_y)
00599 {
00600 data->y = new_y;
00601 }
00602
00603
00604
00605
00606
00607 float
00608 VisualDisplay2DInterface::AddCartCircleMessage::radius() const
00609 {
00610 return data->radius;
00611 }
00612
00613
00614
00615
00616
00617 size_t
00618 VisualDisplay2DInterface::AddCartCircleMessage::maxlenof_radius() const
00619 {
00620 return 1;
00621 }
00622
00623
00624
00625
00626
00627 void
00628 VisualDisplay2DInterface::AddCartCircleMessage::set_radius(const float new_radius)
00629 {
00630 data->radius = new_radius;
00631 }
00632
00633
00634
00635
00636
00637 VisualDisplay2DInterface::LineStyle
00638 VisualDisplay2DInterface::AddCartCircleMessage::style() const
00639 {
00640 return data->style;
00641 }
00642
00643
00644
00645
00646
00647 size_t
00648 VisualDisplay2DInterface::AddCartCircleMessage::maxlenof_style() const
00649 {
00650 return 1;
00651 }
00652
00653
00654
00655
00656
00657 void
00658 VisualDisplay2DInterface::AddCartCircleMessage::set_style(const LineStyle new_style)
00659 {
00660 data->style = new_style;
00661 }
00662
00663
00664
00665
00666
00667 uint8_t *
00668 VisualDisplay2DInterface::AddCartCircleMessage::color() const
00669 {
00670 return data->color;
00671 }
00672
00673
00674
00675
00676
00677
00678
00679 uint8_t
00680 VisualDisplay2DInterface::AddCartCircleMessage::color(unsigned int index) const
00681 {
00682 if (index > 4) {
00683 throw Exception("Index value %u out of bounds (0..4)", index);
00684 }
00685 return data->color[index];
00686 }
00687
00688
00689
00690
00691
00692 size_t
00693 VisualDisplay2DInterface::AddCartCircleMessage::maxlenof_color() const
00694 {
00695 return 4;
00696 }
00697
00698
00699
00700
00701
00702 void
00703 VisualDisplay2DInterface::AddCartCircleMessage::set_color(const uint8_t * new_color)
00704 {
00705 memcpy(data->color, new_color, sizeof(uint8_t) * 4);
00706 }
00707
00708
00709
00710
00711
00712
00713 void
00714 VisualDisplay2DInterface::AddCartCircleMessage::set_color(unsigned int index, const uint8_t new_color)
00715 {
00716 if (index > 4) {
00717 throw Exception("Index value %u out of bounds (0..4)", index);
00718 }
00719 data->color[index] = new_color;
00720 }
00721
00722
00723
00724
00725
00726 Message *
00727 VisualDisplay2DInterface::AddCartCircleMessage::clone() const
00728 {
00729 return new VisualDisplay2DInterface::AddCartCircleMessage(this);
00730 }
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742
00743
00744
00745
00746 VisualDisplay2DInterface::AddCartRectMessage::AddCartRectMessage(const float ini_x, const float ini_y, const float ini_width, const float ini_height, const LineStyle ini_style, const uint8_t * ini_color) : Message("AddCartRectMessage")
00747 {
00748 data_size = sizeof(AddCartRectMessage_data_t);
00749 data_ptr = malloc(data_size);
00750 memset(data_ptr, 0, data_size);
00751 data = (AddCartRectMessage_data_t *)data_ptr;
00752 data_ts = (message_data_ts_t *)data_ptr;
00753 data->x = ini_x;
00754 data->y = ini_y;
00755 data->width = ini_width;
00756 data->height = ini_height;
00757 data->style = ini_style;
00758 memcpy(data->color, ini_color, sizeof(uint8_t) * 4);
00759 add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
00760 add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
00761 add_fieldinfo(IFT_FLOAT, "width", 1, &data->width);
00762 add_fieldinfo(IFT_FLOAT, "height", 1, &data->height);
00763 add_fieldinfo(IFT_ENUM, "style", 1, &data->style, "LineStyle");
00764 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
00765 }
00766
00767 VisualDisplay2DInterface::AddCartRectMessage::AddCartRectMessage() : Message("AddCartRectMessage")
00768 {
00769 data_size = sizeof(AddCartRectMessage_data_t);
00770 data_ptr = malloc(data_size);
00771 memset(data_ptr, 0, data_size);
00772 data = (AddCartRectMessage_data_t *)data_ptr;
00773 data_ts = (message_data_ts_t *)data_ptr;
00774 add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
00775 add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
00776 add_fieldinfo(IFT_FLOAT, "width", 1, &data->width);
00777 add_fieldinfo(IFT_FLOAT, "height", 1, &data->height);
00778 add_fieldinfo(IFT_ENUM, "style", 1, &data->style, "LineStyle");
00779 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
00780 }
00781
00782
00783 VisualDisplay2DInterface::AddCartRectMessage::~AddCartRectMessage()
00784 {
00785 free(data_ptr);
00786 }
00787
00788
00789
00790
00791 VisualDisplay2DInterface::AddCartRectMessage::AddCartRectMessage(const AddCartRectMessage *m) : Message("AddCartRectMessage")
00792 {
00793 data_size = m->data_size;
00794 data_ptr = malloc(data_size);
00795 memcpy(data_ptr, m->data_ptr, data_size);
00796 data = (AddCartRectMessage_data_t *)data_ptr;
00797 data_ts = (message_data_ts_t *)data_ptr;
00798 }
00799
00800
00801
00802
00803
00804
00805 float
00806 VisualDisplay2DInterface::AddCartRectMessage::x() const
00807 {
00808 return data->x;
00809 }
00810
00811
00812
00813
00814
00815 size_t
00816 VisualDisplay2DInterface::AddCartRectMessage::maxlenof_x() const
00817 {
00818 return 1;
00819 }
00820
00821
00822
00823
00824
00825 void
00826 VisualDisplay2DInterface::AddCartRectMessage::set_x(const float new_x)
00827 {
00828 data->x = new_x;
00829 }
00830
00831
00832
00833
00834
00835 float
00836 VisualDisplay2DInterface::AddCartRectMessage::y() const
00837 {
00838 return data->y;
00839 }
00840
00841
00842
00843
00844
00845 size_t
00846 VisualDisplay2DInterface::AddCartRectMessage::maxlenof_y() const
00847 {
00848 return 1;
00849 }
00850
00851
00852
00853
00854
00855 void
00856 VisualDisplay2DInterface::AddCartRectMessage::set_y(const float new_y)
00857 {
00858 data->y = new_y;
00859 }
00860
00861
00862
00863
00864
00865 float
00866 VisualDisplay2DInterface::AddCartRectMessage::width() const
00867 {
00868 return data->width;
00869 }
00870
00871
00872
00873
00874
00875 size_t
00876 VisualDisplay2DInterface::AddCartRectMessage::maxlenof_width() const
00877 {
00878 return 1;
00879 }
00880
00881
00882
00883
00884
00885 void
00886 VisualDisplay2DInterface::AddCartRectMessage::set_width(const float new_width)
00887 {
00888 data->width = new_width;
00889 }
00890
00891
00892
00893
00894
00895 float
00896 VisualDisplay2DInterface::AddCartRectMessage::height() const
00897 {
00898 return data->height;
00899 }
00900
00901
00902
00903
00904
00905 size_t
00906 VisualDisplay2DInterface::AddCartRectMessage::maxlenof_height() const
00907 {
00908 return 1;
00909 }
00910
00911
00912
00913
00914
00915 void
00916 VisualDisplay2DInterface::AddCartRectMessage::set_height(const float new_height)
00917 {
00918 data->height = new_height;
00919 }
00920
00921
00922
00923
00924
00925 VisualDisplay2DInterface::LineStyle
00926 VisualDisplay2DInterface::AddCartRectMessage::style() const
00927 {
00928 return data->style;
00929 }
00930
00931
00932
00933
00934
00935 size_t
00936 VisualDisplay2DInterface::AddCartRectMessage::maxlenof_style() const
00937 {
00938 return 1;
00939 }
00940
00941
00942
00943
00944
00945 void
00946 VisualDisplay2DInterface::AddCartRectMessage::set_style(const LineStyle new_style)
00947 {
00948 data->style = new_style;
00949 }
00950
00951
00952
00953
00954
00955 uint8_t *
00956 VisualDisplay2DInterface::AddCartRectMessage::color() const
00957 {
00958 return data->color;
00959 }
00960
00961
00962
00963
00964
00965
00966
00967 uint8_t
00968 VisualDisplay2DInterface::AddCartRectMessage::color(unsigned int index) const
00969 {
00970 if (index > 4) {
00971 throw Exception("Index value %u out of bounds (0..4)", index);
00972 }
00973 return data->color[index];
00974 }
00975
00976
00977
00978
00979
00980 size_t
00981 VisualDisplay2DInterface::AddCartRectMessage::maxlenof_color() const
00982 {
00983 return 4;
00984 }
00985
00986
00987
00988
00989
00990 void
00991 VisualDisplay2DInterface::AddCartRectMessage::set_color(const uint8_t * new_color)
00992 {
00993 memcpy(data->color, new_color, sizeof(uint8_t) * 4);
00994 }
00995
00996
00997
00998
00999
01000
01001 void
01002 VisualDisplay2DInterface::AddCartRectMessage::set_color(unsigned int index, const uint8_t new_color)
01003 {
01004 if (index > 4) {
01005 throw Exception("Index value %u out of bounds (0..4)", index);
01006 }
01007 data->color[index] = new_color;
01008 }
01009
01010
01011
01012
01013
01014 Message *
01015 VisualDisplay2DInterface::AddCartRectMessage::clone() const
01016 {
01017 return new VisualDisplay2DInterface::AddCartRectMessage(this);
01018 }
01019
01020
01021
01022
01023
01024
01025
01026
01027
01028
01029
01030
01031
01032
01033
01034 VisualDisplay2DInterface::AddCartTextMessage::AddCartTextMessage(const float ini_x, const float ini_y, const char * ini_text, const Anchor ini_anchor, const float ini_size, const uint8_t * ini_color) : Message("AddCartTextMessage")
01035 {
01036 data_size = sizeof(AddCartTextMessage_data_t);
01037 data_ptr = malloc(data_size);
01038 memset(data_ptr, 0, data_size);
01039 data = (AddCartTextMessage_data_t *)data_ptr;
01040 data_ts = (message_data_ts_t *)data_ptr;
01041 data->x = ini_x;
01042 data->y = ini_y;
01043 strncpy(data->text, ini_text, 128);
01044 data->anchor = ini_anchor;
01045 data->size = ini_size;
01046 memcpy(data->color, ini_color, sizeof(uint8_t) * 4);
01047 add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
01048 add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
01049 add_fieldinfo(IFT_STRING, "text", 128, data->text);
01050 add_fieldinfo(IFT_ENUM, "anchor", 1, &data->anchor, "Anchor");
01051 add_fieldinfo(IFT_FLOAT, "size", 1, &data->size);
01052 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
01053 }
01054
01055 VisualDisplay2DInterface::AddCartTextMessage::AddCartTextMessage() : Message("AddCartTextMessage")
01056 {
01057 data_size = sizeof(AddCartTextMessage_data_t);
01058 data_ptr = malloc(data_size);
01059 memset(data_ptr, 0, data_size);
01060 data = (AddCartTextMessage_data_t *)data_ptr;
01061 data_ts = (message_data_ts_t *)data_ptr;
01062 add_fieldinfo(IFT_FLOAT, "x", 1, &data->x);
01063 add_fieldinfo(IFT_FLOAT, "y", 1, &data->y);
01064 add_fieldinfo(IFT_STRING, "text", 128, data->text);
01065 add_fieldinfo(IFT_ENUM, "anchor", 1, &data->anchor, "Anchor");
01066 add_fieldinfo(IFT_FLOAT, "size", 1, &data->size);
01067 add_fieldinfo(IFT_BYTE, "color", 4, &data->color);
01068 }
01069
01070
01071 VisualDisplay2DInterface::AddCartTextMessage::~AddCartTextMessage()
01072 {
01073 free(data_ptr);
01074 }
01075
01076
01077
01078
01079 VisualDisplay2DInterface::AddCartTextMessage::AddCartTextMessage(const AddCartTextMessage *m) : Message("AddCartTextMessage")
01080 {
01081 data_size = m->data_size;
01082 data_ptr = malloc(data_size);
01083 memcpy(data_ptr, m->data_ptr, data_size);
01084 data = (AddCartTextMessage_data_t *)data_ptr;
01085 data_ts = (message_data_ts_t *)data_ptr;
01086 }
01087
01088
01089
01090
01091
01092
01093 float
01094 VisualDisplay2DInterface::AddCartTextMessage::x() const
01095 {
01096 return data->x;
01097 }
01098
01099
01100
01101
01102
01103 size_t
01104 VisualDisplay2DInterface::AddCartTextMessage::maxlenof_x() const
01105 {
01106 return 1;
01107 }
01108
01109
01110
01111
01112
01113 void
01114 VisualDisplay2DInterface::AddCartTextMessage::set_x(const float new_x)
01115 {
01116 data->x = new_x;
01117 }
01118
01119
01120
01121
01122
01123 float
01124 VisualDisplay2DInterface::AddCartTextMessage::y() const
01125 {
01126 return data->y;
01127 }
01128
01129
01130
01131
01132
01133 size_t
01134 VisualDisplay2DInterface::AddCartTextMessage::maxlenof_y() const
01135 {
01136 return 1;
01137 }
01138
01139
01140
01141
01142
01143 void
01144 VisualDisplay2DInterface::AddCartTextMessage::set_y(const float new_y)
01145 {
01146 data->y = new_y;
01147 }
01148
01149
01150
01151
01152
01153 char *
01154 VisualDisplay2DInterface::AddCartTextMessage::text() const
01155 {
01156 return data->text;
01157 }
01158
01159
01160
01161
01162
01163 size_t
01164 VisualDisplay2DInterface::AddCartTextMessage::maxlenof_text() const
01165 {
01166 return 128;
01167 }
01168
01169
01170
01171
01172
01173 void
01174 VisualDisplay2DInterface::AddCartTextMessage::set_text(const char * new_text)
01175 {
01176 strncpy(data->text, new_text, sizeof(data->text));
01177 }
01178
01179
01180
01181
01182
01183
01184 VisualDisplay2DInterface::Anchor
01185 VisualDisplay2DInterface::AddCartTextMessage::anchor() const
01186 {
01187 return data->anchor;
01188 }
01189
01190
01191
01192
01193
01194 size_t
01195 VisualDisplay2DInterface::AddCartTextMessage::maxlenof_anchor() const
01196 {
01197 return 1;
01198 }
01199
01200
01201
01202
01203
01204
01205 void
01206 VisualDisplay2DInterface::AddCartTextMessage::set_anchor(const Anchor new_anchor)
01207 {
01208 data->anchor = new_anchor;
01209 }
01210
01211
01212
01213
01214
01215 float
01216 VisualDisplay2DInterface::AddCartTextMessage::size() const
01217 {
01218 return data->size;
01219 }
01220
01221
01222
01223
01224
01225 size_t
01226 VisualDisplay2DInterface::AddCartTextMessage::maxlenof_size() const
01227 {
01228 return 1;
01229 }
01230
01231
01232
01233
01234
01235 void
01236 VisualDisplay2DInterface::AddCartTextMessage::set_size(const float new_size)
01237 {
01238 data->size = new_size;
01239 }
01240
01241
01242
01243
01244
01245 uint8_t *
01246 VisualDisplay2DInterface::AddCartTextMessage::color() const
01247 {
01248 return data->color;
01249 }
01250
01251
01252
01253
01254
01255
01256
01257 uint8_t
01258 VisualDisplay2DInterface::AddCartTextMessage::color(unsigned int index) const
01259 {
01260 if (index > 4) {
01261 throw Exception("Index value %u out of bounds (0..4)", index);
01262 }
01263 return data->color[index];
01264 }
01265
01266
01267
01268
01269
01270 size_t
01271 VisualDisplay2DInterface::AddCartTextMessage::maxlenof_color() const
01272 {
01273 return 4;
01274 }
01275
01276
01277
01278
01279
01280 void
01281 VisualDisplay2DInterface::AddCartTextMessage::set_color(const uint8_t * new_color)
01282 {
01283 memcpy(data->color, new_color, sizeof(uint8_t) * 4);
01284 }
01285
01286
01287
01288
01289
01290
01291 void
01292 VisualDisplay2DInterface::AddCartTextMessage::set_color(unsigned int index, const uint8_t new_color)
01293 {
01294 if (index > 4) {
01295 throw Exception("Index value %u out of bounds (0..4)", index);
01296 }
01297 data->color[index] = new_color;
01298 }
01299
01300
01301
01302
01303
01304 Message *
01305 VisualDisplay2DInterface::AddCartTextMessage::clone() const
01306 {
01307 return new VisualDisplay2DInterface::AddCartTextMessage(this);
01308 }
01309
01310
01311
01312
01313
01314
01315
01316
01317
01318
01319 VisualDisplay2DInterface::DeleteObjectMessage::DeleteObjectMessage(const uint32_t ini_object_id) : Message("DeleteObjectMessage")
01320 {
01321 data_size = sizeof(DeleteObjectMessage_data_t);
01322 data_ptr = malloc(data_size);
01323 memset(data_ptr, 0, data_size);
01324 data = (DeleteObjectMessage_data_t *)data_ptr;
01325 data_ts = (message_data_ts_t *)data_ptr;
01326 data->object_id = ini_object_id;
01327 add_fieldinfo(IFT_UINT32, "object_id", 1, &data->object_id);
01328 }
01329
01330 VisualDisplay2DInterface::DeleteObjectMessage::DeleteObjectMessage() : Message("DeleteObjectMessage")
01331 {
01332 data_size = sizeof(DeleteObjectMessage_data_t);
01333 data_ptr = malloc(data_size);
01334 memset(data_ptr, 0, data_size);
01335 data = (DeleteObjectMessage_data_t *)data_ptr;
01336 data_ts = (message_data_ts_t *)data_ptr;
01337 add_fieldinfo(IFT_UINT32, "object_id", 1, &data->object_id);
01338 }
01339
01340
01341 VisualDisplay2DInterface::DeleteObjectMessage::~DeleteObjectMessage()
01342 {
01343 free(data_ptr);
01344 }
01345
01346
01347
01348
01349 VisualDisplay2DInterface::DeleteObjectMessage::DeleteObjectMessage(const DeleteObjectMessage *m) : Message("DeleteObjectMessage")
01350 {
01351 data_size = m->data_size;
01352 data_ptr = malloc(data_size);
01353 memcpy(data_ptr, m->data_ptr, data_size);
01354 data = (DeleteObjectMessage_data_t *)data_ptr;
01355 data_ts = (message_data_ts_t *)data_ptr;
01356 }
01357
01358
01359
01360
01361
01362
01363
01364 uint32_t
01365 VisualDisplay2DInterface::DeleteObjectMessage::object_id() const
01366 {
01367 return data->object_id;
01368 }
01369
01370
01371
01372
01373
01374 size_t
01375 VisualDisplay2DInterface::DeleteObjectMessage::maxlenof_object_id() const
01376 {
01377 return 1;
01378 }
01379
01380
01381
01382
01383
01384
01385 void
01386 VisualDisplay2DInterface::DeleteObjectMessage::set_object_id(const uint32_t new_object_id)
01387 {
01388 data->object_id = new_object_id;
01389 }
01390
01391
01392
01393
01394
01395
01396 Message *
01397 VisualDisplay2DInterface::DeleteObjectMessage::clone() const
01398 {
01399 return new VisualDisplay2DInterface::DeleteObjectMessage(this);
01400 }
01401
01402
01403
01404
01405
01406
01407
01408
01409 VisualDisplay2DInterface::DeleteAllMessage::DeleteAllMessage() : Message("DeleteAllMessage")
01410 {
01411 data_size = sizeof(DeleteAllMessage_data_t);
01412 data_ptr = malloc(data_size);
01413 memset(data_ptr, 0, data_size);
01414 data = (DeleteAllMessage_data_t *)data_ptr;
01415 data_ts = (message_data_ts_t *)data_ptr;
01416 }
01417
01418
01419 VisualDisplay2DInterface::DeleteAllMessage::~DeleteAllMessage()
01420 {
01421 free(data_ptr);
01422 }
01423
01424
01425
01426
01427 VisualDisplay2DInterface::DeleteAllMessage::DeleteAllMessage(const DeleteAllMessage *m) : Message("DeleteAllMessage")
01428 {
01429 data_size = m->data_size;
01430 data_ptr = malloc(data_size);
01431 memcpy(data_ptr, m->data_ptr, data_size);
01432 data = (DeleteAllMessage_data_t *)data_ptr;
01433 data_ts = (message_data_ts_t *)data_ptr;
01434 }
01435
01436
01437
01438
01439
01440
01441
01442 Message *
01443 VisualDisplay2DInterface::DeleteAllMessage::clone() const
01444 {
01445 return new VisualDisplay2DInterface::DeleteAllMessage(this);
01446 }
01447
01448
01449
01450
01451 bool
01452 VisualDisplay2DInterface::message_valid(const Message *message) const
01453 {
01454 const AddCartLineMessage *m0 = dynamic_cast<const AddCartLineMessage *>(message);
01455 if ( m0 != NULL ) {
01456 return true;
01457 }
01458 const AddCartCircleMessage *m1 = dynamic_cast<const AddCartCircleMessage *>(message);
01459 if ( m1 != NULL ) {
01460 return true;
01461 }
01462 const AddCartRectMessage *m2 = dynamic_cast<const AddCartRectMessage *>(message);
01463 if ( m2 != NULL ) {
01464 return true;
01465 }
01466 const AddCartTextMessage *m3 = dynamic_cast<const AddCartTextMessage *>(message);
01467 if ( m3 != NULL ) {
01468 return true;
01469 }
01470 const DeleteObjectMessage *m4 = dynamic_cast<const DeleteObjectMessage *>(message);
01471 if ( m4 != NULL ) {
01472 return true;
01473 }
01474 const DeleteAllMessage *m5 = dynamic_cast<const DeleteAllMessage *>(message);
01475 if ( m5 != NULL ) {
01476 return true;
01477 }
01478 return false;
01479 }
01480
01481
01482 EXPORT_INTERFACE(VisualDisplay2DInterface)
01483
01484
01485
01486 }