00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #include "sliderTable.h"
00016 #include "bamReader.h"
00017 #include "bamWriter.h"
00018 #include "vertexTransform.h"
00019
00020 SparseArray SliderTable::_empty_array;
00021 TypeHandle SliderTable::_type_handle;
00022
00023
00024
00025
00026
00027
00028 SliderTable::
00029 SliderTable() :
00030 _is_registered(false)
00031 {
00032 }
00033
00034
00035
00036
00037
00038
00039 SliderTable::
00040 SliderTable(const SliderTable ©) :
00041 _is_registered(false),
00042 _sliders(copy._sliders),
00043 _sliders_by_name(copy._sliders_by_name)
00044 {
00045 }
00046
00047
00048
00049
00050
00051
00052 void SliderTable::
00053 operator = (const SliderTable ©) {
00054 nassertv(!_is_registered);
00055 _sliders = copy._sliders;
00056 _sliders_by_name = copy._sliders_by_name;
00057 }
00058
00059
00060
00061
00062
00063
00064 SliderTable::
00065 ~SliderTable() {
00066 if (_is_registered) {
00067 do_unregister();
00068 }
00069 }
00070
00071
00072
00073
00074
00075
00076
00077 void SliderTable::
00078 set_slider(int n, const VertexSlider *slider) {
00079 nassertv(!_is_registered);
00080 nassertv(n >= 0 && n < (int)_sliders.size());
00081
00082 if (_sliders[n]._slider->get_name() != slider->get_name()) {
00083 _sliders_by_name[_sliders[n]._slider->get_name()].clear_bit(n);
00084 _sliders_by_name[slider->get_name()].set_bit(n);
00085 }
00086
00087 _sliders[n]._slider = slider;
00088 }
00089
00090
00091
00092
00093
00094
00095
00096 void SliderTable::
00097 set_slider_rows(int n, const SparseArray &rows) {
00098
00099
00100
00101
00102 nassertv(n >= 0 && n < (int)_sliders.size());
00103
00104 _sliders[n]._rows = rows;
00105 }
00106
00107
00108
00109
00110
00111
00112
00113 void SliderTable::
00114 remove_slider(int n) {
00115 nassertv(!_is_registered);
00116 nassertv(n >= 0 && n < (int)_sliders.size());
00117
00118 _sliders_by_name[_sliders[n]._slider->get_name()].clear_bit(n);
00119 _sliders.erase(_sliders.begin() + n);
00120 }
00121
00122
00123
00124
00125
00126
00127
00128
00129 int SliderTable::
00130 add_slider(const VertexSlider *slider, const SparseArray &rows) {
00131 nassertr(!_is_registered, -1);
00132
00133 int new_index = (int)_sliders.size();
00134
00135 SliderDef slider_def;
00136 slider_def._slider = slider;
00137 slider_def._rows = rows;
00138 _sliders.push_back(slider_def);
00139 _sliders_by_name[slider->get_name()].set_bit(new_index);
00140
00141 return new_index;
00142 }
00143
00144
00145
00146
00147
00148
00149 void SliderTable::
00150 write(ostream &out) const {
00151 for (size_t i = 0; i < _sliders.size(); ++i) {
00152 out << i << ". " << *_sliders[i]._slider << " "
00153 << _sliders[i]._rows << "\n";
00154 }
00155 }
00156
00157
00158
00159
00160
00161
00162 void SliderTable::
00163 do_register() {
00164 nassertv(!_is_registered);
00165
00166 Sliders::iterator si;
00167 for (si = _sliders.begin(); si != _sliders.end(); ++si) {
00168 const VertexSlider *slider = (*si)._slider;
00169 bool inserted = ((VertexSlider *)slider)->_tables.insert(this).second;
00170 nassertv(inserted);
00171 }
00172 _is_registered = true;
00173 }
00174
00175
00176
00177
00178
00179
00180
00181 void SliderTable::
00182 do_unregister() {
00183 nassertv(_is_registered);
00184
00185 Sliders::iterator si;
00186 for (si = _sliders.begin(); si != _sliders.end(); ++si) {
00187 const VertexSlider *slider = (*si)._slider;
00188 ((VertexSlider *)slider)->_tables.erase(this);
00189 }
00190 _is_registered = false;
00191 }
00192
00193
00194
00195
00196
00197
00198
00199 void SliderTable::
00200 register_with_read_factory() {
00201 BamReader::get_factory()->register_factory(get_class_type(), make_from_bam);
00202 }
00203
00204
00205
00206
00207
00208
00209
00210 void SliderTable::
00211 write_datagram(BamWriter *manager, Datagram &dg) {
00212 TypedWritable::write_datagram(manager, dg);
00213
00214 dg.add_uint16(_sliders.size());
00215 Sliders::const_iterator si;
00216 for (si = _sliders.begin(); si != _sliders.end(); ++si) {
00217 manager->write_pointer(dg, (*si)._slider->get_name());
00218 manager->write_pointer(dg, (*si)._slider);
00219 (*si)._rows.write_datagram(manager, dg);
00220 }
00221
00222 manager->write_cdata(dg, _cycler);
00223 }
00224
00225
00226
00227
00228
00229
00230
00231
00232 int SliderTable::
00233 complete_pointers(TypedWritable **p_list, BamReader *manager) {
00234 int pi = TypedWritableReferenceCount::complete_pointers(p_list, manager);
00235
00236 for (size_t n = 0; n < _sliders.size(); ++n) {
00237 CPT(InternalName) name = DCAST(InternalName, p_list[pi++]);
00238 PT(VertexSlider) slider = DCAST(VertexSlider, p_list[pi++]);
00239
00240 _sliders[n]._slider = slider;
00241 _sliders_by_name[name].set_bit(n);
00242 }
00243
00244 return pi;
00245 }
00246
00247
00248
00249
00250
00251
00252
00253
00254
00255 TypedWritable *SliderTable::
00256 make_from_bam(const FactoryParams ¶ms) {
00257 SliderTable *object = new SliderTable;
00258 DatagramIterator scan;
00259 BamReader *manager;
00260
00261 parse_params(params, scan, manager);
00262 object->fillin(scan, manager);
00263
00264 return object;
00265 }
00266
00267
00268
00269
00270
00271
00272
00273
00274 void SliderTable::
00275 fillin(DatagramIterator &scan, BamReader *manager) {
00276 TypedWritable::fillin(scan, manager);
00277
00278 size_t num_sliders = scan.get_uint16();
00279 _sliders.reserve(num_sliders);
00280 for (size_t i = 0; i < num_sliders; ++i) {
00281 manager->read_pointer(scan);
00282 manager->read_pointer(scan);
00283 _sliders.push_back(SliderDef());
00284 if (manager->get_file_minor_ver() >= 7) {
00285 _sliders[i]._rows.read_datagram(scan, manager);
00286 } else {
00287
00288
00289
00290 }
00291 }
00292
00293 manager->read_cdata(scan, _cycler);
00294 }
00295
00296
00297
00298
00299
00300
00301 CycleData *SliderTable::CData::
00302 make_copy() const {
00303 return new CData(*this);
00304 }
00305
00306
00307
00308
00309
00310
00311
00312 void SliderTable::CData::
00313 write_datagram(BamWriter *manager, Datagram &dg) const {
00314 }
00315
00316
00317
00318
00319
00320
00321
00322
00323 void SliderTable::CData::
00324 fillin(DatagramIterator &scan, BamReader *manager) {
00325 Thread *current_thread = Thread::get_current_thread();
00326 _modified = VertexTransform::get_next_modified(current_thread);
00327 }