[7497] | 1 | #ifndef RC_H |
---|
| 2 | #define RC_H |
---|
| 3 | |
---|
[15746] | 4 | int sendtuxtxt(int code) |
---|
[9300] | 5 | { |
---|
[15746] | 6 | int rc; |
---|
| 7 | |
---|
| 8 | if((rc = open("/tmp/block.tmp", O_RDONLY)) >= 0) |
---|
| 9 | { |
---|
| 10 | close(rc); |
---|
| 11 | |
---|
| 12 | if(status.fdrctxt <= 0) |
---|
| 13 | { |
---|
| 14 | struct sockaddr_un vAddr; |
---|
| 15 | vAddr.sun_family = AF_UNIX; |
---|
| 16 | strcpy(vAddr.sun_path, "/tmp/rc.socket"); |
---|
| 17 | status.fdrctxt = socket(PF_UNIX, SOCK_STREAM, 0); |
---|
| 18 | |
---|
| 19 | if(status.fdrctxt <= 0) |
---|
| 20 | { |
---|
| 21 | err("open tuxtxt rc socket"); |
---|
| 22 | return 1; |
---|
| 23 | }; |
---|
[9300] | 24 | |
---|
[15746] | 25 | if(connect(status.fdrctxt, (struct sockaddr *)&vAddr, sizeof(vAddr)) !=0) |
---|
| 26 | { |
---|
| 27 | close(status.fdrctxt); |
---|
| 28 | status.fdrctxt = -1; |
---|
| 29 | err("connect to tuxtxt rc socket"); |
---|
| 30 | return 1; |
---|
| 31 | } |
---|
| 32 | } |
---|
| 33 | |
---|
| 34 | if(status.fdrctxt > 0) |
---|
| 35 | { |
---|
| 36 | char* tmpstr = malloc(8); |
---|
| 37 | if(tmpstr != NULL) |
---|
| 38 | { |
---|
| 39 | sprintf(tmpstr, "%08d", code); |
---|
| 40 | |
---|
| 41 | if(write(status.fdrctxt, tmpstr, 8) <= 0) |
---|
| 42 | { |
---|
| 43 | err("forwarding to rc socket"); |
---|
| 44 | close(status.fdrctxt); |
---|
| 45 | status.fdrctxt = -1; |
---|
| 46 | free(tmpstr); tmpstr = NULL; |
---|
| 47 | return 1; |
---|
| 48 | } |
---|
| 49 | } |
---|
| 50 | free(tmpstr); tmpstr = NULL; |
---|
| 51 | } |
---|
| 52 | else |
---|
| 53 | { |
---|
| 54 | err("forwarding to rc socket"); |
---|
| 55 | } |
---|
| 56 | return 0; |
---|
| 57 | } |
---|
| 58 | |
---|
| 59 | if(status.fdrctxt != -1) |
---|
[9300] | 60 | { |
---|
[15746] | 61 | close(status.fdrctxt); |
---|
| 62 | status.fdrctxt = -1; |
---|
[9300] | 63 | } |
---|
| 64 | return 0; |
---|
| 65 | } |
---|
| 66 | |
---|
[9275] | 67 | int maprc(int rccode, struct skin* owner) |
---|
| 68 | { |
---|
| 69 | if(owner != NULL) |
---|
| 70 | { |
---|
| 71 | struct rcmap* rcmapnode = getrcmap(owner->name, rccode); |
---|
| 72 | if(rcmapnode != NULL) |
---|
| 73 | rccode = rcmapnode->newkey; |
---|
| 74 | } |
---|
| 75 | |
---|
| 76 | return rccode; |
---|
| 77 | } |
---|
| 78 | |
---|
[7497] | 79 | struct rc* getrc(int key, struct skin* owner) |
---|
| 80 | { |
---|
| 81 | struct rc *node = rc; |
---|
| 82 | |
---|
| 83 | while(node != NULL) |
---|
| 84 | { |
---|
[7804] | 85 | if(node->key == key && node->owner == owner) |
---|
[7497] | 86 | return node; |
---|
| 87 | |
---|
| 88 | node = node->next; |
---|
| 89 | } |
---|
[7804] | 90 | |
---|
| 91 | node = rc; |
---|
| 92 | |
---|
| 93 | while(node != NULL) |
---|
| 94 | { |
---|
| 95 | if(node->key == key && node->owner == NULL) |
---|
| 96 | return node; |
---|
| 97 | |
---|
| 98 | node = node->next; |
---|
| 99 | } |
---|
[7497] | 100 | return NULL; |
---|
| 101 | } |
---|
| 102 | |
---|
| 103 | int openrc() |
---|
| 104 | { |
---|
| 105 | char *rcdev = NULL; |
---|
| 106 | int i = 0; |
---|
| 107 | |
---|
[7532] | 108 | status.fdrc = -1; |
---|
| 109 | |
---|
[7506] | 110 | rcdev = getconfig("rcdev", NULL); |
---|
[7497] | 111 | if(rcdev != NULL) |
---|
| 112 | { |
---|
[7532] | 113 | while(status.fdrc < 0 && i < 3) |
---|
[7497] | 114 | { |
---|
[15845] | 115 | status.fdrc = open(rcdev, O_RDWR); |
---|
[7532] | 116 | if(status.fdrc < 0) sleep(1); |
---|
[7524] | 117 | i++; |
---|
[7497] | 118 | } |
---|
| 119 | |
---|
[7532] | 120 | if(status.fdrc < 0) |
---|
[7497] | 121 | { |
---|
| 122 | err("open input device %s", rcdev); |
---|
| 123 | return 1; |
---|
| 124 | } |
---|
[8238] | 125 | closeonexec(status.fdrc); |
---|
[7497] | 126 | } |
---|
| 127 | else |
---|
| 128 | { |
---|
| 129 | err("input device not found in config"); |
---|
| 130 | return 1; |
---|
| 131 | } |
---|
| 132 | |
---|
| 133 | return 0; |
---|
| 134 | } |
---|
| 135 | |
---|
| 136 | void closerc() |
---|
| 137 | { |
---|
[7532] | 138 | if(status.fdrc != -1) |
---|
| 139 | close(status.fdrc); |
---|
[7497] | 140 | } |
---|
| 141 | |
---|
[12226] | 142 | int islongkey(int keycode) |
---|
| 143 | { |
---|
| 144 | int i = 0; |
---|
| 145 | |
---|
| 146 | for(i = 0; i < MAXLONGKEY; i++) |
---|
| 147 | { |
---|
| 148 | if(status.longkeycode[i] == keycode) |
---|
| 149 | return 1; |
---|
| 150 | } |
---|
| 151 | return 0; |
---|
| 152 | } |
---|
| 153 | |
---|
[9300] | 154 | int writerc(int keycode) |
---|
| 155 | { |
---|
[29558] | 156 | int ret = 0; |
---|
[9300] | 157 | struct input_event rcdata; |
---|
| 158 | struct timeval akttime; |
---|
| 159 | |
---|
| 160 | gettimeofday(&akttime, 0); |
---|
[15746] | 161 | sendtuxtxt(keycode); |
---|
| 162 | |
---|
[9300] | 163 | rcdata.time = akttime; |
---|
| 164 | rcdata.type = EV_KEY; |
---|
| 165 | rcdata.code = keycode; |
---|
| 166 | rcdata.value = 1; |
---|
[29558] | 167 | ret = write(status.fdrc, &rcdata, sizeof(rcdata)); |
---|
[15746] | 168 | |
---|
[29558] | 169 | #ifdef MIPSEL |
---|
[15682] | 170 | rcdata.time = akttime; |
---|
[29558] | 171 | rcdata.type = 0; |
---|
| 172 | rcdata.code = 0; |
---|
| 173 | rcdata.value = 0; |
---|
| 174 | ret = write(status.fdrc, &rcdata, sizeof(rcdata)); |
---|
| 175 | #endif |
---|
| 176 | |
---|
| 177 | rcdata.time = akttime; |
---|
[15682] | 178 | rcdata.type = EV_KEY; |
---|
| 179 | rcdata.code = keycode; |
---|
| 180 | rcdata.value = 0; |
---|
[29558] | 181 | ret = write(status.fdrc, &rcdata, sizeof(rcdata)); |
---|
| 182 | |
---|
| 183 | #ifdef MIPSEL |
---|
| 184 | rcdata.time = akttime; |
---|
| 185 | rcdata.type = 0; |
---|
| 186 | rcdata.code = 0; |
---|
| 187 | rcdata.value = 0; |
---|
| 188 | ret = write(status.fdrc, &rcdata, sizeof(rcdata)); |
---|
| 189 | #endif |
---|
[15746] | 190 | |
---|
[29558] | 191 | return ret; |
---|
[9300] | 192 | } |
---|
| 193 | |
---|
[15462] | 194 | int flushrc(unsigned int timeout) |
---|
| 195 | { |
---|
| 196 | fd_set rfds; |
---|
| 197 | struct timeval tv; |
---|
| 198 | struct input_event rcdata; |
---|
| 199 | int rest = 0, count = 0; |
---|
| 200 | int ret = 0, len = 0; |
---|
| 201 | |
---|
| 202 | rest = timeout % 1000; |
---|
| 203 | timeout = (timeout - rest) / 1000; |
---|
| 204 | |
---|
| 205 | while(count < 10) |
---|
| 206 | { |
---|
| 207 | count++; |
---|
| 208 | tv.tv_sec = timeout; |
---|
| 209 | tv.tv_usec = rest * 1000; |
---|
| 210 | FD_ZERO(&rfds); |
---|
| 211 | FD_SET(status.fdrc, &rfds); |
---|
| 212 | |
---|
| 213 | ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv)); |
---|
| 214 | |
---|
| 215 | if(ret < 1) break; |
---|
| 216 | if(FD_ISSET(status.fdrc, &rfds)) |
---|
| 217 | { |
---|
| 218 | count = 0; |
---|
| 219 | len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event))); |
---|
| 220 | } |
---|
| 221 | } |
---|
[15746] | 222 | |
---|
| 223 | return 0; |
---|
[15462] | 224 | } |
---|
| 225 | |
---|
[39734] | 226 | void rcsignal(int flag) |
---|
| 227 | { |
---|
[39746] | 228 | if(checkbox("DM900") == 1 && status.standby == 0) |
---|
[39734] | 229 | { |
---|
| 230 | int art = getconfigint("dm900frontrun", NULL); |
---|
| 231 | if(flag == 1) |
---|
| 232 | { |
---|
| 233 | if(art == 0) |
---|
| 234 | writesys("/proc/stb/fp/led1_pattern", "ffffffff", 1); |
---|
| 235 | else if(art == 1) |
---|
| 236 | writesys("/proc/stb/fp/led0_pattern", "ffffffff", 1); |
---|
| 237 | else if(art == 2) |
---|
| 238 | writesys("/proc/stb/fp/led1_pattern", "ffffffff", 1); |
---|
| 239 | } |
---|
| 240 | if(flag == 0) |
---|
| 241 | { |
---|
| 242 | if(art == 0) |
---|
| 243 | writesys("/proc/stb/fp/led1_pattern", "00000000", 1); |
---|
| 244 | else if(art == 1) |
---|
| 245 | writesys("/proc/stb/fp/led0_pattern", "00000000", 1); |
---|
| 246 | else if(art == 2) |
---|
| 247 | writesys("/proc/stb/fp/led1_pattern", "00000000", 1); |
---|
| 248 | } |
---|
| 249 | } |
---|
| 250 | } |
---|
| 251 | |
---|
[16574] | 252 | int waitrcext(struct skin* owner, unsigned int timeout, int screencalc, int filelistview) |
---|
[7497] | 253 | { |
---|
| 254 | fd_set rfds; |
---|
| 255 | struct timeval tv; |
---|
[7763] | 256 | struct input_event rcdata; |
---|
[8399] | 257 | int treffer = 0, rest = 0; |
---|
[15462] | 258 | int ret = 0, len = 0, fromthread = 0, longpress = 0, longpresscount = 0; |
---|
[7497] | 259 | struct rc *node; |
---|
[28462] | 260 | struct timeval aktrctime; |
---|
[7497] | 261 | |
---|
[9630] | 262 | if(pthread_self() != status.mainthread) |
---|
| 263 | fromthread = 1; |
---|
| 264 | |
---|
[8399] | 265 | rest = timeout % 1000; |
---|
| 266 | timeout = (timeout - rest) / 1000; |
---|
[7497] | 267 | |
---|
[8399] | 268 | if(timeout == 0 && rest == 0) timeout = 0x7fffffff; |
---|
| 269 | |
---|
[7497] | 270 | while(treffer == 0) |
---|
| 271 | { |
---|
[8646] | 272 | tv.tv_sec = timeout; |
---|
| 273 | tv.tv_usec = rest * 1000; |
---|
[9300] | 274 | FD_ZERO(&rfds); |
---|
| 275 | FD_SET(status.fdrc, &rfds); |
---|
| 276 | |
---|
[9630] | 277 | if(fromthread == 0) status.sec = 0; |
---|
| 278 | if((fromthread == 0 && status.rckey == 0) || fromthread == 1) |
---|
[8646] | 279 | { |
---|
[21386] | 280 | if(fromthread == 0) m_unlock(&status.waitrcmutex, 24); |
---|
[15746] | 281 | ret = TEMP_FAILURE_RETRY(select(status.fdrc + 1, &rfds, NULL, NULL, &tv)); |
---|
[21386] | 282 | if(fromthread == 0) m_lock(&status.waitrcmutex, 24); |
---|
| 283 | |
---|
[22985] | 284 | if((status.rcowner != NULL && status.rcowner != owner) || (status.rcstandby != NULL && status.rcstandby != owner)) |
---|
[8646] | 285 | { |
---|
[22985] | 286 | if(status.rcstandby == NULL || status.rcstandby != owner) |
---|
| 287 | { |
---|
| 288 | usleep(100000); |
---|
| 289 | continue; |
---|
| 290 | } |
---|
[8646] | 291 | } |
---|
| 292 | } |
---|
[9630] | 293 | if(fromthread == 0) status.sec = time(NULL); |
---|
[7497] | 294 | |
---|
[9630] | 295 | if((fromthread == 0 && ret > 0 && status.rckey == 0) || (fromthread == 1 && ret > 0)) |
---|
[7497] | 296 | { |
---|
[9300] | 297 | if(FD_ISSET(status.fdrc, &rfds)) |
---|
[10380] | 298 | len = TEMP_FAILURE_RETRY(read(status.fdrc, &rcdata, sizeof(struct input_event))); |
---|
[7497] | 299 | |
---|
[7934] | 300 | if(rcdata.type != EV_KEY) |
---|
[8255] | 301 | { |
---|
| 302 | usleep(10000); |
---|
[7934] | 303 | continue; |
---|
[8255] | 304 | } |
---|
[12216] | 305 | if(rcdata.value == 0) //release |
---|
[8255] | 306 | { |
---|
[39734] | 307 | rcsignal(0); |
---|
[39803] | 308 | #ifdef DREAMBOX |
---|
| 309 | if(longpresscount > 0) |
---|
| 310 | { |
---|
| 311 | rcdata.code = longpress; |
---|
| 312 | if(longpresscount > 3) rcdata.code = longpress + 3000; |
---|
| 313 | ret = rcdata.code; |
---|
| 314 | break; |
---|
| 315 | } |
---|
| 316 | #endif |
---|
[8255] | 317 | usleep(10000); |
---|
[7934] | 318 | continue; |
---|
[8255] | 319 | } |
---|
[39734] | 320 | else |
---|
| 321 | rcsignal(1); |
---|
[12216] | 322 | |
---|
[12226] | 323 | if(islongkey(rcdata.code)) |
---|
[12216] | 324 | { |
---|
| 325 | longpress = rcdata.code; |
---|
| 326 | longpresscount++; |
---|
| 327 | timeout = 0; |
---|
[39803] | 328 | #ifdef DREAMBOX |
---|
| 329 | if(longpresscount == 1) |
---|
| 330 | rest = 700; |
---|
| 331 | else |
---|
| 332 | rest = 500; |
---|
| 333 | #else |
---|
[12230] | 334 | rest = 500; |
---|
[39803] | 335 | #endif |
---|
[12216] | 336 | usleep(10000); |
---|
| 337 | continue; |
---|
| 338 | } |
---|
[28462] | 339 | |
---|
| 340 | gettimeofday(&aktrctime, NULL); |
---|
| 341 | if(status.rcskipms > 0 && ((aktrctime.tv_sec - rcdata.time.tv_sec) * 1000000LL + aktrctime.tv_usec - rcdata.time.tv_usec) > status.rcskipms) |
---|
[8255] | 342 | { |
---|
| 343 | usleep(10000); |
---|
[7934] | 344 | continue; |
---|
[8255] | 345 | } |
---|
[28462] | 346 | |
---|
[28464] | 347 | // printf(".\n"); |
---|
[28462] | 348 | |
---|
[7934] | 349 | debug(100, "key code=%d, type=%d, value=%d", rcdata.code, rcdata.type, rcdata.value); |
---|
| 350 | treffer = 1; |
---|
[9275] | 351 | rcdata.code = maprc(rcdata.code, owner); |
---|
[7497] | 352 | |
---|
[7934] | 353 | node = getrc(rcdata.code, owner); |
---|
| 354 | if(node != NULL && node->rcfunc != NULL) |
---|
[11112] | 355 | { |
---|
| 356 | if(fromthread == 0) |
---|
[16574] | 357 | node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0); |
---|
[11112] | 358 | else |
---|
[16574] | 359 | node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2); |
---|
[11112] | 360 | } |
---|
[7497] | 361 | |
---|
[7934] | 362 | ret = rcdata.code; |
---|
[7497] | 363 | #ifdef SIMULATE |
---|
[7934] | 364 | if(ret == 16) treffer = 0; |
---|
[7497] | 365 | #endif |
---|
| 366 | } |
---|
[9630] | 367 | else if((fromthread == 0 && ret == 0 && status.rckey == 0) || (fromthread == 1 && ret == 0)) //timeout |
---|
[7497] | 368 | { |
---|
[12217] | 369 | rcdata.code = 0; |
---|
[12216] | 370 | if(longpress > 0) |
---|
| 371 | { |
---|
| 372 | rcdata.code = longpress; |
---|
| 373 | if(longpresscount > 5) rcdata.code = longpress + 3000; |
---|
| 374 | } |
---|
[7497] | 375 | treffer = 1; |
---|
[9275] | 376 | rcdata.code = maprc(rcdata.code, owner); |
---|
| 377 | |
---|
[12217] | 378 | node = getrc(rcdata.code, NULL); |
---|
[7497] | 379 | if(node != NULL && node->rcfunc != NULL) |
---|
[11112] | 380 | { |
---|
| 381 | if(fromthread == 0) |
---|
[16574] | 382 | node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0); |
---|
[11112] | 383 | else |
---|
[16574] | 384 | node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2); |
---|
[11112] | 385 | } |
---|
[12216] | 386 | if(longpress > 0) |
---|
| 387 | ret = rcdata.code; |
---|
| 388 | else |
---|
| 389 | ret = RCTIMEOUT; |
---|
[7497] | 390 | } |
---|
[9630] | 391 | else if(fromthread == 0 && status.rckey != 0) |
---|
[7639] | 392 | { |
---|
| 393 | treffer = 1; |
---|
[9275] | 394 | rcdata.code = maprc(rcdata.code, owner); |
---|
| 395 | |
---|
[7639] | 396 | node = getrc(status.rckey, owner); |
---|
| 397 | if(node != NULL && node->rcfunc != NULL) |
---|
[11112] | 398 | { |
---|
| 399 | if(fromthread == 0) |
---|
[16574] | 400 | node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 0); |
---|
[11112] | 401 | else |
---|
[16574] | 402 | node->rcfunc(node->screen, node->screennode, screencalc, filelistview, 2); |
---|
[11112] | 403 | } |
---|
[7639] | 404 | ret = status.rckey; |
---|
| 405 | status.rckey = 0; |
---|
| 406 | } |
---|
[7497] | 407 | else |
---|
| 408 | { |
---|
| 409 | treffer = 1; |
---|
| 410 | perr("select failed"); |
---|
| 411 | } |
---|
| 412 | } |
---|
[7763] | 413 | |
---|
[19519] | 414 | if(ret != RCTIMEOUT) |
---|
| 415 | status.lastrcaction = time(NULL); |
---|
[7497] | 416 | return ret; |
---|
| 417 | } |
---|
| 418 | |
---|
[16574] | 419 | int waitrc(struct skin* owner, unsigned int timeout, int screencalc) |
---|
| 420 | { |
---|
[16577] | 421 | return waitrcext(owner, timeout, screencalc, 0); |
---|
[16574] | 422 | } |
---|
| 423 | |
---|
[7497] | 424 | struct rc* addrc(int key, void *func, struct skin* screen, struct skin *screennode) |
---|
| 425 | { |
---|
| 426 | struct rc *newnode, *node = rc; |
---|
| 427 | struct rc **nodeaddr; |
---|
| 428 | |
---|
| 429 | newnode = (struct rc*)malloc(sizeof(struct rc)); |
---|
| 430 | if(newnode == NULL) |
---|
| 431 | { |
---|
| 432 | err("no memory"); |
---|
| 433 | return NULL; |
---|
| 434 | } |
---|
| 435 | |
---|
| 436 | memset(newnode, 0, sizeof(struct rc)); |
---|
| 437 | newnode->key = key; |
---|
| 438 | newnode->rcfunc = func; |
---|
| 439 | newnode->screen = screen; |
---|
| 440 | newnode->screennode = screennode; |
---|
| 441 | newnode->owner = screen; |
---|
| 442 | |
---|
| 443 | if(node != NULL) |
---|
| 444 | { |
---|
| 445 | while(node != NULL) |
---|
| 446 | { |
---|
| 447 | if(node->key == key && node->owner == screen) |
---|
| 448 | { |
---|
| 449 | node->rcfunc = func; |
---|
| 450 | node->screen = screen; |
---|
| 451 | node->screennode = screennode; |
---|
| 452 | free(newnode); |
---|
| 453 | newnode = NULL; |
---|
| 454 | return node; |
---|
| 455 | } |
---|
| 456 | nodeaddr = &node->next; |
---|
| 457 | node = node->next; |
---|
| 458 | } |
---|
| 459 | *nodeaddr = newnode; |
---|
| 460 | } |
---|
| 461 | else |
---|
| 462 | rc = newnode; |
---|
| 463 | |
---|
| 464 | return newnode; |
---|
| 465 | } |
---|
| 466 | |
---|
[8087] | 467 | void delrc(int key, struct skin* owner, struct skin* screennode) |
---|
[7497] | 468 | { |
---|
| 469 | struct rc *node = rc, *prev = rc; |
---|
| 470 | |
---|
| 471 | while(node != NULL) |
---|
| 472 | { |
---|
[8087] | 473 | if(node->key == key && node->owner == owner && node->screennode == screennode) |
---|
[7497] | 474 | { |
---|
| 475 | if(node == rc) |
---|
| 476 | rc = node->next; |
---|
| 477 | else |
---|
| 478 | prev->next = node->next; |
---|
| 479 | |
---|
| 480 | free(node); |
---|
| 481 | node = NULL; |
---|
| 482 | break; |
---|
| 483 | } |
---|
| 484 | |
---|
| 485 | prev = node; |
---|
| 486 | node = node->next; |
---|
| 487 | } |
---|
| 488 | } |
---|
| 489 | |
---|
| 490 | void delownerrc(struct skin* owner) |
---|
| 491 | { |
---|
| 492 | struct rc *node = rc, *prev = rc; |
---|
| 493 | |
---|
| 494 | while(node != NULL) |
---|
| 495 | { |
---|
| 496 | prev = node; |
---|
| 497 | node = node->next; |
---|
| 498 | if(prev != NULL && prev->owner == owner) |
---|
[8087] | 499 | delrc(prev->key, prev->owner, prev->screennode); |
---|
[7497] | 500 | } |
---|
| 501 | } |
---|
| 502 | |
---|
| 503 | void freerc() |
---|
| 504 | { |
---|
| 505 | struct rc *node = rc, *prev = rc; |
---|
| 506 | |
---|
| 507 | while(node != NULL) |
---|
| 508 | { |
---|
| 509 | prev = node; |
---|
| 510 | node = node->next; |
---|
| 511 | if(prev != NULL) |
---|
[8087] | 512 | delrc(prev->key, prev->owner, prev->screennode); |
---|
[7497] | 513 | } |
---|
| 514 | } |
---|
| 515 | |
---|
| 516 | #endif |
---|