1 /***************************************************************************
2 DIA_factory.cpp
3 This file contains only redirect functions.
4 Check the GTK/QT/.. functions to see the intersting parts
5 (C) Mean 2008 fixounet@free.fr
6
7 /!\ Big Warning, each time there is a cast, it is a gross hack and needs to be fixed
8 later by using proper inheritance. It is very dangerous as it is.
9
10
11 ***************************************************************************/
12
13 /***************************************************************************
14 * *
15 * This program is free software; you can redistribute it and/or modify *
16 * it under the terms of the GNU General Public License as published by *
17 * the Free Software Foundation; either version 2 of the License, or *
18 * (at your option) any later version. *
19 * *
20 ***************************************************************************/
21
22 #include "ADM_default.h"
23 #include "DIA_coreToolkit.h"
24 #include "DIA_coreUI_internal.h"
25 #include "DIA_factoryStubs.h"
26
27 static FactoryDescriptor *Factory=NULL;
28 /**
29 * \fn FactoryDescriptor
30 */
DIA_factoryInit(FactoryDescriptor * d)31 uint8_t DIA_factoryInit(FactoryDescriptor *d)
32 {
33 uint32_t major,minor,patch;
34 Factory=d;
35 d->FactoryGetVersion(&major,&minor,&patch);
36 printf("[COREUI] Compiled with %02d.%02d.%02d\n",ADM_COREUI_MAJOR,ADM_COREUI_MINOR,ADM_COREUI_PATCH);
37 printf("[COREUI] Linked with %02d.%02d.%02d\n",major,minor,patch);
38 if(major!=ADM_COREUI_MAJOR)
39 {
40 printf("[CoreUI]Incompatible COREUI Major version, compiled with %d, using %d\n",ADM_COREUI_MAJOR,major);
41 ADM_assert(0);
42 }
43 if(minor!=ADM_COREUI_MINOR)
44 {
45 printf("[CoreUI] Maybe Incompatible COREUI Minor version, compiled with %d, using %d\n",ADM_COREUI_MINOR,minor);
46 }
47 printf("[CoreUI] Compiled with patch version %d, using %d\n",ADM_COREUI_PATCH,patch);
48 return 1;
49 }
50 // ****************** All ************************
diaFactoryRun(const char * title,uint32_t nb,diaElem ** elems)51 uint8_t diaFactoryRun(const char *title,uint32_t nb,diaElem **elems)
52 {
53 ADM_assert(Factory);
54 return Factory->FactoryRun(title,nb,elems);
55 }
diaFactoryRunTabs(const char * title,uint32_t nb,diaElemTabs ** tabs)56 uint8_t diaFactoryRunTabs(const char *title,uint32_t nb,diaElemTabs **tabs)
57 {
58 ADM_assert(Factory);
59 return Factory->FactoryRunTab(title,nb,tabs);
60 }
diaFactoryRunTabsPrepare(const char * title,uint32_t nb,diaElemTabs ** tabs)61 void * diaFactoryRunTabsPrepare(const char *title,uint32_t nb,diaElemTabs **tabs)
62 {
63 ADM_assert(Factory);
64 return Factory->FactoryTabPrepare(title,nb,tabs);
65 }
diaFactoryRunTabsFinish(void * f)66 bool diaFactoryRunTabsFinish(void *f)
67 {
68 ADM_assert(Factory);
69 return Factory->FactoryTabFinish(f);
70 }
71
72 // ****************** Buttons ********************
diaElemButton(const char * toggleTitle,ADM_FAC_CALLBACK * cb,void * cookie,const char * tip)73 diaElemButton ::diaElemButton(const char *toggleTitle, ADM_FAC_CALLBACK *cb,void *cookie,const char *tip) :diaElem(ELEM_BUTTON)
74 {
75 ADM_assert(Factory);
76 internalPointer=Factory->CreareButton(toggleTitle, cb,cookie,tip);
77 }
~diaElemButton()78 diaElemButton ::~diaElemButton()
79 {
80 ADM_assert(Factory);
81 Factory->DestroyButton(internalPointer);
82 internalPointer=NULL;
83 }
enable(uint32_t onoff)84 void diaElemButton::enable(uint32_t onoff)
85 {
86 ADM_assert(internalPointer);
87 internalPointer->enable(onoff);
88 }
DIA_MKSTUBS(diaElemButton)89 DIA_MKSTUBS(diaElemButton)
90 // ****************** Bar ********************
91 diaElemBar ::diaElemBar(uint32_t percent,const char *toggleTitle) :diaElem(ELEM_BAR)
92 {
93 ADM_assert(Factory);
94 internalPointer=Factory->CreateBar(percent,toggleTitle);
95 }
~diaElemBar()96 diaElemBar ::~diaElemBar()
97 {
98 ADM_assert(Factory);
99 Factory->DestroyBar(internalPointer);
100 internalPointer=NULL;
101 }
DIA_MKSTUBS(diaElemBar)102 DIA_MKSTUBS(diaElemBar)
103 // ****************** TimeStamp ********************
104 diaElemTimeStamp ::diaElemTimeStamp(uint32_t *value,const char *toggleTitle,const uint32_t valMin,const uint32_t valMax) :diaElem(ELEM_TIMESTAMP)
105 {
106 ADM_assert(Factory);
107 internalPointer=Factory->CreateTimeStamp(value,toggleTitle,valMin,valMax);
108 }
~diaElemTimeStamp()109 diaElemTimeStamp ::~diaElemTimeStamp()
110 {
111 ADM_assert(Factory);
112 Factory->DestroyBar(internalPointer);
113 internalPointer=NULL;
114 }
DIA_MKSTUBS(diaElemTimeStamp)115 DIA_MKSTUBS(diaElemTimeStamp)
116
117
118 // ****************** Buttons ********************
119 diaElemFloat ::diaElemFloat(ELEM_TYPE_FLOAT *intValue,const char *toggleTitle, ELEM_TYPE_FLOAT min,
120 ELEM_TYPE_FLOAT max,const char *tip, int decimals) :diaElem(ELEM_FLOAT)
121 {
122 ADM_assert(Factory);
123 internalPointer=Factory->CreateFloat(intValue,toggleTitle, min,max,tip, decimals);
124 }
~diaElemFloat()125 diaElemFloat ::~diaElemFloat()
126 {
127 ADM_assert(Factory);
128 Factory->DestroyFloat(internalPointer);
129 internalPointer=NULL;
130 }
enable(uint32_t onoff)131 void diaElemFloat::enable(uint32_t onoff)
132 {
133 ADM_assert(internalPointer);
134 internalPointer->enable(onoff);
135 }
DIA_MKSTUBS(diaElemFloat)136 DIA_MKSTUBS(diaElemFloat)
137 // ****************** Integer ********************
138 diaElemInteger ::diaElemInteger(int32_t *intValue,const char *toggleTitle, int32_t min, int32_t max,const char *tip) :
139 diaElem(ELEM_INTEGER)
140 {
141 ADM_assert(Factory);
142 internalPointer=Factory->CreateInteger(intValue,toggleTitle, min,max,tip);
143 }
~diaElemInteger()144 diaElemInteger ::~diaElemInteger()
145 {
146 ADM_assert(Factory);
147 Factory->DestroyInteger(internalPointer);
148 internalPointer=NULL;
149 }
enable(uint32_t onoff)150 void diaElemInteger::enable(uint32_t onoff)
151 {
152 ADM_assert(internalPointer);
153 internalPointer->enable(onoff);
154 }
DIA_MKSTUBS(diaElemInteger)155 DIA_MKSTUBS(diaElemInteger)
156 // ****************** UInteger ********************
157 diaElemUInteger ::diaElemUInteger(uint32_t *intValue,const char *toggleTitle, uint32_t min, uint32_t max,const char *tip) :
158 diaElem(ELEM_INTEGER)
159 {
160 ADM_assert(Factory);
161 internalPointer=Factory->CreateUInteger(intValue,toggleTitle, min,max,tip);
162 }
~diaElemUInteger()163 diaElemUInteger ::~diaElemUInteger()
164 {
165 ADM_assert(Factory);
166 Factory->DestroyUInteger(internalPointer);
167 internalPointer=NULL;
168 }
enable(uint32_t onoff)169 void diaElemUInteger::enable(uint32_t onoff)
170 {
171 ADM_assert(internalPointer);
172 internalPointer->enable(onoff);
173 }
DIA_MKSTUBS(diaElemUInteger)174 DIA_MKSTUBS(diaElemUInteger)
175 // ****************** diaElemNotch ********************
176 diaElemNotch ::diaElemNotch(uint32_t yes,const char *toggleTitle, const char *tip):
177 diaElem(ELEM_NOTCH)
178 {
179 ADM_assert(Factory);
180 internalPointer=Factory->CreateNotch(yes,toggleTitle,tip);
181 }
~diaElemNotch()182 diaElemNotch ::~diaElemNotch()
183 {
184 ADM_assert(Factory);
185 Factory->DestroyNotch(internalPointer);
186 internalPointer=NULL;
187 }
188
DIA_MKSTUBS(diaElemNotch)189 DIA_MKSTUBS(diaElemNotch)
190 // ****************** diaReadonlyText ********************
191 diaElemReadOnlyText ::diaElemReadOnlyText(const char *readyOnly,const char *toggleTitle,const char *tip):
192 diaElem(ELEM_ROTEXT)
193 {
194 ADM_assert(Factory);
195 internalPointer=Factory->CreateReadonlyText(readyOnly,toggleTitle,tip);
196 }
~diaElemReadOnlyText()197 diaElemReadOnlyText ::~diaElemReadOnlyText()
198 {
199 ADM_assert(Factory);
200 Factory->DestroyReadonlyText(internalPointer);
201 internalPointer=NULL;
202 }
enable(uint32_t onoff)203 void diaElemReadOnlyText::enable(uint32_t onoff)
204 {
205 ADM_assert(internalPointer);
206 internalPointer->enable(onoff);
207 }
DIA_MKSTUBS(diaElemReadOnlyText)208 DIA_MKSTUBS(diaElemReadOnlyText)
209 // ****************** diaText ********************
210 diaElemText ::diaElemText(char **readyOnly,const char *toggleTitle,const char *tip):
211 diaElem(ELEM_TEXT)
212 {
213 ADM_assert(Factory);
214 internalPointer=Factory->CreateText(readyOnly,toggleTitle,tip);
215 }
~diaElemText()216 diaElemText ::~diaElemText()
217 {
218 ADM_assert(Factory);
219 Factory->DestroyText(internalPointer);
220 internalPointer=NULL;
221 }
enable(uint32_t onoff)222 void diaElemText::enable(uint32_t onoff)
223 {
224 ADM_assert(internalPointer);
225 internalPointer->enable(onoff);
226 }
DIA_MKSTUBS(diaElemText)227 DIA_MKSTUBS(diaElemText)
228 // ******************************************
229
230 diaElemHex ::diaElemHex(const char *toggleTitle, uint32_t dataSize,uint8_t *data):
231 diaElem(ELEM_HEXDUMP)
232 {
233 ADM_assert(Factory);
234 internalPointer=Factory->CreateHex(toggleTitle,dataSize,data);
235 }
~diaElemHex()236 diaElemHex ::~diaElemHex()
237 {
238 ADM_assert(Factory);
239 Factory->DestroyHex(internalPointer);
240 internalPointer=NULL;
241 }
finalize(void)242 void diaElemHex::finalize(void)
243 {
244 ADM_assert(internalPointer);
245 internalPointer->finalize();
246 }
DIA_MKSTUBS(diaElemHex)247 DIA_MKSTUBS(diaElemHex)
248 // ****************** diaElemMatrix ********************
249 diaElemMatrix ::diaElemMatrix(uint8_t *trix,const char *toggleTitle, uint32_t trixSize,const char *tip):
250 diaElem(ELEM_MATRIX)
251 {
252 ADM_assert(Factory);
253 internalPointer=Factory->CreateMatrix(trix,toggleTitle,trixSize,tip);
254 }
~diaElemMatrix()255 diaElemMatrix ::~diaElemMatrix()
256 {
257 ADM_assert(Factory);
258 Factory->DestroyMatrix(internalPointer);
259 internalPointer=NULL;
260 }
enable(uint32_t onoff)261 void diaElemMatrix::enable(uint32_t onoff)
262 {
263 ADM_assert(internalPointer);
264 internalPointer->enable(onoff);
265 }
DIA_MKSTUBS(diaElemMatrix)266 DIA_MKSTUBS(diaElemMatrix)
267 // ****************** diaElemMenu ********************
268 diaElemMenu ::diaElemMenu(uint32_t *intValue,const char *itle, uint32_t nb,
269 const diaMenuEntry *menu,const char *tip):
270 diaElemMenuBase()
271 {
272 ADM_assert(Factory);
273 internalPointer=Factory->CreateMenu(intValue, itle, nb, menu,tip);
274 }
~diaElemMenu()275 diaElemMenu ::~diaElemMenu()
276 {
277 ADM_assert(Factory);
278 Factory->DestroyMenu(internalPointer);
279 internalPointer=NULL;
280 }
enable(uint32_t onoff)281 void diaElemMenu::enable(uint32_t onoff)
282 {
283 ADM_assert(internalPointer);
284 internalPointer->enable(onoff);
285 }
link(diaMenuEntry * entry,uint32_t onoff,diaElem * w)286 uint8_t diaElemMenu::link(diaMenuEntry *entry,uint32_t onoff,diaElem *w)
287 {
288 diaElemMenuBase *cast=(diaElemMenuBase *)internalPointer;
289 cast->link(entry,onoff,w);
290 return 1;
291 }
updateMe(void)292 void diaElemMenu::updateMe(void)
293 {
294
295
296 }
finalize(void)297 void diaElemMenu::finalize(void)
298 {
299 internalPointer->finalize();
300 }
DIA_MKSTUBS(diaElemMenu)301 DIA_MKSTUBS(diaElemMenu)
302 // ****************** diaElemMenuDynamic ********************
303 diaElemMenuDynamic ::diaElemMenuDynamic(uint32_t *intValue,const char *itle, uint32_t nb,
304 diaMenuEntryDynamic **menu,const char *tip):
305 diaElemMenuDynamicBase()
306 {
307 ADM_assert(Factory);
308 internalPointer=Factory->CreateMenuDynamic(intValue, itle, nb, menu,tip);
309 }
~diaElemMenuDynamic()310 diaElemMenuDynamic ::~diaElemMenuDynamic()
311 {
312 ADM_assert(Factory);
313 Factory->DestroyMenuDynamic(internalPointer);
314 internalPointer=NULL;
315 }
enable(uint32_t onoff)316 void diaElemMenuDynamic::enable(uint32_t onoff)
317 {
318 ADM_assert(internalPointer);
319 internalPointer->enable(onoff);
320 }
link(diaMenuEntryDynamic * entry,uint32_t onoff,diaElem * w)321 uint8_t diaElemMenuDynamic::link(diaMenuEntryDynamic *entry,uint32_t onoff,diaElem *w)
322 {
323 diaElemMenuDynamicBase *cast=(diaElemMenuDynamicBase *)internalPointer;
324 cast->link(entry,onoff,w);
325 return 1;
326 }
finalize(void)327 void diaElemMenuDynamic::finalize(void)
328 {
329 internalPointer->finalize();
330 }
updateMe(void)331 void diaElemMenuDynamic::updateMe(void)
332 {
333
334
335 }
336
DIA_MKSTUBS(diaElemMenuDynamic)337 DIA_MKSTUBS(diaElemMenuDynamic)
338 // ****************** diaElemMatrix ********************
339 diaElemThreadCount ::diaElemThreadCount(uint32_t *value, const char *title, const char *tip):
340 diaElem(ELEM_THREAD_COUNT)
341 {
342 ADM_assert(Factory);
343 internalPointer=Factory->CreateThreadCount(value,title,tip);
344 }
~diaElemThreadCount()345 diaElemThreadCount ::~diaElemThreadCount()
346 {
347 ADM_assert(Factory);
348 Factory->DestroyThreadCount(internalPointer);
349 internalPointer=NULL;
350 }
DIA_MKSTUBS(diaElemThreadCount)351 DIA_MKSTUBS(diaElemThreadCount)
352
353 // ****************** diaElemBitrate ********************
354 diaElemBitrate ::diaElemBitrate(COMPRES_PARAMS *p,const char *toggleTitle,const char *tip):
355 diaElemBitrateBase()
356 {
357 ADM_assert(Factory);
358 internalPointer=Factory->CreateBitrate(p,toggleTitle,tip);
359 }
~diaElemBitrate()360 diaElemBitrate ::~diaElemBitrate()
361 {
362 ADM_assert(Factory);
363 Factory->DestroyBitrate(internalPointer);
364 internalPointer=NULL;
365 }
updateMe()366 void diaElemBitrate::updateMe()
367 {
368
369 }
setMaxQz(uint32_t qz)370 void diaElemBitrate::setMaxQz(uint32_t qz)
371 {
372 diaElemBitrateBase *cast=(diaElemBitrateBase *)internalPointer;
373 cast->setMaxQz(qz);
374
375 }
enable(uint32_t onoff)376 void diaElemBitrate::enable(uint32_t onoff)
377 {
378 ADM_assert(internalPointer);
379 internalPointer->enable(onoff);
380 }
DIA_MKSTUBS(diaElemBitrate)381 DIA_MKSTUBS(diaElemBitrate)
382 // ****************** diaElemFile ********************
383 diaElemFile ::diaElemFile(uint32_t writeMode,std::string &filename,const char *toggleTitle,
384 const char *defaultSuffix ,const char *tip)
385 {
386 ADM_assert(Factory);
387 internalPointer=Factory->CreateFile(writeMode,filename,toggleTitle,defaultSuffix,tip);
388 }
~diaElemFile()389 diaElemFile ::~diaElemFile()
390 {
391 ADM_assert(Factory);
392 Factory->DestroyBitrate(internalPointer);
393 internalPointer=NULL;
394 }
enable(uint32_t onoff)395 void diaElemFile::enable(uint32_t onoff)
396 {
397 ADM_assert(internalPointer);
398 internalPointer->enable(onoff);
399 }
changeFile(void)400 void diaElemFile::changeFile(void)
401 {
402 diaElemFileBase *cast=(diaElemFileBase *)internalPointer;
403 cast->changeFile();
404 }
DIA_MKSTUBS(diaElemFile)405 DIA_MKSTUBS(diaElemFile)
406
407 // ****************** diaElemDirSelect ********************
408 diaElemDirSelect ::diaElemDirSelect(std::string &filename,const char *toggleTitle,const char *tip):
409 diaElemDirSelectBase()
410 {
411 ADM_assert(Factory);
412 internalPointer=Factory->CreateDir( filename, toggleTitle, tip);
413 }
~diaElemDirSelect()414 diaElemDirSelect ::~diaElemDirSelect()
415 {
416 ADM_assert(Factory);
417 Factory->DestroyBitrate(internalPointer);
418 internalPointer=NULL;
419 }
enable(uint32_t onoff)420 void diaElemDirSelect::enable(uint32_t onoff)
421 {
422 ADM_assert(internalPointer);
423 internalPointer->enable(onoff);
424 }
changeFile(void)425 void diaElemDirSelect::changeFile(void)
426 {
427 diaElemDirSelectBase *cast=(diaElemDirSelectBase *)internalPointer;
428 cast->changeFile();
429 }
DIA_MKSTUBS(diaElemDirSelect)430 DIA_MKSTUBS(diaElemDirSelect)
431 // ****************** diaElemFrame ********************
432 diaElemFrame ::diaElemFrame(const char *toggleTitle, const char *tip):
433 diaElemFrameBase()
434 {
435 ADM_assert(Factory);
436 internalPointer=Factory->CreateFrame( toggleTitle, tip);
437 }
~diaElemFrame()438 diaElemFrame ::~diaElemFrame()
439 {
440 ADM_assert(Factory);
441 Factory->DestroyFrame(internalPointer);
442 internalPointer=NULL;
443 }
enable(uint32_t onoff)444 void diaElemFrame::enable(uint32_t onoff)
445 {
446 ADM_assert(internalPointer);
447 internalPointer->enable(onoff);
448 }
swallow(diaElem * widget)449 void diaElemFrame::swallow(diaElem *widget)
450 {
451 diaElemFrameBase *cast=(diaElemFrameBase *)internalPointer;
452 cast->swallow(widget);
453 }
454
finalize(void)455 void diaElemFrame::finalize(void)
456 {
457 internalPointer->finalize();
458
459 }
460
DIA_MKSTUBS(diaElemFrame)461 DIA_MKSTUBS(diaElemFrame)
462 // ****************** diaElemToggleUint ********************
463 diaElemToggleUint ::diaElemToggleUint(uint32_t *toggleValue,const char *toggleTitle, uint32_t *uintval, const char *name,uint32_t min,uint32_t max,const char *tip):
464 diaElem(ELEM_TOGGLE_UINT)
465 {
466 ADM_assert(Factory);
467 internalPointer=Factory->CreateToggleUint(toggleValue,toggleTitle,uintval,name,min,max,tip);
468 }
~diaElemToggleUint()469 diaElemToggleUint ::~diaElemToggleUint()
470 {
471
472 ADM_assert(Factory);
473 Factory->DestroyToggleUint(internalPointer);
474 internalPointer=NULL;
475 }
finalize(void)476 void diaElemToggleUint::finalize(void)
477 {
478 ADM_assert(internalPointer);
479 internalPointer->finalize();
480 }
enable(uint32_t onoff)481 void diaElemToggleUint::enable(uint32_t onoff)
482 {
483 ADM_assert(internalPointer);
484 internalPointer->enable(onoff);
485 }
DIA_MKSTUBS(diaElemToggleUint)486 DIA_MKSTUBS(diaElemToggleUint)
487 // ****************** diaElemAspectRatio ********************
488 diaElemAspectRatio ::diaElemAspectRatio(uint32_t *num,uint32_t *den,const char *toggleTitle,const char *tip):
489 diaElem(ELEM_ASPECT_RATIO)
490 {
491 ADM_assert(Factory);
492 internalPointer=Factory->CreateAspectRatio(num,den,toggleTitle,tip);
493 }
~diaElemAspectRatio()494 diaElemAspectRatio ::~diaElemAspectRatio()
495 {
496
497 ADM_assert(Factory);
498 Factory->DestroyAspectRatio(internalPointer);
499 internalPointer=NULL;
500 }
finalize(void)501 void diaElemAspectRatio::finalize(void)
502 {
503 ADM_assert(internalPointer);
504 internalPointer->finalize();
505 }
enable(uint32_t onoff)506 void diaElemAspectRatio::enable(uint32_t onoff)
507 {
508 ADM_assert(internalPointer);
509 internalPointer->enable(onoff);
510 }
DIA_MKSTUBS(diaElemAspectRatio)511 DIA_MKSTUBS(diaElemAspectRatio)
512 // ****************** diaElemToggleInt ********************
513 diaElemToggleInt ::diaElemToggleInt(uint32_t *toggleValue,const char *toggleTitle, int32_t *uintval,
514 const char *name,int32_t min,int32_t max,const char *tip):
515 diaElem(ELEM_TOGGLE_INT)
516 {
517 ADM_assert(Factory);
518 internalPointer=Factory->CreateToggleInt(toggleValue,toggleTitle,uintval,name,min,max,tip);
519 }
~diaElemToggleInt()520 diaElemToggleInt ::~diaElemToggleInt()
521 {
522
523 ADM_assert(Factory);
524 Factory->DestroyToggleInt(internalPointer);
525 internalPointer=NULL;
526 }
finalize(void)527 void diaElemToggleInt::finalize(void)
528 {
529 ADM_assert(internalPointer);
530 internalPointer->finalize();
531 }
enable(uint32_t onoff)532 void diaElemToggleInt::enable(uint32_t onoff)
533 {
534 ADM_assert(internalPointer);
535 internalPointer->enable(onoff);
536 }
DIA_MKSTUBS(diaElemToggleInt)537 DIA_MKSTUBS(diaElemToggleInt)
538 // ****************** diaElemToggle ********************
539 diaElemToggle ::diaElemToggle(bool *toggleValue,const char *toggleTitle, const char *tip):
540 diaElemToggleBase()
541 {
542 ADM_assert(Factory);
543 internalPointer=Factory->CreateToggle(toggleValue,toggleTitle,tip);
544 }
~diaElemToggle()545 diaElemToggle ::~diaElemToggle()
546 {
547
548 ADM_assert(Factory);
549 Factory->DestroyToggle(internalPointer);
550 internalPointer=NULL;
551 }
finalize(void)552 void diaElemToggle::finalize(void)
553 {
554 ADM_assert(internalPointer);
555 internalPointer->finalize();
556 }
enable(uint32_t onoff)557 void diaElemToggle::enable(uint32_t onoff)
558 {
559 ADM_assert(internalPointer);
560 internalPointer->enable(onoff);
561 }
link(uint32_t onoff,diaElem * w)562 uint8_t diaElemToggle::link(uint32_t onoff,diaElem *w)
563 {
564 diaElemToggleBase *cast=(diaElemToggleBase *)internalPointer;
565 cast->link(onoff,w);
566 return 1;
567 }
DIA_MKSTUBS(diaElemToggle)568 DIA_MKSTUBS(diaElemToggle)
569 //
570 // ****************** diaElemUSlider ********************
571 diaElemUSlider ::diaElemUSlider(uint32_t *value,const char *toggleTitle, uint32_t min,uint32_t max,uint32_t incr , const char *tip):
572 diaElemSliderBase()
573 {
574 ADM_assert(Factory);
575 internalPointer=Factory->CreateUSlider(value,toggleTitle,min,max,incr,tip);
576 }
~diaElemUSlider()577 diaElemUSlider ::~diaElemUSlider()
578 {
579
580 ADM_assert(Factory);
581 Factory->DestroyUSlider(internalPointer);
582 internalPointer=NULL;
583 }
enable(uint32_t onoff)584 void diaElemUSlider::enable(uint32_t onoff)
585 {
586 ADM_assert(internalPointer);
587 internalPointer->enable(onoff);
588 }
setDigits(uint32_t digits)589 uint8_t diaElemUSlider::setDigits(uint32_t digits)
590 {
591 diaElemSliderBase *cast=(diaElemSliderBase *)internalPointer;
592 cast->setDigits(digits);
593 return 1;
594 }
DIA_MKSTUBS(diaElemUSlider)595 DIA_MKSTUBS(diaElemUSlider)
596 // ****************** diaElemSlider ********************
597 diaElemSlider ::diaElemSlider(int32_t *value,const char *toggleTitle, int32_t min,int32_t max,int32_t incr , const char *tip):
598 diaElemSliderBase()
599 {
600 ADM_assert(Factory);
601 internalPointer=Factory->CreateSlider(value,toggleTitle,min,max,incr,tip);
602 }
~diaElemSlider()603 diaElemSlider ::~diaElemSlider()
604 {
605
606 ADM_assert(Factory);
607 Factory->DestroySlider(internalPointer);
608 internalPointer=NULL;
609 }
enable(uint32_t onoff)610 void diaElemSlider::enable(uint32_t onoff)
611 {
612 ADM_assert(internalPointer);
613 internalPointer->enable(onoff);
614 }
setDigits(uint32_t digits)615 uint8_t diaElemSlider::setDigits(uint32_t digits)
616 {
617 diaElemSliderBase *cast=(diaElemSliderBase *)internalPointer;
618 cast->setDigits(digits);
619 return 1;
620 }
621 DIA_MKSTUBS(diaElemSlider)
622 //
623 // EOF
624