-rw-r--r-- | libopie2/opiecore/device/odevice.cpp | 623 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice.h | 329 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice_ipaq.cpp | 524 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice_jornada.cpp | 214 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice_ramses.cpp | 317 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice_simpad.cpp | 443 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice_yopy.cpp | 212 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevice_zaurus.cpp | 790 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevicebutton.cpp | 246 | ||||
-rw-r--r-- | libopie2/opiecore/device/odevicebutton.h | 108 |
10 files changed, 3806 insertions, 0 deletions
diff --git a/libopie2/opiecore/device/odevice.cpp b/libopie2/opiecore/device/odevice.cpp new file mode 100644 index 0000000..0f88c3c --- a/dev/null +++ b/libopie2/opiecore/device/odevice.cpp | |||
@@ -0,0 +1,623 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | using namespace Opie; | ||
70 | |||
71 | class iPAQ; | ||
72 | class Zaurus; | ||
73 | class SIMpad; | ||
74 | class Ramses; | ||
75 | class Jornada; | ||
76 | |||
77 | ODevice *ODevice::inst() | ||
78 | { | ||
79 | static ODevice *dev = 0; | ||
80 | |||
81 | // rewrite this to only use /proc/devinfo or so | ||
82 | |||
83 | /* | ||
84 | if ( !dev ) { | ||
85 | if ( QFile::exists ( "/proc/hal/model" )) | ||
86 | dev = new iPAQ(); | ||
87 | else if ( Zaurus::isZaurus() ) | ||
88 | dev = new Zaurus(); | ||
89 | else if ( QFile::exists ( "/proc/ucb1x00" ) && QFile::exists ( "/proc/cs3" )) | ||
90 | dev = new SIMpad(); | ||
91 | else if ( QFile::exists ( "/proc/sys/board/name" )) | ||
92 | dev = new Ramses(); | ||
93 | else if ( Yopy::isYopy() ) | ||
94 | dev = new Yopy(); | ||
95 | else if ( Jornada::isJornada() ) | ||
96 | dev = new Jornada(); | ||
97 | else | ||
98 | dev = new ODevice(); | ||
99 | dev->init(); | ||
100 | } | ||
101 | */ | ||
102 | return dev; | ||
103 | } | ||
104 | |||
105 | ODevice::ODevice() | ||
106 | { | ||
107 | d = new ODeviceData; | ||
108 | |||
109 | d->m_modelstr = "Unknown"; | ||
110 | d->m_model = Model_Unknown; | ||
111 | d->m_vendorstr = "Unknown"; | ||
112 | d->m_vendor = Vendor_Unknown; | ||
113 | d->m_systemstr = "Unknown"; | ||
114 | d->m_system = System_Unknown; | ||
115 | d->m_sysverstr = "0.0"; | ||
116 | d->m_rotation = Rot0; | ||
117 | d->m_direction = CW; | ||
118 | |||
119 | d->m_holdtime = 1000; // 1000ms | ||
120 | d->m_buttons = 0; | ||
121 | d->m_cpu_frequencies = new QStrList; | ||
122 | } | ||
123 | |||
124 | void ODevice::systemMessage ( const QCString &msg, const QByteArray & ) | ||
125 | { | ||
126 | if ( msg == "deviceButtonMappingChanged()" ) { | ||
127 | reloadButtonMapping(); | ||
128 | } | ||
129 | } | ||
130 | |||
131 | void ODevice::init() | ||
132 | { | ||
133 | } | ||
134 | |||
135 | /** | ||
136 | * This method initialises the button mapping | ||
137 | */ | ||
138 | void ODevice::initButtons() | ||
139 | { | ||
140 | if ( d->m_buttons ) | ||
141 | return; | ||
142 | |||
143 | qDebug ( "init Buttons" ); | ||
144 | d->m_buttons = new QValueList <ODeviceButton>; | ||
145 | |||
146 | reloadButtonMapping(); | ||
147 | |||
148 | QCopChannel *sysch = new QCopChannel ( "QPE/System", this ); | ||
149 | connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & ))); | ||
150 | } | ||
151 | |||
152 | ODevice::~ODevice() | ||
153 | { | ||
154 | // we leak m_devicebuttons and m_cpu_frequency | ||
155 | // but it's a singleton and it is not so importantant | ||
156 | // -zecke | ||
157 | delete d; | ||
158 | } | ||
159 | |||
160 | bool ODevice::setSoftSuspend ( bool /*soft*/ ) | ||
161 | { | ||
162 | return false; | ||
163 | } | ||
164 | |||
165 | //#include <linux/apm_bios.h> | ||
166 | |||
167 | #define APM_IOC_SUSPEND OD_IO( 'A', 2 ) | ||
168 | |||
169 | /** | ||
170 | * This method will try to suspend the device | ||
171 | * It only works if the user is the QWS Server and the apm application | ||
172 | * is installed. | ||
173 | * It tries to suspend and then waits some time cause some distributions | ||
174 | * do have asynchronus apm implementations. | ||
175 | * This method will either fail and return false or it'll suspend the | ||
176 | * device and return once the device got woken up | ||
177 | * | ||
178 | * @return if the device got suspended | ||
179 | */ | ||
180 | bool ODevice::suspend() | ||
181 | { | ||
182 | qDebug("ODevice::suspend"); | ||
183 | if ( !isQWS( ) ) // only qwsserver is allowed to suspend | ||
184 | return false; | ||
185 | |||
186 | if ( d->m_model == Model_Unknown ) // better don't suspend in qvfb / on unkown devices | ||
187 | return false; | ||
188 | |||
189 | bool res = false; | ||
190 | |||
191 | struct timeval tvs, tvn; | ||
192 | ::gettimeofday ( &tvs, 0 ); | ||
193 | |||
194 | ::sync(); // flush fs caches | ||
195 | res = ( ::system ( "apm --suspend" ) == 0 ); | ||
196 | |||
197 | // This is needed because the iPAQ apm implementation is asynchronous and we | ||
198 | // can not be sure when exactly the device is really suspended | ||
199 | // This can be deleted as soon as a stable familiar with a synchronous apm implementation exists. | ||
200 | |||
201 | if ( res ) { | ||
202 | do { // wait at most 1.5 sec: either suspend didn't work or the device resumed | ||
203 | ::usleep ( 200 * 1000 ); | ||
204 | ::gettimeofday ( &tvn, 0 ); | ||
205 | } while ((( tvn. tv_sec - tvs. tv_sec ) * 1000 + ( tvn. tv_usec - tvs. tv_usec ) / 1000 ) < 1500 ); | ||
206 | } | ||
207 | |||
208 | return res; | ||
209 | } | ||
210 | |||
211 | //#include <linux/fb.h> better not rely on kernel headers in userspace ... | ||
212 | |||
213 | #define FBIOBLANK OD_IO( 'F', 0x11 ) // 0x4611 | ||
214 | |||
215 | /* VESA Blanking Levels */ | ||
216 | #define VESA_NO_BLANKING 0 | ||
217 | #define VESA_VSYNC_SUSPEND 1 | ||
218 | #define VESA_HSYNC_SUSPEND 2 | ||
219 | #define VESA_POWERDOWN 3 | ||
220 | |||
221 | /** | ||
222 | * This sets the display on or off | ||
223 | */ | ||
224 | bool ODevice::setDisplayStatus ( bool on ) | ||
225 | { | ||
226 | qDebug("ODevice::setDisplayStatus(%d)", on); | ||
227 | |||
228 | if ( d->m_model == Model_Unknown ) | ||
229 | return false; | ||
230 | |||
231 | bool res = false; | ||
232 | int fd; | ||
233 | |||
234 | if (( fd = ::open ( "/dev/fb0", O_RDWR )) >= 0 ) { | ||
235 | res = ( ::ioctl ( fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN ) == 0 ); | ||
236 | ::close ( fd ); | ||
237 | } | ||
238 | return res; | ||
239 | } | ||
240 | |||
241 | /** | ||
242 | * This sets the display brightness | ||
243 | * | ||
244 | * @param p The brightness to be set on a scale from 0 to 255 | ||
245 | * @return success or failure | ||
246 | */ | ||
247 | bool ODevice::setDisplayBrightness ( int p) | ||
248 | { | ||
249 | Q_UNUSED( p ) | ||
250 | return false; | ||
251 | } | ||
252 | |||
253 | /** | ||
254 | * @return returns the number of steppings on the brightness slider | ||
255 | * in the Light-'n-Power settings. | ||
256 | */ | ||
257 | int ODevice::displayBrightnessResolution() const | ||
258 | { | ||
259 | return 16; | ||
260 | } | ||
261 | |||
262 | /** | ||
263 | * This sets the display contrast | ||
264 | * @param p The contrast to be set on a scale from 0 to 255 | ||
265 | * @return success or failure | ||
266 | */ | ||
267 | bool ODevice::setDisplayContrast ( int p) | ||
268 | { | ||
269 | Q_UNUSED( p ) | ||
270 | return false; | ||
271 | } | ||
272 | |||
273 | /** | ||
274 | * @return return the max value for the brightness settings slider | ||
275 | * or 0 if the device doesn't support setting of a contrast | ||
276 | */ | ||
277 | int ODevice::displayContrastResolution() const | ||
278 | { | ||
279 | return 0; | ||
280 | } | ||
281 | |||
282 | /** | ||
283 | * This returns the vendor as string | ||
284 | * @return Vendor as QString | ||
285 | */ | ||
286 | QString ODevice::vendorString() const | ||
287 | { | ||
288 | return d->m_vendorstr; | ||
289 | } | ||
290 | |||
291 | /** | ||
292 | * This returns the vendor as one of the values of OVendor | ||
293 | * @return OVendor | ||
294 | */ | ||
295 | OVendor ODevice::vendor() const | ||
296 | { | ||
297 | return d->m_vendor; | ||
298 | } | ||
299 | |||
300 | /** | ||
301 | * This returns the model as a string | ||
302 | * @return A string representing the model | ||
303 | */ | ||
304 | QString ODevice::modelString() const | ||
305 | { | ||
306 | return d->m_modelstr; | ||
307 | } | ||
308 | |||
309 | /** | ||
310 | * This does return the OModel used | ||
311 | */ | ||
312 | OModel ODevice::model() const | ||
313 | { | ||
314 | return d->m_model; | ||
315 | } | ||
316 | |||
317 | /** | ||
318 | * This does return the systen name | ||
319 | */ | ||
320 | QString ODevice::systemString() const | ||
321 | { | ||
322 | return d->m_systemstr; | ||
323 | } | ||
324 | |||
325 | /** | ||
326 | * Return System as OSystem value | ||
327 | */ | ||
328 | OSystem ODevice::system() const | ||
329 | { | ||
330 | return d->m_system; | ||
331 | } | ||
332 | |||
333 | /** | ||
334 | * @return the version string of the base system | ||
335 | */ | ||
336 | QString ODevice::systemVersionString() const | ||
337 | { | ||
338 | return d->m_sysverstr; | ||
339 | } | ||
340 | |||
341 | /** | ||
342 | * @return the current Transformation | ||
343 | */ | ||
344 | Transformation ODevice::rotation() const | ||
345 | { | ||
346 | return d->m_rotation; | ||
347 | } | ||
348 | |||
349 | /** | ||
350 | * @return the current rotation direction | ||
351 | */ | ||
352 | ODirection ODevice::direction() const | ||
353 | { | ||
354 | return d->m_direction; | ||
355 | } | ||
356 | |||
357 | /** | ||
358 | * This plays an alarmSound | ||
359 | */ | ||
360 | void ODevice::alarmSound() | ||
361 | { | ||
362 | #ifndef QT_NO_SOUND | ||
363 | static Sound snd ( "alarm" ); | ||
364 | |||
365 | if ( snd. isFinished()) | ||
366 | snd. play(); | ||
367 | #endif | ||
368 | } | ||
369 | |||
370 | /** | ||
371 | * This plays a key sound | ||
372 | */ | ||
373 | void ODevice::keySound() | ||
374 | { | ||
375 | #ifndef QT_NO_SOUND | ||
376 | static Sound snd ( "keysound" ); | ||
377 | |||
378 | if ( snd. isFinished()) | ||
379 | snd. play(); | ||
380 | #endif | ||
381 | } | ||
382 | |||
383 | /** | ||
384 | * This plays a touch sound | ||
385 | */ | ||
386 | void ODevice::touchSound() | ||
387 | { | ||
388 | #ifndef QT_NO_SOUND | ||
389 | static Sound snd ( "touchsound" ); | ||
390 | |||
391 | if ( snd. isFinished()) | ||
392 | snd. play(); | ||
393 | #endif | ||
394 | } | ||
395 | |||
396 | /** | ||
397 | * This method will return a list of leds | ||
398 | * available on this device | ||
399 | * @return a list of LEDs. | ||
400 | */ | ||
401 | QValueList <OLed> ODevice::ledList() const | ||
402 | { | ||
403 | return QValueList <OLed>(); | ||
404 | } | ||
405 | |||
406 | /** | ||
407 | * This does return the state of the LEDs | ||
408 | */ | ||
409 | QValueList <OLedState> ODevice::ledStateList ( OLed /*which*/ ) const | ||
410 | { | ||
411 | return QValueList <OLedState>(); | ||
412 | } | ||
413 | |||
414 | /** | ||
415 | * @return the state for a given OLed | ||
416 | */ | ||
417 | OLedState ODevice::ledState ( OLed /*which*/ ) const | ||
418 | { | ||
419 | return Led_Off; | ||
420 | } | ||
421 | |||
422 | /** | ||
423 | * Set the state for a LED | ||
424 | * @param which Which OLed to use | ||
425 | * @param st The state to set | ||
426 | * @return success or failure | ||
427 | */ | ||
428 | bool ODevice::setLedState ( OLed which, OLedState st ) | ||
429 | { | ||
430 | Q_UNUSED( which ) | ||
431 | Q_UNUSED( st ) | ||
432 | return false; | ||
433 | } | ||
434 | |||
435 | /** | ||
436 | * @return if the device has a light sensor | ||
437 | */ | ||
438 | bool ODevice::hasLightSensor() const | ||
439 | { | ||
440 | return false; | ||
441 | } | ||
442 | |||
443 | /** | ||
444 | * @return a value from the light sensor | ||
445 | */ | ||
446 | int ODevice::readLightSensor() | ||
447 | { | ||
448 | return -1; | ||
449 | } | ||
450 | |||
451 | /** | ||
452 | * @return the light sensor resolution | ||
453 | */ | ||
454 | int ODevice::lightSensorResolution() const | ||
455 | { | ||
456 | return 0; | ||
457 | } | ||
458 | |||
459 | /** | ||
460 | * @return if the device has a hinge sensor | ||
461 | */ | ||
462 | bool ODevice::hasHingeSensor() const | ||
463 | { | ||
464 | return false; | ||
465 | } | ||
466 | |||
467 | /** | ||
468 | * @return a value from the hinge sensor | ||
469 | */ | ||
470 | OHingeStatus ODevice::readHingeSensor() | ||
471 | { | ||
472 | return CASE_UNKNOWN; | ||
473 | } | ||
474 | |||
475 | /** | ||
476 | * @return a list with CPU frequencies supported by the hardware | ||
477 | */ | ||
478 | const QStrList &ODevice::allowedCpuFrequencies() const | ||
479 | { | ||
480 | return *d->m_cpu_frequencies; | ||
481 | } | ||
482 | |||
483 | |||
484 | /** | ||
485 | * Set desired CPU frequency | ||
486 | * | ||
487 | * @param index index into d->m_cpu_frequencies of the frequency to be set | ||
488 | */ | ||
489 | bool ODevice::setCurrentCpuFrequency(uint index) | ||
490 | { | ||
491 | if (index >= d->m_cpu_frequencies->count()) | ||
492 | return false; | ||
493 | |||
494 | char *freq = d->m_cpu_frequencies->at(index); | ||
495 | qWarning("set freq to %s", freq); | ||
496 | |||
497 | int fd; | ||
498 | |||
499 | if ((fd = ::open("/proc/sys/cpu/0/speed", O_WRONLY)) >= 0) { | ||
500 | char writeCommand[50]; | ||
501 | const int count = sprintf(writeCommand, "%s\n", freq); | ||
502 | int res = (::write(fd, writeCommand, count) != -1); | ||
503 | ::close(fd); | ||
504 | return res; | ||
505 | } | ||
506 | |||
507 | return false; | ||
508 | } | ||
509 | |||
510 | |||
511 | /** | ||
512 | * @return a list of hardware buttons | ||
513 | */ | ||
514 | const QValueList <ODeviceButton> &ODevice::buttons() | ||
515 | { | ||
516 | initButtons(); | ||
517 | |||
518 | return *d->m_buttons; | ||
519 | } | ||
520 | |||
521 | /** | ||
522 | * @return The amount of time that would count as a hold | ||
523 | */ | ||
524 | uint ODevice::buttonHoldTime() const | ||
525 | { | ||
526 | return d->m_holdtime; | ||
527 | } | ||
528 | |||
529 | /** | ||
530 | * This method return a ODeviceButton for a key code | ||
531 | * or 0 if no special hardware button is available for the device | ||
532 | * | ||
533 | * @return The devicebutton or 0l | ||
534 | * @see ODeviceButton | ||
535 | */ | ||
536 | const ODeviceButton *ODevice::buttonForKeycode ( ushort code ) | ||
537 | { | ||
538 | initButtons(); | ||
539 | |||
540 | for ( QValueListConstIterator<ODeviceButton> it = d->m_buttons->begin(); it != d->m_buttons->end(); ++it ) { | ||
541 | if ( (*it). keycode() == code ) | ||
542 | return &(*it); | ||
543 | } | ||
544 | return 0; | ||
545 | } | ||
546 | |||
547 | void ODevice::reloadButtonMapping() | ||
548 | { | ||
549 | initButtons(); | ||
550 | |||
551 | Config cfg ( "ButtonSettings" ); | ||
552 | |||
553 | for ( uint i = 0; i < d->m_buttons->count(); i++ ) { | ||
554 | ODeviceButton &b = ( *d->m_buttons ) [i]; | ||
555 | QString group = "Button" + QString::number ( i ); | ||
556 | |||
557 | QCString pch, hch; | ||
558 | QCString pm, hm; | ||
559 | QByteArray pdata, hdata; | ||
560 | |||
561 | if ( cfg. hasGroup ( group )) { | ||
562 | cfg. setGroup ( group ); | ||
563 | pch = cfg. readEntry ( "PressedActionChannel" ). latin1(); | ||
564 | pm = cfg. readEntry ( "PressedActionMessage" ). latin1(); | ||
565 | // pdata = decodeBase64 ( buttonFile. readEntry ( "PressedActionArgs" )); | ||
566 | |||
567 | hch = cfg. readEntry ( "HeldActionChannel" ). latin1(); | ||
568 | hm = cfg. readEntry ( "HeldActionMessage" ). latin1(); | ||
569 | // hdata = decodeBase64 ( buttonFile. readEntry ( "HeldActionArgs" )); | ||
570 | } | ||
571 | |||
572 | b. setPressedAction ( OQCopMessage ( pch, pm, pdata )); | ||
573 | |||
574 | b. setHeldAction ( OQCopMessage ( hch, hm, hdata )); | ||
575 | } | ||
576 | } | ||
577 | |||
578 | void ODevice::remapPressedAction ( int button, const OQCopMessage &action ) | ||
579 | { | ||
580 | initButtons(); | ||
581 | |||
582 | QString mb_chan; | ||
583 | |||
584 | if ( button >= (int) d->m_buttons->count()) | ||
585 | return; | ||
586 | |||
587 | ODeviceButton &b = ( *d->m_buttons ) [button]; | ||
588 | b. setPressedAction ( action ); | ||
589 | |||
590 | mb_chan=b. pressedAction(). channel(); | ||
591 | |||
592 | Config buttonFile ( "ButtonSettings" ); | ||
593 | buttonFile. setGroup ( "Button" + QString::number ( button )); | ||
594 | buttonFile. writeEntry ( "PressedActionChannel", (const char*) mb_chan); | ||
595 | buttonFile. writeEntry ( "PressedActionMessage", (const char*) b. pressedAction(). message()); | ||
596 | |||
597 | //buttonFile. writeEntry ( "PressedActionArgs", encodeBase64 ( b. pressedAction(). data())); | ||
598 | |||
599 | QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" ); | ||
600 | } | ||
601 | |||
602 | void ODevice::remapHeldAction ( int button, const OQCopMessage &action ) | ||
603 | { | ||
604 | initButtons(); | ||
605 | |||
606 | if ( button >= (int) d->m_buttons->count()) | ||
607 | return; | ||
608 | |||
609 | ODeviceButton &b = ( *d->m_buttons ) [button]; | ||
610 | b. setHeldAction ( action ); | ||
611 | |||
612 | Config buttonFile ( "ButtonSettings" ); | ||
613 | buttonFile. setGroup ( "Button" + QString::number ( button )); | ||
614 | buttonFile. writeEntry ( "HeldActionChannel", (const char *) b. heldAction(). channel()); | ||
615 | buttonFile. writeEntry ( "HeldActionMessage", (const char *) b. heldAction(). message()); | ||
616 | |||
617 | //buttonFile. writeEntry ( "HeldActionArgs", decodeBase64 ( b. heldAction(). data())); | ||
618 | |||
619 | QCopEnvelope ( "QPE/System", "deviceButtonMappingChanged()" ); | ||
620 | } | ||
621 | void ODevice::virtual_hook(int, void* ){ | ||
622 | |||
623 | } | ||
diff --git a/libopie2/opiecore/device/odevice.h b/libopie2/opiecore/device/odevice.h new file mode 100644 index 0000000..bde6411 --- a/dev/null +++ b/libopie2/opiecore/device/odevice.h | |||
@@ -0,0 +1,329 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #ifndef ODEVICE_H_ | ||
31 | #define ODEVICE_H_ | ||
32 | |||
33 | #include <opie2/odevicebutton.h> | ||
34 | |||
35 | /* QT */ | ||
36 | #include <qnamespace.h> | ||
37 | #include <qobject.h> | ||
38 | #include <qstring.h> | ||
39 | #include <qstrlist.h> | ||
40 | |||
41 | #include <qpe/qpeapplication.h> /* for Transformation enum.. */ | ||
42 | |||
43 | namespace Opie | ||
44 | { | ||
45 | class ODeviceData; | ||
46 | /** | ||
47 | * The available devices | ||
48 | */ | ||
49 | enum OModel { | ||
50 | Model_Unknown, // = 0 | ||
51 | |||
52 | Model_Series_Mask = 0xff000000, | ||
53 | |||
54 | Model_iPAQ = ( 1 << 24 ), | ||
55 | |||
56 | Model_iPAQ_All = ( Model_iPAQ | 0xffffff ), | ||
57 | Model_iPAQ_H31xx = ( Model_iPAQ | 0x000001 ), | ||
58 | Model_iPAQ_H36xx = ( Model_iPAQ | 0x000002 ), | ||
59 | Model_iPAQ_H37xx = ( Model_iPAQ | 0x000004 ), | ||
60 | Model_iPAQ_H38xx = ( Model_iPAQ | 0x000008 ), | ||
61 | Model_iPAQ_H39xx = ( Model_iPAQ | 0x000010 ), | ||
62 | Model_iPAQ_H5xxx = ( Model_iPAQ | 0x000011 ), | ||
63 | |||
64 | Model_Jornada = ( 6 << 24 ), | ||
65 | Model_Jornada_56x = ( Model_Jornada | 0x000001 ), | ||
66 | |||
67 | Model_Zaurus = ( 2 << 24 ), | ||
68 | |||
69 | Model_Zaurus_SL5000 = ( Model_Zaurus | 0x000001 ), | ||
70 | Model_Zaurus_SL5500 = ( Model_Zaurus | 0x000002 ), | ||
71 | Model_Zaurus_SLA300 = ( Model_Zaurus | 0x000003 ), | ||
72 | Model_Zaurus_SLB600 = ( Model_Zaurus | 0x000004 ), | ||
73 | Model_Zaurus_SLC7x0 = ( Model_Zaurus | 0x000005 ), | ||
74 | |||
75 | Model_SIMpad = ( 3 << 24 ), | ||
76 | |||
77 | Model_SIMpad_All = ( Model_SIMpad | 0xffffff ), | ||
78 | Model_SIMpad_CL4 = ( Model_SIMpad | 0x000001 ), | ||
79 | Model_SIMpad_SL4 = ( Model_SIMpad | 0x000002 ), | ||
80 | Model_SIMpad_SLC = ( Model_SIMpad | 0x000004 ), | ||
81 | Model_SIMpad_TSinus = ( Model_SIMpad | 0x000008 ), | ||
82 | |||
83 | Model_Ramses = ( 4 << 24 ), | ||
84 | |||
85 | Model_Ramses_All = ( Model_Ramses | 0xffffff ), | ||
86 | Model_Ramses_MNCI = ( Model_Ramses | 0x000001 ), | ||
87 | |||
88 | Model_Yopy = ( 5 << 24 ), | ||
89 | |||
90 | Model_Yopy_All = ( Model_Yopy | 0xffffff ), | ||
91 | Model_Yopy_3000 = ( Model_Yopy | 0x000001 ), | ||
92 | Model_Yopy_3500 = ( Model_Yopy | 0x000002 ), | ||
93 | Model_Yopy_3700 = ( Model_Yopy | 0x000003 ), | ||
94 | |||
95 | }; | ||
96 | |||
97 | /** | ||
98 | * The vendor of the device | ||
99 | */ | ||
100 | enum OVendor { | ||
101 | Vendor_Unknown, | ||
102 | |||
103 | Vendor_HP, | ||
104 | Vendor_Sharp, | ||
105 | Vendor_SIEMENS, | ||
106 | Vendor_MundN, | ||
107 | Vendor_GMate, | ||
108 | }; | ||
109 | |||
110 | /** | ||
111 | * The System used | ||
112 | */ | ||
113 | enum OSystem { | ||
114 | System_Unknown, | ||
115 | |||
116 | System_Familiar, | ||
117 | System_Zaurus, | ||
118 | System_OpenZaurus, | ||
119 | System_Linupy, | ||
120 | }; | ||
121 | |||
122 | enum OLedState { | ||
123 | Led_Off, | ||
124 | Led_On, | ||
125 | Led_BlinkSlow, | ||
126 | Led_BlinkFast | ||
127 | }; | ||
128 | |||
129 | enum OLed { | ||
130 | Led_Mail, | ||
131 | Led_Power, | ||
132 | Led_BlueTooth | ||
133 | }; | ||
134 | |||
135 | enum OHardKey { | ||
136 | HardKey_Datebook = Qt::Key_F9, | ||
137 | HardKey_Contacts = Qt::Key_F10, | ||
138 | HardKey_Menu = Qt::Key_F11, | ||
139 | HardKey_Home = Qt::Key_F12, | ||
140 | HardKey_Mail = Qt::Key_F13, | ||
141 | HardKey_Record = Qt::Key_F24, | ||
142 | HardKey_Suspend = Qt::Key_F34, | ||
143 | HardKey_Backlight = Qt::Key_F35, | ||
144 | HardKey_Action = Qt::Key_F10, | ||
145 | HardKey_OK = Qt::Key_F11, | ||
146 | HardKey_End = Qt::Key_F12, | ||
147 | }; | ||
148 | |||
149 | enum ODirection { | ||
150 | CW = 0, | ||
151 | CCW = 1, | ||
152 | Flip = 2, | ||
153 | }; | ||
154 | |||
155 | enum OHingeStatus { | ||
156 | CASE_CLOSED = 3, | ||
157 | CASE_PORTRAIT = 2, | ||
158 | CASE_LANDSCAPE = 0, | ||
159 | CASE_UNKNOWN = 1, | ||
160 | }; | ||
161 | |||
162 | /** | ||
163 | * A singleton which gives informations about device specefic option | ||
164 | * like the Hardware used, LEDs, the Base Distribution and | ||
165 | * hardware key mappings. | ||
166 | * | ||
167 | * @short A small class for device specefic options | ||
168 | * @see QObject | ||
169 | * @author Robert Griebl | ||
170 | * @version 1.0 | ||
171 | */ | ||
172 | class ODevice : public QObject | ||
173 | { | ||
174 | Q_OBJECT | ||
175 | |||
176 | private: | ||
177 | /* disable copy */ | ||
178 | ODevice ( const ODevice & ); | ||
179 | |||
180 | protected: | ||
181 | ODevice(); | ||
182 | virtual void init(); | ||
183 | virtual void initButtons(); | ||
184 | |||
185 | ODeviceData *d; | ||
186 | |||
187 | public: | ||
188 | // sandman do we want to allow destructions? -zecke? | ||
189 | virtual ~ODevice(); | ||
190 | |||
191 | static ODevice *inst(); | ||
192 | |||
193 | // information | ||
194 | |||
195 | QString modelString() const; | ||
196 | OModel model() const; | ||
197 | inline OModel series() const { return (OModel) ( model() & Model_Series_Mask ); } | ||
198 | |||
199 | QString vendorString() const; | ||
200 | OVendor vendor() const; | ||
201 | |||
202 | QString systemString() const; | ||
203 | OSystem system() const; | ||
204 | |||
205 | QString systemVersionString() const; | ||
206 | |||
207 | virtual Transformation rotation() const; | ||
208 | virtual ODirection direction() const; | ||
209 | |||
210 | // system | ||
211 | |||
212 | virtual bool setSoftSuspend ( bool on ); | ||
213 | virtual bool suspend(); | ||
214 | |||
215 | virtual bool setDisplayStatus ( bool on ); | ||
216 | virtual bool setDisplayBrightness ( int brightness ); | ||
217 | virtual int displayBrightnessResolution() const; | ||
218 | virtual bool setDisplayContrast ( int contrast ); | ||
219 | virtual int displayContrastResolution() const; | ||
220 | |||
221 | // don't add new virtual methods, use this: | ||
222 | ///*virtual */ void boo(int i ) { return virtual_hook(1,&i); }; | ||
223 | // and in your subclass do do overwrite | ||
224 | //protected virtual int virtual_hook(int, void *) | ||
225 | // which is defined below | ||
226 | |||
227 | // input / output | ||
228 | //FIXME playAlarmSound and al might be better -zecke | ||
229 | virtual void alarmSound(); | ||
230 | virtual void keySound(); | ||
231 | virtual void touchSound(); | ||
232 | |||
233 | virtual QValueList <OLed> ledList() const; | ||
234 | virtual QValueList <OLedState> ledStateList ( OLed led ) const; | ||
235 | virtual OLedState ledState ( OLed led ) const; | ||
236 | virtual bool setLedState ( OLed led, OLedState st ); | ||
237 | |||
238 | virtual bool hasLightSensor() const; | ||
239 | virtual int readLightSensor(); | ||
240 | virtual int lightSensorResolution() const; | ||
241 | |||
242 | virtual bool hasHingeSensor() const; | ||
243 | virtual OHingeStatus readHingeSensor(); | ||
244 | |||
245 | const QStrList &allowedCpuFrequencies() const; | ||
246 | bool setCurrentCpuFrequency(uint index); | ||
247 | |||
248 | /** | ||
249 | * Returns the available buttons on this device. The number and location | ||
250 | * of buttons will vary depending on the device. Button numbers will be assigned | ||
251 | * by the device manufacturer and will be from most preferred button to least preffered | ||
252 | * button. Note that this list only contains "user mappable" buttons. | ||
253 | */ | ||
254 | const QValueList<ODeviceButton> &buttons() /* ### make const */; | ||
255 | |||
256 | /** | ||
257 | * Returns the DeviceButton for the \a keyCode. If \a keyCode is not found, it | ||
258 | * returns 0L | ||
259 | */ | ||
260 | const ODeviceButton *buttonForKeycode ( ushort keyCode ); | ||
261 | |||
262 | /** | ||
263 | * Reassigns the pressed action for \a button. To return to the factory | ||
264 | * default pass an empty string as \a qcopMessage. | ||
265 | */ | ||
266 | void remapPressedAction ( int button, const OQCopMessage &qcopMessage ); | ||
267 | |||
268 | /** | ||
269 | * Reassigns the held action for \a button. To return to the factory | ||
270 | * default pass an empty string as \a qcopMessage. | ||
271 | */ | ||
272 | void remapHeldAction ( int button, const OQCopMessage &qcopMessage ); | ||
273 | |||
274 | /** | ||
275 | * How long (in ms) you have to press a button for a "hold" action | ||
276 | */ | ||
277 | uint buttonHoldTime() const; | ||
278 | |||
279 | signals: | ||
280 | void buttonMappingChanged(); | ||
281 | |||
282 | private slots: | ||
283 | void systemMessage ( const QCString &, const QByteArray & ); | ||
284 | |||
285 | protected: | ||
286 | void reloadButtonMapping(); | ||
287 | /* ugly virtual hook */ | ||
288 | virtual void virtual_hook( int id, void* data ); | ||
289 | }; | ||
290 | |||
291 | class ODeviceData { | ||
292 | |||
293 | public: | ||
294 | QString m_vendorstr; | ||
295 | OVendor m_vendor; | ||
296 | |||
297 | QString m_modelstr; | ||
298 | OModel m_model; | ||
299 | |||
300 | QString m_systemstr; | ||
301 | OSystem m_system; | ||
302 | |||
303 | QString m_sysverstr; | ||
304 | |||
305 | Transformation m_rotation; | ||
306 | ODirection m_direction; | ||
307 | |||
308 | QValueList <ODeviceButton> *m_buttons; | ||
309 | uint m_holdtime; | ||
310 | QStrList *m_cpu_frequencies; | ||
311 | }; | ||
312 | |||
313 | } | ||
314 | |||
315 | static inline bool isQWS() | ||
316 | { | ||
317 | return qApp ? ( qApp->type() == QApplication::GuiServer ) : false; | ||
318 | } | ||
319 | |||
320 | static QCString makeChannel ( const char *str ) | ||
321 | { | ||
322 | if ( str && !::strchr ( str, '/' )) | ||
323 | return QCString ( "QPE/Application/" ) + str; | ||
324 | else | ||
325 | return str; | ||
326 | } | ||
327 | |||
328 | #endif | ||
329 | |||
diff --git a/libopie2/opiecore/device/odevice_ipaq.cpp b/libopie2/opiecore/device/odevice_ipaq.cpp new file mode 100644 index 0000000..d928806 --- a/dev/null +++ b/libopie2/opiecore/device/odevice_ipaq.cpp | |||
@@ -0,0 +1,524 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | typedef struct { | ||
70 | unsigned char OffOnBlink; /* 0=off 1=on 2=Blink */ | ||
71 | unsigned char TotalTime; /* Units of 5 seconds */ | ||
72 | unsigned char OnTime; /* units of 100m/s */ | ||
73 | unsigned char OffTime; /* units of 100m/s */ | ||
74 | } LED_IN; | ||
75 | |||
76 | typedef struct { | ||
77 | unsigned char mode; | ||
78 | unsigned char pwr; | ||
79 | unsigned char brightness; | ||
80 | } FLITE_IN; | ||
81 | |||
82 | #define LED_ON OD_IOW( 'f', 5, LED_IN ) | ||
83 | #define FLITE_ON OD_IOW( 'f', 7, FLITE_IN ) | ||
84 | |||
85 | using namespace Opie; | ||
86 | |||
87 | class iPAQ : public ODevice, public QWSServer::KeyboardFilter | ||
88 | { | ||
89 | |||
90 | protected: | ||
91 | virtual void init(); | ||
92 | virtual void initButtons(); | ||
93 | |||
94 | public: | ||
95 | virtual bool setSoftSuspend( bool soft ); | ||
96 | |||
97 | virtual bool setDisplayBrightness( int b ); | ||
98 | virtual int displayBrightnessResolution() const; | ||
99 | |||
100 | virtual void alarmSound(); | ||
101 | |||
102 | virtual QValueList <OLed> ledList() const; | ||
103 | virtual QValueList <OLedState> ledStateList( OLed led ) const; | ||
104 | virtual OLedState ledState( OLed led ) const; | ||
105 | virtual bool setLedState( OLed led, OLedState st ); | ||
106 | |||
107 | virtual bool hasLightSensor() const; | ||
108 | virtual int readLightSensor(); | ||
109 | virtual int lightSensorResolution() const; | ||
110 | |||
111 | protected: | ||
112 | virtual bool filter( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ); | ||
113 | virtual void timerEvent( QTimerEvent *te ); | ||
114 | |||
115 | int m_power_timer; | ||
116 | |||
117 | OLedState m_leds [2]; | ||
118 | }; | ||
119 | |||
120 | struct i_button { | ||
121 | uint model; | ||
122 | Qt::Key code; | ||
123 | char *utext; | ||
124 | char *pix; | ||
125 | char *fpressedservice; | ||
126 | char *fpressedaction; | ||
127 | char *fheldservice; | ||
128 | char *fheldaction; | ||
129 | } ipaq_buttons [] = { | ||
130 | { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx, | ||
131 | Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"), | ||
132 | "devicebuttons/ipaq_calendar", | ||
133 | "datebook", "nextView()", | ||
134 | "today", "raise()" }, | ||
135 | { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx, | ||
136 | Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"), | ||
137 | "devicebuttons/ipaq_contact", | ||
138 | "addressbook", "raise()", | ||
139 | "addressbook", "beamBusinessCard()" }, | ||
140 | { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx, | ||
141 | Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"), | ||
142 | "devicebuttons/ipaq_menu", | ||
143 | "QPE/TaskBar", "toggleMenu()", | ||
144 | "QPE/TaskBar", "toggleStartMenu()" }, | ||
145 | { Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx, | ||
146 | Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"), | ||
147 | "devicebuttons/ipaq_mail", | ||
148 | "mail", "raise()", | ||
149 | "mail", "newMail()" }, | ||
150 | { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx, | ||
151 | Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"), | ||
152 | "devicebuttons/ipaq_home", | ||
153 | "QPE/Launcher", "home()", | ||
154 | "buttonsettings", "raise()" }, | ||
155 | { Model_iPAQ_H31xx | Model_iPAQ_H36xx | Model_iPAQ_H37xx | Model_iPAQ_H38xx | Model_iPAQ_H39xx | Model_iPAQ_H5xxx, | ||
156 | Qt::Key_F24, QT_TRANSLATE_NOOP("Button", "Record Button"), | ||
157 | "devicebuttons/ipaq_record", | ||
158 | "QPE/VMemo", "toggleRecord()", | ||
159 | "sound", "raise()" }, | ||
160 | }; | ||
161 | |||
162 | void iPAQ::init() | ||
163 | { | ||
164 | d->m_vendorstr = "HP"; | ||
165 | d->m_vendor = Vendor_HP; | ||
166 | |||
167 | QFile f ( "/proc/hal/model" ); | ||
168 | |||
169 | if ( f. open ( IO_ReadOnly )) { | ||
170 | QTextStream ts ( &f ); | ||
171 | |||
172 | d->m_modelstr = "H" + ts. readLine(); | ||
173 | |||
174 | if ( d->m_modelstr == "H3100" ) | ||
175 | d->m_model = Model_iPAQ_H31xx; | ||
176 | else if ( d->m_modelstr == "H3600" ) | ||
177 | d->m_model = Model_iPAQ_H36xx; | ||
178 | else if ( d->m_modelstr == "H3700" ) | ||
179 | d->m_model = Model_iPAQ_H37xx; | ||
180 | else if ( d->m_modelstr == "H3800" ) | ||
181 | d->m_model = Model_iPAQ_H38xx; | ||
182 | else if ( d->m_modelstr == "H3900" ) | ||
183 | d->m_model = Model_iPAQ_H39xx; | ||
184 | else if ( d->m_modelstr == "H5400" ) | ||
185 | d->m_model = Model_iPAQ_H5xxx; | ||
186 | else | ||
187 | d->m_model = Model_Unknown; | ||
188 | |||
189 | f. close(); | ||
190 | } | ||
191 | |||
192 | switch ( d->m_model ) { | ||
193 | case Model_iPAQ_H31xx: | ||
194 | case Model_iPAQ_H38xx: | ||
195 | d->m_rotation = Rot90; | ||
196 | break; | ||
197 | case Model_iPAQ_H36xx: | ||
198 | case Model_iPAQ_H37xx: | ||
199 | case Model_iPAQ_H39xx: | ||
200 | |||
201 | default: | ||
202 | d->m_rotation = Rot270; | ||
203 | break; | ||
204 | case Model_iPAQ_H5xxx: | ||
205 | d->m_rotation = Rot0; | ||
206 | } | ||
207 | |||
208 | f. setName ( "/etc/familiar-version" ); | ||
209 | if ( f. open ( IO_ReadOnly )) { | ||
210 | d->m_systemstr = "Familiar"; | ||
211 | d->m_system = System_Familiar; | ||
212 | |||
213 | QTextStream ts ( &f ); | ||
214 | d->m_sysverstr = ts. readLine(). mid ( 10 ); | ||
215 | |||
216 | f. close(); | ||
217 | } else { | ||
218 | f. setName ( "/etc/oz_version" ); | ||
219 | |||
220 | if ( f. open ( IO_ReadOnly )) { | ||
221 | d->m_systemstr = "OpenEmbedded/iPaq"; | ||
222 | d->m_system = System_Familiar; | ||
223 | |||
224 | QTextStream ts ( &f ); | ||
225 | ts.setDevice ( &f ); | ||
226 | d->m_sysverstr = ts. readLine(); | ||
227 | f. close(); | ||
228 | } | ||
229 | } | ||
230 | |||
231 | m_leds [0] = m_leds [1] = Led_Off; | ||
232 | |||
233 | m_power_timer = 0; | ||
234 | |||
235 | } | ||
236 | |||
237 | void iPAQ::initButtons() | ||
238 | { | ||
239 | if ( d->m_buttons ) | ||
240 | return; | ||
241 | |||
242 | if ( isQWS( ) ) | ||
243 | QWSServer::setKeyboardFilter ( this ); | ||
244 | |||
245 | d->m_buttons = new QValueList <ODeviceButton>; | ||
246 | |||
247 | for ( uint i = 0; i < ( sizeof( ipaq_buttons ) / sizeof( i_button )); i++ ) { | ||
248 | i_button *ib = ipaq_buttons + i; | ||
249 | ODeviceButton b; | ||
250 | |||
251 | if (( ib->model & d->m_model ) == d->m_model ) { | ||
252 | b. setKeycode ( ib->code ); | ||
253 | b. setUserText ( QObject::tr ( "Button", ib->utext )); | ||
254 | b. setPixmap ( Resource::loadPixmap ( ib->pix )); | ||
255 | b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( ib->fpressedservice ), ib->fpressedaction )); | ||
256 | b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( ib->fheldservice ), ib->fheldaction )); | ||
257 | |||
258 | d->m_buttons->append ( b ); | ||
259 | } | ||
260 | } | ||
261 | reloadButtonMapping(); | ||
262 | |||
263 | QCopChannel *sysch = new QCopChannel ( "QPE/System", this ); | ||
264 | connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & ))); | ||
265 | } | ||
266 | |||
267 | QValueList <OLed> iPAQ::ledList() const | ||
268 | { | ||
269 | QValueList <OLed> vl; | ||
270 | vl << Led_Power; | ||
271 | |||
272 | if ( d->m_model == Model_iPAQ_H38xx ) | ||
273 | vl << Led_BlueTooth; | ||
274 | return vl; | ||
275 | } | ||
276 | |||
277 | QValueList <OLedState> iPAQ::ledStateList ( OLed l ) const | ||
278 | { | ||
279 | QValueList <OLedState> vl; | ||
280 | |||
281 | if ( l == Led_Power ) | ||
282 | vl << Led_Off << Led_On << Led_BlinkSlow << Led_BlinkFast; | ||
283 | else if ( l == Led_BlueTooth && d->m_model == Model_iPAQ_H38xx ) | ||
284 | vl << Led_Off; // << Led_On << ??? | ||
285 | |||
286 | return vl; | ||
287 | } | ||
288 | |||
289 | OLedState iPAQ::ledState ( OLed l ) const | ||
290 | { | ||
291 | switch ( l ) { | ||
292 | case Led_Power: | ||
293 | return m_leds [0]; | ||
294 | case Led_BlueTooth: | ||
295 | return m_leds [1]; | ||
296 | default: | ||
297 | return Led_Off; | ||
298 | } | ||
299 | } | ||
300 | |||
301 | bool iPAQ::setLedState ( OLed l, OLedState st ) | ||
302 | { | ||
303 | static int fd = ::open ( "/dev/touchscreen/0", O_RDWR | O_NONBLOCK ); | ||
304 | |||
305 | if ( l == Led_Power ) { | ||
306 | if ( fd >= 0 ) { | ||
307 | LED_IN leds; | ||
308 | ::memset ( &leds, 0, sizeof( leds )); | ||
309 | leds. TotalTime = 0; | ||
310 | leds. OnTime = 0; | ||
311 | leds. OffTime = 1; | ||
312 | leds. OffOnBlink = 2; | ||
313 | |||
314 | switch ( st ) { | ||
315 | case Led_Off : leds. OffOnBlink = 0; break; | ||
316 | case Led_On : leds. OffOnBlink = 1; break; | ||
317 | case Led_BlinkSlow: leds. OnTime = 10; leds. OffTime = 10; break; | ||
318 | case Led_BlinkFast: leds. OnTime = 5; leds. OffTime = 5; break; | ||
319 | } | ||
320 | |||
321 | if ( ::ioctl ( fd, LED_ON, &leds ) >= 0 ) { | ||
322 | m_leds [0] = st; | ||
323 | return true; | ||
324 | } | ||
325 | } | ||
326 | } | ||
327 | return false; | ||
328 | } | ||
329 | |||
330 | |||
331 | bool iPAQ::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat ) | ||
332 | { | ||
333 | int newkeycode = keycode; | ||
334 | |||
335 | switch ( keycode ) { | ||
336 | // H38xx/H39xx have no "Q" key anymore - this is now the Mail key | ||
337 | case HardKey_Menu: { | ||
338 | if (( d->m_model == Model_iPAQ_H38xx ) || | ||
339 | ( d->m_model == Model_iPAQ_H39xx ) || | ||
340 | ( d->m_model == Model_iPAQ_H5xxx)) { | ||
341 | newkeycode = HardKey_Mail; | ||
342 | } | ||
343 | break; | ||
344 | } | ||
345 | |||
346 | // Rotate cursor keys 180° | ||
347 | case Key_Left : | ||
348 | case Key_Right: | ||
349 | case Key_Up : | ||
350 | case Key_Down : { | ||
351 | if (( d->m_model == Model_iPAQ_H31xx ) || | ||
352 | ( d->m_model == Model_iPAQ_H38xx )) { | ||
353 | newkeycode = Key_Left + ( keycode - Key_Left + 2 ) % 4; | ||
354 | } | ||
355 | break; | ||
356 | } | ||
357 | |||
358 | // map Power Button short/long press to F34/F35 | ||
359 | case Key_SysReq: { | ||
360 | if ( isPress ) { | ||
361 | if ( m_power_timer ) | ||
362 | killTimer ( m_power_timer ); | ||
363 | m_power_timer = startTimer ( 500 ); | ||
364 | } | ||
365 | else if ( m_power_timer ) { | ||
366 | killTimer ( m_power_timer ); | ||
367 | m_power_timer = 0; | ||
368 | QWSServer::sendKeyEvent ( -1, HardKey_Suspend, 0, true, false ); | ||
369 | QWSServer::sendKeyEvent ( -1, HardKey_Suspend, 0, false, false ); | ||
370 | } | ||
371 | newkeycode = Key_unknown; | ||
372 | break; | ||
373 | } | ||
374 | } | ||
375 | |||
376 | if ( newkeycode != keycode ) { | ||
377 | if ( newkeycode != Key_unknown ) | ||
378 | QWSServer::sendKeyEvent ( -1, newkeycode, modifiers, isPress, autoRepeat ); | ||
379 | return true; | ||
380 | } | ||
381 | else | ||
382 | return false; | ||
383 | } | ||
384 | |||
385 | void iPAQ::timerEvent ( QTimerEvent * ) | ||
386 | { | ||
387 | killTimer ( m_power_timer ); | ||
388 | m_power_timer = 0; | ||
389 | QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, true, false ); | ||
390 | QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, false, false ); | ||
391 | } | ||
392 | |||
393 | |||
394 | void iPAQ::alarmSound() | ||
395 | { | ||
396 | #ifndef QT_NO_SOUND | ||
397 | static Sound snd ( "alarm" ); | ||
398 | int fd; | ||
399 | int vol; | ||
400 | bool vol_reset = false; | ||
401 | |||
402 | if (( fd = ::open ( "/dev/sound/mixer", O_RDWR )) >= 0 ) { | ||
403 | if ( ::ioctl ( fd, MIXER_READ( 0 ), &vol ) >= 0 ) { | ||
404 | Config cfg ( "qpe" ); | ||
405 | cfg. setGroup ( "Volume" ); | ||
406 | |||
407 | int volalarm = cfg. readNumEntry ( "AlarmPercent", 50 ); | ||
408 | if ( volalarm < 0 ) | ||
409 | volalarm = 0; | ||
410 | else if ( volalarm > 100 ) | ||
411 | volalarm = 100; | ||
412 | volalarm |= ( volalarm << 8 ); | ||
413 | |||
414 | if ( ::ioctl ( fd, MIXER_WRITE( 0 ), &volalarm ) >= 0 ) | ||
415 | vol_reset = true; | ||
416 | } | ||
417 | } | ||
418 | |||
419 | snd. play(); | ||
420 | while ( !snd. isFinished()) | ||
421 | qApp->processEvents(); | ||
422 | |||
423 | if ( fd >= 0 ) { | ||
424 | if ( vol_reset ) | ||
425 | ::ioctl ( fd, MIXER_WRITE( 0 ), &vol ); | ||
426 | ::close ( fd ); | ||
427 | } | ||
428 | #endif | ||
429 | } | ||
430 | |||
431 | |||
432 | bool iPAQ::setSoftSuspend ( bool soft ) | ||
433 | { | ||
434 | bool res = false; | ||
435 | int fd; | ||
436 | |||
437 | if (( fd = ::open ( "/proc/sys/ts/suspend_button_mode", O_WRONLY )) >= 0 ) { | ||
438 | if ( ::write ( fd, soft ? "1" : "0", 1 ) == 1 ) | ||
439 | res = true; | ||
440 | else | ||
441 | ::perror ( "write to /proc/sys/ts/suspend_button_mode" ); | ||
442 | |||
443 | ::close ( fd ); | ||
444 | } | ||
445 | else | ||
446 | ::perror ( "/proc/sys/ts/suspend_button_mode" ); | ||
447 | |||
448 | return res; | ||
449 | } | ||
450 | |||
451 | |||
452 | bool iPAQ::setDisplayBrightness ( int bright ) | ||
453 | { | ||
454 | bool res = false; | ||
455 | int fd; | ||
456 | |||
457 | if ( bright > 255 ) | ||
458 | bright = 255; | ||
459 | if ( bright < 0 ) | ||
460 | bright = 0; | ||
461 | |||
462 | if (( fd = ::open ( "/dev/touchscreen/0", O_WRONLY )) >= 0 ) { | ||
463 | FLITE_IN bl; | ||
464 | bl. mode = 1; | ||
465 | bl. pwr = bright ? 1 : 0; | ||
466 | bl. brightness = ( bright * ( displayBrightnessResolution() - 1 ) + 127 ) / 255; | ||
467 | res = ( ::ioctl ( fd, FLITE_ON, &bl ) == 0 ); | ||
468 | ::close ( fd ); | ||
469 | } | ||
470 | return res; | ||
471 | } | ||
472 | |||
473 | int iPAQ::displayBrightnessResolution() const | ||
474 | { | ||
475 | switch ( model()) { | ||
476 | case Model_iPAQ_H31xx: | ||
477 | case Model_iPAQ_H36xx: | ||
478 | case Model_iPAQ_H37xx: | ||
479 | return 128; // really 256, but >128 could damage the LCD | ||
480 | |||
481 | case Model_iPAQ_H38xx: | ||
482 | case Model_iPAQ_H39xx: | ||
483 | return 64; | ||
484 | case Model_iPAQ_H5xxx: | ||
485 | return 255; | ||
486 | |||
487 | default: | ||
488 | return 2; | ||
489 | } | ||
490 | } | ||
491 | |||
492 | |||
493 | bool iPAQ::hasLightSensor() const | ||
494 | { | ||
495 | return true; | ||
496 | } | ||
497 | |||
498 | int iPAQ::readLightSensor() | ||
499 | { | ||
500 | int fd; | ||
501 | int val = -1; | ||
502 | |||
503 | if (( fd = ::open ( "/proc/hal/light_sensor", O_RDONLY )) >= 0 ) { | ||
504 | char buffer [8]; | ||
505 | |||
506 | if ( ::read ( fd, buffer, 5 ) == 5 ) { | ||
507 | char *endptr; | ||
508 | |||
509 | buffer [4] = 0; | ||
510 | val = ::strtol ( buffer + 2, &endptr, 16 ); | ||
511 | |||
512 | if ( *endptr != 0 ) | ||
513 | val = -1; | ||
514 | } | ||
515 | ::close ( fd ); | ||
516 | } | ||
517 | |||
518 | return val; | ||
519 | } | ||
520 | |||
521 | int iPAQ::lightSensorResolution() const | ||
522 | { | ||
523 | return 256; | ||
524 | } | ||
diff --git a/libopie2/opiecore/device/odevice_jornada.cpp b/libopie2/opiecore/device/odevice_jornada.cpp new file mode 100644 index 0000000..bcd03ed --- a/dev/null +++ b/libopie2/opiecore/device/odevice_jornada.cpp | |||
@@ -0,0 +1,214 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | typedef struct { | ||
70 | unsigned char OffOnBlink; /* 0=off 1=on 2=Blink */ | ||
71 | unsigned char TotalTime; /* Units of 5 seconds */ | ||
72 | unsigned char OnTime; /* units of 100m/s */ | ||
73 | unsigned char OffTime; /* units of 100m/s */ | ||
74 | } LED_IN; | ||
75 | |||
76 | typedef struct { | ||
77 | unsigned char mode; | ||
78 | unsigned char pwr; | ||
79 | unsigned char brightness; | ||
80 | } FLITE_IN; | ||
81 | |||
82 | #define LED_ON OD_IOW( 'f', 5, LED_IN ) | ||
83 | #define FLITE_ON OD_IOW( 'f', 7, FLITE_IN ) | ||
84 | |||
85 | using namespace Opie; | ||
86 | |||
87 | class Jornada : public ODevice | ||
88 | { | ||
89 | |||
90 | protected: | ||
91 | virtual void init(); | ||
92 | |||
93 | public: | ||
94 | virtual bool setSoftSuspend ( bool soft ); | ||
95 | virtual bool setDisplayBrightness ( int b ); | ||
96 | virtual int displayBrightnessResolution() const; | ||
97 | static bool isJornada(); | ||
98 | }; | ||
99 | |||
100 | |||
101 | bool Jornada::isJornada() | ||
102 | { | ||
103 | QFile f( "/proc/cpuinfo" ); | ||
104 | if ( f. open ( IO_ReadOnly ) ) { | ||
105 | QTextStream ts ( &f ); | ||
106 | QString line; | ||
107 | while( line = ts. readLine() ) { | ||
108 | if ( line. left ( 8 ) == "Hardware" ) { | ||
109 | int loc = line. find ( ":" ); | ||
110 | if ( loc != -1 ) { | ||
111 | QString model = line.mid( loc + 2 ).simplifyWhiteSpace( ); | ||
112 | return ( model == "HP Jornada 56x" ); | ||
113 | } | ||
114 | } | ||
115 | } | ||
116 | } | ||
117 | return false; | ||
118 | } | ||
119 | |||
120 | void Jornada::init() | ||
121 | { | ||
122 | d->m_vendorstr = "HP"; | ||
123 | d->m_vendor = Vendor_HP; | ||
124 | d->m_modelstr = "Jornada 56x"; | ||
125 | d->m_model = Model_Jornada_56x; | ||
126 | d->m_systemstr = "Familiar"; | ||
127 | d->m_system = System_Familiar; | ||
128 | d->m_rotation = Rot0; | ||
129 | |||
130 | QFile f ( "/etc/familiar-version" ); | ||
131 | f. setName ( "/etc/familiar-version" ); | ||
132 | if ( f. open ( IO_ReadOnly )) { | ||
133 | |||
134 | QTextStream ts ( &f ); | ||
135 | d->m_sysverstr = ts. readLine(). mid ( 10 ); | ||
136 | |||
137 | f. close(); | ||
138 | } | ||
139 | } | ||
140 | |||
141 | #if 0 | ||
142 | void Jornada::initButtons() | ||
143 | { | ||
144 | if ( d->m_buttons ) | ||
145 | return; | ||
146 | |||
147 | // Simulation uses iPAQ 3660 device buttons | ||
148 | |||
149 | qDebug ( "init Buttons" ); | ||
150 | d->m_buttons = new QValueList <ODeviceButton>; | ||
151 | |||
152 | for ( uint i = 0; i < ( sizeof( ipaq_buttons ) / sizeof( i_button )); i++ ) { | ||
153 | i_button *ib = ipaq_buttons + i; | ||
154 | ODeviceButton b; | ||
155 | |||
156 | if (( ib->model & Model_iPAQ_H36xx ) == Model_iPAQ_H36xx ) { | ||
157 | b. setKeycode ( ib->code ); | ||
158 | b. setUserText ( QObject::tr ( "Button", ib->utext )); | ||
159 | b. setPixmap ( Resource::loadPixmap ( ib->pix )); | ||
160 | b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( ib->fpressedservice ), ib->fpressedaction )); | ||
161 | b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( ib->fheldservice ), ib->fheldaction )); | ||
162 | d->m_buttons->append ( b ); | ||
163 | } | ||
164 | } | ||
165 | reloadButtonMapping(); | ||
166 | |||
167 | QCopChannel *sysch = new QCopChannel ( "QPE/System", this ); | ||
168 | connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & ))); | ||
169 | } | ||
170 | #endif | ||
171 | |||
172 | int Jornada::displayBrightnessResolution() const | ||
173 | { | ||
174 | } | ||
175 | |||
176 | bool Jornada::setDisplayBrightness( int bright ) | ||
177 | { | ||
178 | bool res = false; | ||
179 | int fd; | ||
180 | |||
181 | if ( bright > 255 ) | ||
182 | bright = 255; | ||
183 | if ( bright < 0 ) | ||
184 | bright = 0; | ||
185 | |||
186 | if (( fd = ::open ( "/dev/touchscreen/0", O_WRONLY )) >= 0 ) { | ||
187 | FLITE_IN bl; | ||
188 | bl. mode = 1; | ||
189 | bl. pwr = bright ? 1 : 0; | ||
190 | bl. brightness = ( bright * ( displayBrightnessResolution() - 1 ) + 127 ) / 255; | ||
191 | res = ( ::ioctl ( fd, FLITE_ON, &bl ) == 0 ); | ||
192 | ::close ( fd ); | ||
193 | } | ||
194 | return res; | ||
195 | } | ||
196 | |||
197 | bool Jornada::setSoftSuspend( bool soft ) | ||
198 | { | ||
199 | bool res = false; | ||
200 | int fd; | ||
201 | |||
202 | if (( fd = ::open ( "/proc/sys/ts/suspend_button_mode", O_WRONLY )) >= 0 ) { | ||
203 | if ( ::write ( fd, soft ? "1" : "0", 1 ) == 1 ) | ||
204 | res = true; | ||
205 | else | ||
206 | ::perror ( "write to /proc/sys/ts/suspend_button_mode" ); | ||
207 | |||
208 | ::close ( fd ); | ||
209 | } | ||
210 | else | ||
211 | ::perror ( "/proc/sys/ts/suspend_button_mode" ); | ||
212 | |||
213 | return res; | ||
214 | } | ||
diff --git a/libopie2/opiecore/device/odevice_ramses.cpp b/libopie2/opiecore/device/odevice_ramses.cpp new file mode 100644 index 0000000..a90c3a0 --- a/dev/null +++ b/libopie2/opiecore/device/odevice_ramses.cpp | |||
@@ -0,0 +1,317 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | using namespace Opie; | ||
70 | |||
71 | class Ramses : public ODevice, public QWSServer::KeyboardFilter | ||
72 | { | ||
73 | protected: | ||
74 | virtual void init(); | ||
75 | |||
76 | public: | ||
77 | virtual bool setSoftSuspend( bool soft ); | ||
78 | virtual bool suspend(); | ||
79 | |||
80 | virtual bool setDisplayStatus( bool on ); | ||
81 | virtual bool setDisplayBrightness( int b ); | ||
82 | virtual int displayBrightnessResolution() const; | ||
83 | virtual bool setDisplayContrast( int b ); | ||
84 | virtual int displayContrastResolution() const; | ||
85 | |||
86 | protected: | ||
87 | virtual bool filter ( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ); | ||
88 | virtual void timerEvent ( QTimerEvent *te ); | ||
89 | |||
90 | int m_power_timer; | ||
91 | }; | ||
92 | |||
93 | struct r_button { | ||
94 | uint model; | ||
95 | Qt::Key code; | ||
96 | char *utext; | ||
97 | char *pix; | ||
98 | char *fpressedservice; | ||
99 | char *fpressedaction; | ||
100 | char *fheldservice; | ||
101 | char *fheldaction; | ||
102 | } ramses_buttons [] = { | ||
103 | { Model_Ramses_MNCI, | ||
104 | Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"), | ||
105 | "devicebuttons/z_menu", | ||
106 | "QPE/TaskBar", "toggleMenu()", | ||
107 | "QPE/TaskBar", "toggleStartMenu()" }, | ||
108 | { Model_Ramses_MNCI, | ||
109 | Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"), | ||
110 | "devicebuttons/ipaq_home", | ||
111 | "QPE/Launcher", "home()", | ||
112 | "buttonsettings", "raise()" }, | ||
113 | }; | ||
114 | |||
115 | void Ramses::init() | ||
116 | { | ||
117 | d->m_vendorstr = "M und N"; | ||
118 | d->m_vendor = Vendor_MundN; | ||
119 | |||
120 | QFile f("/proc/sys/board/ramses"); | ||
121 | |||
122 | d->m_modelstr = "Ramses"; | ||
123 | d->m_model = Model_Ramses_MNCI; | ||
124 | |||
125 | d->m_rotation = Rot0; | ||
126 | d->m_holdtime = 1000; | ||
127 | |||
128 | f.setName("/etc/oz_version"); | ||
129 | |||
130 | if (f.open(IO_ReadOnly)) { | ||
131 | d->m_systemstr = "OpenEmbedded/Ramses"; | ||
132 | d->m_system = System_OpenZaurus; | ||
133 | |||
134 | QTextStream ts(&f); | ||
135 | ts.setDevice(&f); | ||
136 | d->m_sysverstr = ts.readLine(); | ||
137 | f.close(); | ||
138 | } | ||
139 | |||
140 | m_power_timer = 0; | ||
141 | |||
142 | #ifdef QT_QWS_ALLOW_OVERCLOCK | ||
143 | #warning *** Overclocking enabled - this may fry your hardware - you have been warned *** | ||
144 | #define OC(x...) x | ||
145 | #else | ||
146 | #define OC(x...) | ||
147 | #endif | ||
148 | |||
149 | // This table is true for a Intel XScale PXA 255 | ||
150 | |||
151 | d->m_cpu_frequencies->append("99000"); // mem= 99, run= 99, turbo= 99, PXbus= 50 | ||
152 | OC(d->m_cpu_frequencies->append("118000"); ) // mem=118, run=118, turbo=118, PXbus= 59 OC'd mem | ||
153 | d->m_cpu_frequencies->append("199100"); // mem= 99, run=199, turbo=199, PXbus= 99 | ||
154 | OC(d->m_cpu_frequencies->append("236000"); ) // mem=118, run=236, turbo=236, PXbus=118 OC'd mem | ||
155 | d->m_cpu_frequencies->append("298600"); // mem= 99, run=199, turbo=298, PXbus= 99 | ||
156 | OC(d->m_cpu_frequencies->append("354000"); ) // mem=118, run=236, turbo=354, PXbus=118 OC'd mem | ||
157 | d->m_cpu_frequencies->append("398099"); // mem= 99, run=199, turbo=398, PXbus= 99 | ||
158 | d->m_cpu_frequencies->append("398100"); // mem= 99, run=398, turbo=398, PXbus=196 | ||
159 | OC(d->m_cpu_frequencies->append("471000"); ) // mem=118, run=471, turbo=471, PXbus=236 OC'd mem/core/bus | ||
160 | |||
161 | } | ||
162 | |||
163 | bool Ramses::filter(int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat) | ||
164 | { | ||
165 | Q_UNUSED( keycode ); | ||
166 | Q_UNUSED( modifiers ); | ||
167 | Q_UNUSED( isPress ); | ||
168 | Q_UNUSED( autoRepeat ); | ||
169 | return false; | ||
170 | } | ||
171 | |||
172 | void Ramses::timerEvent(QTimerEvent *) | ||
173 | { | ||
174 | killTimer(m_power_timer); | ||
175 | m_power_timer = 0; | ||
176 | QWSServer::sendKeyEvent(-1, HardKey_Backlight, 0, true, false); | ||
177 | QWSServer::sendKeyEvent(-1, HardKey_Backlight, 0, false, false); | ||
178 | } | ||
179 | |||
180 | |||
181 | bool Ramses::setSoftSuspend(bool soft) | ||
182 | { | ||
183 | qDebug("Ramses::setSoftSuspend(%d)", soft); | ||
184 | #if 0 | ||
185 | bool res = false; | ||
186 | int fd; | ||
187 | |||
188 | if (((fd = ::open("/dev/apm_bios", O_RDWR)) >= 0) || | ||
189 | ((fd = ::open("/dev/misc/apm_bios",O_RDWR)) >= 0)) { | ||
190 | |||
191 | int sources = ::ioctl(fd, APM_IOCGEVTSRC, 0); // get current event sources | ||
192 | |||
193 | if (sources >= 0) { | ||
194 | if (soft) | ||
195 | sources &= ~APM_EVT_POWER_BUTTON; | ||
196 | else | ||
197 | sources |= APM_EVT_POWER_BUTTON; | ||
198 | |||
199 | if (::ioctl(fd, APM_IOCSEVTSRC, sources) >= 0) // set new event sources | ||
200 | res = true; | ||
201 | else | ||
202 | perror("APM_IOCGEVTSRC"); | ||
203 | } | ||
204 | else | ||
205 | perror("APM_IOCGEVTSRC"); | ||
206 | |||
207 | ::close(fd); | ||
208 | } | ||
209 | else | ||
210 | perror("/dev/apm_bios or /dev/misc/apm_bios"); | ||
211 | |||
212 | return res; | ||
213 | #else | ||
214 | return true; | ||
215 | #endif | ||
216 | } | ||
217 | |||
218 | bool Ramses::suspend() | ||
219 | { | ||
220 | qDebug("Ramses::suspend"); | ||
221 | return false; | ||
222 | } | ||
223 | |||
224 | /** | ||
225 | * This sets the display on or off | ||
226 | */ | ||
227 | bool Ramses::setDisplayStatus(bool on) | ||
228 | { | ||
229 | qDebug("Ramses::setDisplayStatus(%d)", on); | ||
230 | #if 0 | ||
231 | bool res = false; | ||
232 | int fd; | ||
233 | |||
234 | if ((fd = ::open ("/dev/fb/0", O_RDWR)) >= 0) { | ||
235 | res = (::ioctl(fd, FBIOBLANK, on ? VESA_NO_BLANKING : VESA_POWERDOWN) == 0); | ||
236 | ::close(fd); | ||
237 | } | ||
238 | return res; | ||
239 | #else | ||
240 | return true; | ||
241 | #endif | ||
242 | } | ||
243 | |||
244 | |||
245 | /* | ||
246 | * We get something between 0..255 into us | ||
247 | */ | ||
248 | bool Ramses::setDisplayBrightness(int bright) | ||
249 | { | ||
250 | qDebug("Ramses::setDisplayBrightness(%d)", bright); | ||
251 | bool res = false; | ||
252 | int fd; | ||
253 | |||
254 | // pwm1 brighness: 20 steps 500..0 (dunkel->hell) | ||
255 | |||
256 | if (bright > 255 ) | ||
257 | bright = 255; | ||
258 | if (bright < 0) | ||
259 | bright = 0; | ||
260 | |||
261 | // Turn backlight completely off | ||
262 | if ((fd = ::open("/proc/sys/board/lcd_backlight", O_WRONLY)) >= 0) { | ||
263 | char writeCommand[10]; | ||
264 | const int count = sprintf(writeCommand, "%d\n", bright ? 1 : 0); | ||
265 | res = (::write(fd, writeCommand, count) != -1); | ||
266 | ::close(fd); | ||
267 | } | ||
268 | |||
269 | // scale backlight brightness to hardware | ||
270 | bright = 500-(bright * 500 / 255); | ||
271 | if ((fd = ::open("/proc/sys/board/pwm1", O_WRONLY)) >= 0) { | ||
272 | qDebug(" %d ->pwm1", bright); | ||
273 | char writeCommand[100]; | ||
274 | const int count = sprintf(writeCommand, "%d\n", bright); | ||
275 | res = (::write(fd, writeCommand, count) != -1); | ||
276 | ::close(fd); | ||
277 | } | ||
278 | return res; | ||
279 | } | ||
280 | |||
281 | |||
282 | int Ramses::displayBrightnessResolution() const | ||
283 | { | ||
284 | return 32; | ||
285 | } | ||
286 | |||
287 | bool Ramses::setDisplayContrast(int contr) | ||
288 | { | ||
289 | qDebug("Ramses::setDisplayContrast(%d)", contr); | ||
290 | bool res = false; | ||
291 | int fd; | ||
292 | |||
293 | // pwm0 contrast: 20 steps 79..90 (dunkel->hell) | ||
294 | |||
295 | if (contr > 255 ) | ||
296 | contr = 255; | ||
297 | if (contr < 0) | ||
298 | contr = 0; | ||
299 | contr = 90 - (contr * 20 / 255); | ||
300 | |||
301 | if ((fd = ::open("/proc/sys/board/pwm0", O_WRONLY)) >= 0) { | ||
302 | qDebug(" %d ->pwm0", contr); | ||
303 | char writeCommand[100]; | ||
304 | const int count = sprintf(writeCommand, "%d\n", contr); | ||
305 | res = (::write(fd, writeCommand, count) != -1); | ||
306 | res = true; | ||
307 | ::close(fd); | ||
308 | } | ||
309 | return res; | ||
310 | } | ||
311 | |||
312 | |||
313 | int Ramses::displayContrastResolution() const | ||
314 | { | ||
315 | return 20; | ||
316 | } | ||
317 | |||
diff --git a/libopie2/opiecore/device/odevice_simpad.cpp b/libopie2/opiecore/device/odevice_simpad.cpp new file mode 100644 index 0000000..82dce10 --- a/dev/null +++ b/libopie2/opiecore/device/odevice_simpad.cpp | |||
@@ -0,0 +1,443 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | using namespace Opie; | ||
70 | |||
71 | class SIMpad : public ODevice, public QWSServer::KeyboardFilter | ||
72 | { | ||
73 | protected: | ||
74 | virtual void init(); | ||
75 | virtual void initButtons(); | ||
76 | |||
77 | public: | ||
78 | virtual bool setSoftSuspend( bool soft ); | ||
79 | virtual bool suspend(); | ||
80 | |||
81 | virtual bool setDisplayStatus( bool on ); | ||
82 | virtual bool setDisplayBrightness( int b ); | ||
83 | virtual int displayBrightnessResolution() const; | ||
84 | |||
85 | virtual void alarmSound(); | ||
86 | |||
87 | virtual QValueList <OLed> ledList() const; | ||
88 | virtual QValueList <OLedState> ledStateList( OLed led ) const; | ||
89 | virtual OLedState ledState( OLed led ) const; | ||
90 | virtual bool setLedState( OLed led, OLedState st ); | ||
91 | |||
92 | protected: | ||
93 | virtual bool filter( int unicode, int keycode, int modifiers, bool isPress, bool autoRepeat ); | ||
94 | virtual void timerEvent( QTimerEvent *te ); | ||
95 | |||
96 | int m_power_timer; | ||
97 | |||
98 | OLedState m_leds [1]; | ||
99 | }; | ||
100 | |||
101 | struct s_button { | ||
102 | uint model; | ||
103 | Qt::Key code; | ||
104 | char *utext; | ||
105 | char *pix; | ||
106 | char *fpressedservice; | ||
107 | char *fpressedaction; | ||
108 | char *fheldservice; | ||
109 | char *fheldaction; | ||
110 | } simpad_buttons [] = { | ||
111 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
112 | Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Lower+Up"), | ||
113 | "devicebuttons/simpad_lower_up", | ||
114 | "datebook", "nextView()", | ||
115 | "today", "raise()" }, | ||
116 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
117 | Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Lower+Down"), | ||
118 | "devicebuttons/simpad_lower_down", | ||
119 | "addressbook", "raise()", | ||
120 | "addressbook", "beamBusinessCard()" }, | ||
121 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
122 | Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Lower+Right"), | ||
123 | "devicebuttons/simpad_lower_right", | ||
124 | "QPE/TaskBar", "toggleMenu()", | ||
125 | "QPE/TaskBar", "toggleStartMenu()" }, | ||
126 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
127 | Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Lower+Left"), | ||
128 | "devicebuttons/simpad_lower_left", | ||
129 | "mail", "raise()", | ||
130 | "mail", "newMail()" }, | ||
131 | |||
132 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
133 | Qt::Key_F5, QT_TRANSLATE_NOOP("Button", "Upper+Up"), | ||
134 | "devicebuttons/simpad_upper_up", | ||
135 | "QPE/Launcher", "home()", | ||
136 | "buttonsettings", "raise()" }, | ||
137 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
138 | Qt::Key_F6, QT_TRANSLATE_NOOP("Button", "Upper+Down"), | ||
139 | "devicebuttons/simpad_upper_down", | ||
140 | "addressbook", "raise()", | ||
141 | "addressbook", "beamBusinessCard()" }, | ||
142 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
143 | Qt::Key_F7, QT_TRANSLATE_NOOP("Button", "Upper+Right"), | ||
144 | "devicebuttons/simpad_upper_right", | ||
145 | "QPE/TaskBar", "toggleMenu()", | ||
146 | "QPE/TaskBar", "toggleStartMenu()" }, | ||
147 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
148 | Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Upper+Left"), | ||
149 | "devicebuttons/simpad_upper_left", | ||
150 | "QPE/Rotation", "flip()", | ||
151 | "QPE/Rotation", "flip()" }, | ||
152 | /* | ||
153 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
154 | Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Lower+Upper"), | ||
155 | "devicebuttons/simpad_lower_upper", | ||
156 | "QPE/Launcher", "home()", | ||
157 | "buttonsettings", "raise()" }, | ||
158 | { Model_SIMpad_CL4 | Model_SIMpad_SL4 | Model_SIMpad_SLC | Model_SIMpad_TSinus, | ||
159 | Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Lower+Upper"), | ||
160 | "devicebuttons/simpad_upper_lower", | ||
161 | "QPE/Launcher", "home()", | ||
162 | "buttonsettings", "raise()" }, | ||
163 | */ | ||
164 | }; | ||
165 | |||
166 | void SIMpad::init() | ||
167 | { | ||
168 | d->m_vendorstr = "SIEMENS"; | ||
169 | d->m_vendor = Vendor_SIEMENS; | ||
170 | |||
171 | QFile f ( "/proc/hal/model" ); | ||
172 | |||
173 | //TODO Implement model checking | ||
174 | //FIXME For now we assume an SL4 | ||
175 | |||
176 | d->m_modelstr = "SL4"; | ||
177 | d->m_model = Model_SIMpad_SL4; | ||
178 | |||
179 | switch ( d->m_model ) { | ||
180 | default: | ||
181 | d->m_rotation = Rot0; | ||
182 | d->m_direction = CCW; | ||
183 | d->m_holdtime = 1000; // 1000ms | ||
184 | |||
185 | break; | ||
186 | } | ||
187 | |||
188 | f. setName ( "/etc/familiar-version" ); | ||
189 | if ( f. open ( IO_ReadOnly )) { | ||
190 | d->m_systemstr = "Familiar"; | ||
191 | d->m_system = System_Familiar; | ||
192 | |||
193 | QTextStream ts ( &f ); | ||
194 | d->m_sysverstr = ts. readLine(). mid ( 10 ); | ||
195 | |||
196 | f. close(); | ||
197 | } else { | ||
198 | f. setName ( "/etc/oz_version" ); | ||
199 | |||
200 | if ( f. open ( IO_ReadOnly )) { | ||
201 | d->m_systemstr = "OpenEmbedded/SIMpad"; | ||
202 | d->m_system = System_OpenZaurus; | ||
203 | |||
204 | QTextStream ts ( &f ); | ||
205 | ts.setDevice ( &f ); | ||
206 | d->m_sysverstr = ts. readLine(); | ||
207 | f. close(); | ||
208 | } | ||
209 | } | ||
210 | |||
211 | m_leds [0] = m_leds [1] = Led_Off; | ||
212 | |||
213 | m_power_timer = 0; | ||
214 | |||
215 | } | ||
216 | |||
217 | void SIMpad::initButtons() | ||
218 | { | ||
219 | if ( d->m_buttons ) | ||
220 | return; | ||
221 | |||
222 | if ( isQWS( ) ) | ||
223 | QWSServer::setKeyboardFilter ( this ); | ||
224 | |||
225 | d->m_buttons = new QValueList <ODeviceButton>; | ||
226 | |||
227 | for ( uint i = 0; i < ( sizeof( simpad_buttons ) / sizeof( s_button )); i++ ) { | ||
228 | s_button *sb = simpad_buttons + i; | ||
229 | ODeviceButton b; | ||
230 | |||
231 | if (( sb->model & d->m_model ) == d->m_model ) { | ||
232 | b. setKeycode ( sb->code ); | ||
233 | b. setUserText ( QObject::tr ( "Button", sb->utext )); | ||
234 | b. setPixmap ( Resource::loadPixmap ( sb->pix )); | ||
235 | b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( sb->fpressedservice ), sb->fpressedaction )); | ||
236 | b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( sb->fheldservice ), sb->fheldaction )); | ||
237 | |||
238 | d->m_buttons->append ( b ); | ||
239 | } | ||
240 | } | ||
241 | reloadButtonMapping(); | ||
242 | |||
243 | QCopChannel *sysch = new QCopChannel ( "QPE/System", this ); | ||
244 | connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), this, SLOT( systemMessage ( const QCString &, const QByteArray & ))); | ||
245 | } | ||
246 | |||
247 | // SIMpad boardcontrol register CS3 | ||
248 | #define SIMPAD_BOARDCONTROL "/proc/cs3" | ||
249 | #define SIMPAD_VCC_5V_EN 0x0001 // For 5V PCMCIA | ||
250 | #define SIMPAD_VCC_3V_EN 0x0002 // FOR 3.3V PCMCIA | ||
251 | #define SIMPAD_EN1 0x0004 // This is only for EPROM's | ||
252 | #define SIMPAD_EN0 0x0008 // Both should be enable for 3.3V or 5V | ||
253 | #define SIMPAD_DISPLAY_ON 0x0010 | ||
254 | #define SIMPAD_PCMCIA_BUFF_DIS 0x0020 | ||
255 | #define SIMPAD_MQ_RESET 0x0040 | ||
256 | #define SIMPAD_PCMCIA_RESET 0x0080 | ||
257 | #define SIMPAD_DECT_POWER_ON 0x0100 | ||
258 | #define SIMPAD_IRDA_SD 0x0200 // Shutdown for powersave | ||
259 | #define SIMPAD_RS232_ON 0x0400 | ||
260 | #define SIMPAD_SD_MEDIAQ 0x0800 // Shutdown for powersave | ||
261 | #define SIMPAD_LED2_ON 0x1000 | ||
262 | #define SIMPAD_IRDA_MODE 0x2000 // Fast/Slow IrDA mode | ||
263 | #define SIMPAD_ENABLE_5V 0x4000 // Enable 5V circuit | ||
264 | #define SIMPAD_RESET_SIMCARD 0x8000 | ||
265 | |||
266 | //SIMpad touchscreen backlight strength control | ||
267 | #define SIMPAD_BACKLIGHT_CONTROL "/proc/driver/mq200/registers/PWM_CONTROL" | ||
268 | #define SIMPAD_BACKLIGHT_MASK 0x00a10044 | ||
269 | |||
270 | QValueList <OLed> SIMpad::ledList() const | ||
271 | { | ||
272 | QValueList <OLed> vl; | ||
273 | vl << Led_Power; //FIXME which LED is LED2 ? The green one or the amber one? | ||
274 | //vl << Led_Mail; //TODO find out if LED1 is accessible anyway | ||
275 | return vl; | ||
276 | } | ||
277 | |||
278 | QValueList <OLedState> SIMpad::ledStateList ( OLed l ) const | ||
279 | { | ||
280 | QValueList <OLedState> vl; | ||
281 | |||
282 | if ( l == Led_Power ) //FIXME which LED is LED2 ? The green one or the amber one? | ||
283 | vl << Led_Off << Led_On; | ||
284 | //else if ( l == Led_Mail ) //TODO find out if LED1 is accessible anyway | ||
285 | //vl << Led_Off; | ||
286 | return vl; | ||
287 | } | ||
288 | |||
289 | OLedState SIMpad::ledState ( OLed l ) const | ||
290 | { | ||
291 | switch ( l ) { | ||
292 | case Led_Power: | ||
293 | return m_leds [0]; | ||
294 | //case Led_Mail: | ||
295 | //return m_leds [1]; | ||
296 | default: | ||
297 | return Led_Off; | ||
298 | } | ||
299 | } | ||
300 | |||
301 | bool SIMpad::setLedState ( OLed l, OLedState st ) | ||
302 | { | ||
303 | #if 0 | ||
304 | static int fd = ::open ( SIMPAD_BOARDCONTROL, O_RDWR | O_NONBLOCK ); | ||
305 | |||
306 | /*TODO Implement this like that: | ||
307 | read from cs3 | ||
308 | && with SIMPAD_LED2_ON | ||
309 | write to cs3 */ | ||
310 | m_leds [0] = st; | ||
311 | return true; | ||
312 | } | ||
313 | } | ||
314 | } | ||
315 | |||
316 | #endif | ||
317 | return false; | ||
318 | } | ||
319 | |||
320 | |||
321 | bool SIMpad::filter ( int /*unicode*/, int keycode, int modifiers, bool isPress, bool autoRepeat ) | ||
322 | { | ||
323 | //TODO | ||
324 | return false; | ||
325 | } | ||
326 | |||
327 | void SIMpad::timerEvent ( QTimerEvent * ) | ||
328 | { | ||
329 | killTimer ( m_power_timer ); | ||
330 | m_power_timer = 0; | ||
331 | QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, true, false ); | ||
332 | QWSServer::sendKeyEvent ( -1, HardKey_Backlight, 0, false, false ); | ||
333 | } | ||
334 | |||
335 | |||
336 | void SIMpad::alarmSound() | ||
337 | { | ||
338 | #ifndef QT_NO_SOUND | ||
339 | static Sound snd ( "alarm" ); | ||
340 | int fd; | ||
341 | int vol; | ||
342 | bool vol_reset = false; | ||
343 | |||
344 | if (( fd = ::open ( "/dev/sound/mixer", O_RDWR )) >= 0 ) { | ||
345 | if ( ::ioctl ( fd, MIXER_READ( 0 ), &vol ) >= 0 ) { | ||
346 | Config cfg ( "qpe" ); | ||
347 | cfg. setGroup ( "Volume" ); | ||
348 | |||
349 | int volalarm = cfg. readNumEntry ( "AlarmPercent", 50 ); | ||
350 | if ( volalarm < 0 ) | ||
351 | volalarm = 0; | ||
352 | else if ( volalarm > 100 ) | ||
353 | volalarm = 100; | ||
354 | volalarm |= ( volalarm << 8 ); | ||
355 | |||
356 | if ( ::ioctl ( fd, MIXER_WRITE( 0 ), &volalarm ) >= 0 ) | ||
357 | vol_reset = true; | ||
358 | } | ||
359 | } | ||
360 | |||
361 | snd. play(); | ||
362 | while ( !snd. isFinished()) | ||
363 | qApp->processEvents(); | ||
364 | |||
365 | if ( fd >= 0 ) { | ||
366 | if ( vol_reset ) | ||
367 | ::ioctl ( fd, MIXER_WRITE( 0 ), &vol ); | ||
368 | ::close ( fd ); | ||
369 | } | ||
370 | #endif | ||
371 | } | ||
372 | |||
373 | |||
374 | bool SIMpad::suspend() // Must override because SIMpad does NOT have apm | ||
375 | { | ||
376 | qDebug( "ODevice for SIMpad: suspend()" ); | ||
377 | if ( !isQWS( ) ) // only qwsserver is allowed to suspend | ||
378 | return false; | ||
379 | |||
380 | bool res = false; | ||
381 | |||
382 | struct timeval tvs, tvn; | ||
383 | ::gettimeofday ( &tvs, 0 ); | ||
384 | |||
385 | ::sync(); // flush fs caches | ||
386 | res = ( ::system ( "cat /dev/fb/0 >/tmp/.buffer; echo > /proc/sys/pm/suspend; cat /tmp/.buffer >/dev/fb/0" ) == 0 ); //TODO make better :) | ||
387 | |||
388 | return res; | ||
389 | } | ||
390 | |||
391 | |||
392 | bool SIMpad::setSoftSuspend ( bool soft ) | ||
393 | { | ||
394 | qDebug( "ODevice for SIMpad: UNHANDLED setSoftSuspend(%s)", soft? "on" : "off" ); | ||
395 | return false; | ||
396 | } | ||
397 | |||
398 | |||
399 | bool SIMpad::setDisplayStatus ( bool on ) | ||
400 | { | ||
401 | qDebug( "ODevice for SIMpad: setDisplayStatus(%s)", on? "on" : "off" ); | ||
402 | |||
403 | bool res = false; | ||
404 | int fd; | ||
405 | |||
406 | QString cmdline = QString().sprintf( "echo %s > /proc/cs3", on ? "0xd41a" : "0xd40a" ); //TODO make better :) | ||
407 | |||
408 | res = ( ::system( (const char*) cmdline ) == 0 ); | ||
409 | |||
410 | return res; | ||
411 | } | ||
412 | |||
413 | |||
414 | bool SIMpad::setDisplayBrightness ( int bright ) | ||
415 | { | ||
416 | qDebug( "ODevice for SIMpad: setDisplayBrightness( %d )", bright ); | ||
417 | bool res = false; | ||
418 | int fd; | ||
419 | |||
420 | if ( bright > 255 ) | ||
421 | bright = 255; | ||
422 | if ( bright < 1 ) | ||
423 | bright = 0; | ||
424 | |||
425 | if (( fd = ::open ( SIMPAD_BACKLIGHT_CONTROL, O_WRONLY )) >= 0 ) { | ||
426 | int value = 255 - bright; | ||
427 | const int mask = SIMPAD_BACKLIGHT_MASK; | ||
428 | value = value << 8; | ||
429 | value += mask; | ||
430 | char writeCommand[100]; | ||
431 | const int count = sprintf( writeCommand, "0x%x\n", value ); | ||
432 | res = ( ::write ( fd, writeCommand, count ) != -1 ); | ||
433 | ::close ( fd ); | ||
434 | } | ||
435 | return res; | ||
436 | } | ||
437 | |||
438 | |||
439 | int SIMpad::displayBrightnessResolution() const | ||
440 | { | ||
441 | return 255; // All SIMpad models share the same display | ||
442 | } | ||
443 | |||
diff --git a/libopie2/opiecore/device/odevice_yopy.cpp b/libopie2/opiecore/device/odevice_yopy.cpp new file mode 100644 index 0000000..9d0cdeb --- a/dev/null +++ b/libopie2/opiecore/device/odevice_yopy.cpp | |||
@@ -0,0 +1,212 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | using namespace Opie; | ||
70 | |||
71 | class Yopy : public ODevice | ||
72 | { | ||
73 | protected: | ||
74 | |||
75 | virtual void init(); | ||
76 | virtual void initButtons(); | ||
77 | |||
78 | public: | ||
79 | virtual bool suspend(); | ||
80 | |||
81 | virtual bool setDisplayBrightness ( int b ); | ||
82 | virtual int displayBrightnessResolution() const; | ||
83 | |||
84 | static bool isYopy(); | ||
85 | }; | ||
86 | |||
87 | struct yopy_button { | ||
88 | Qt::Key code; | ||
89 | char *utext; | ||
90 | char *pix; | ||
91 | char *fpressedservice; | ||
92 | char *fpressedaction; | ||
93 | char *fheldservice; | ||
94 | char *fheldaction; | ||
95 | } yopy_buttons [] = { | ||
96 | { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Action Button"), | ||
97 | "devicebuttons/yopy_action", | ||
98 | "datebook", "nextView()", | ||
99 | "today", "raise()" }, | ||
100 | { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "OK Button"), | ||
101 | "devicebuttons/yopy_ok", | ||
102 | "addressbook", "raise()", | ||
103 | "addressbook", "beamBusinessCard()" }, | ||
104 | { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "End Button"), | ||
105 | "devicebuttons/yopy_end", | ||
106 | "QPE/Launcher", "home()", | ||
107 | "buttonsettings", "raise()" }, | ||
108 | }; | ||
109 | |||
110 | bool Yopy::isYopy() | ||
111 | { | ||
112 | QFile f( "/proc/cpuinfo" ); | ||
113 | if ( f. open ( IO_ReadOnly ) ) { | ||
114 | QTextStream ts ( &f ); | ||
115 | QString line; | ||
116 | while( line = ts. readLine() ) { | ||
117 | if ( line. left ( 8 ) == "Hardware" ) { | ||
118 | int loc = line. find ( ":" ); | ||
119 | if ( loc != -1 ) { | ||
120 | QString model = | ||
121 | line. mid ( loc + 2 ). simplifyWhiteSpace( ); | ||
122 | return ( model == "Yopy" ); | ||
123 | } | ||
124 | } | ||
125 | } | ||
126 | } | ||
127 | return false; | ||
128 | } | ||
129 | |||
130 | void Yopy::init() | ||
131 | { | ||
132 | d->m_vendorstr = "G.Mate"; | ||
133 | d->m_vendor = Vendor_GMate; | ||
134 | d->m_modelstr = "Yopy3700"; | ||
135 | d->m_model = Model_Yopy_3700; | ||
136 | d->m_rotation = Rot0; | ||
137 | |||
138 | d->m_systemstr = "Linupy"; | ||
139 | d->m_system = System_Linupy; | ||
140 | |||
141 | QFile f ( "/etc/issue" ); | ||
142 | if ( f. open ( IO_ReadOnly )) { | ||
143 | QTextStream ts ( &f ); | ||
144 | ts.readLine(); | ||
145 | d->m_sysverstr = ts. readLine(); | ||
146 | f. close(); | ||
147 | } | ||
148 | } | ||
149 | |||
150 | void Yopy::initButtons() | ||
151 | { | ||
152 | if ( d->m_buttons ) | ||
153 | return; | ||
154 | |||
155 | d->m_buttons = new QValueList <ODeviceButton>; | ||
156 | |||
157 | for (uint i = 0; i < ( sizeof( yopy_buttons ) / sizeof(yopy_button)); i++) { | ||
158 | |||
159 | yopy_button *ib = yopy_buttons + i; | ||
160 | |||
161 | ODeviceButton b; | ||
162 | |||
163 | b. setKeycode ( ib->code ); | ||
164 | b. setUserText ( QObject::tr ( "Button", ib->utext )); | ||
165 | b. setPixmap ( Resource::loadPixmap ( ib->pix )); | ||
166 | b. setFactoryPresetPressedAction | ||
167 | (OQCopMessage(makeChannel(ib->fpressedservice), ib->fpressedaction)); | ||
168 | b. setFactoryPresetHeldAction | ||
169 | (OQCopMessage(makeChannel(ib->fheldservice), ib->fheldaction)); | ||
170 | |||
171 | d->m_buttons->append ( b ); | ||
172 | } | ||
173 | reloadButtonMapping(); | ||
174 | |||
175 | QCopChannel *sysch = new QCopChannel("QPE/System", this); | ||
176 | connect(sysch, SIGNAL(received(const QCString &, const QByteArray & )), | ||
177 | this, SLOT(systemMessage(const QCString &, const QByteArray & ))); | ||
178 | } | ||
179 | |||
180 | bool Yopy::suspend() | ||
181 | { | ||
182 | /* Opie for Yopy does not implement its own power management at the | ||
183 | moment. The public version runs parallel to X, and relies on the | ||
184 | existing power management features. */ | ||
185 | return false; | ||
186 | } | ||
187 | |||
188 | bool Yopy::setDisplayBrightness(int bright) | ||
189 | { | ||
190 | /* The code here works, but is disabled as the current version runs | ||
191 | parallel to X, and relies on the existing backlight demon. */ | ||
192 | #if 0 | ||
193 | if ( QFile::exists("/proc/sys/pm/light") ) { | ||
194 | int fd = ::open("/proc/sys/pm/light", O_WRONLY); | ||
195 | if (fd >= 0 ) { | ||
196 | if (bright) | ||
197 | ::write(fd, "1\n", 2); | ||
198 | else | ||
199 | ::write(fd, "0\n", 2); | ||
200 | ::close(fd); | ||
201 | return true; | ||
202 | } | ||
203 | } | ||
204 | #endif | ||
205 | return false; | ||
206 | } | ||
207 | |||
208 | int Yopy::displayBrightnessResolution() const | ||
209 | { | ||
210 | return 2; | ||
211 | } | ||
212 | |||
diff --git a/libopie2/opiecore/device/odevice_zaurus.cpp b/libopie2/opiecore/device/odevice_zaurus.cpp new file mode 100644 index 0000000..a6e8b82 --- a/dev/null +++ b/libopie2/opiecore/device/odevice_zaurus.cpp | |||
@@ -0,0 +1,790 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include "odevice.h" | ||
31 | |||
32 | /* QT */ | ||
33 | #include <qapplication.h> | ||
34 | #include <qfile.h> | ||
35 | #include <qtextstream.h> | ||
36 | #include <qwindowsystem_qws.h> | ||
37 | |||
38 | /* OPIE */ | ||
39 | #include <qpe/config.h> | ||
40 | #include <qpe/resource.h> | ||
41 | #include <qpe/sound.h> | ||
42 | #include <qpe/qcopenvelope_qws.h> | ||
43 | |||
44 | /* STD */ | ||
45 | #include <fcntl.h> | ||
46 | #include <math.h> | ||
47 | #include <stdlib.h> | ||
48 | #include <signal.h> | ||
49 | #include <sys/ioctl.h> | ||
50 | #include <sys/time.h> | ||
51 | #include <unistd.h> | ||
52 | #ifndef QT_NO_SOUND | ||
53 | #include <linux/soundcard.h> | ||
54 | #endif | ||
55 | |||
56 | #ifndef ARRAY_SIZE | ||
57 | #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) | ||
58 | #endif | ||
59 | |||
60 | // _IO and friends are only defined in kernel headers ... | ||
61 | |||
62 | #define OD_IOC(dir,type,number,size) (( dir << 30 ) | ( type << 8 ) | ( number ) | ( size << 16 )) | ||
63 | |||
64 | #define OD_IO(type,number) OD_IOC(0,type,number,0) | ||
65 | #define OD_IOW(type,number,size) OD_IOC(1,type,number,sizeof(size)) | ||
66 | #define OD_IOR(type,number,size) OD_IOC(2,type,number,sizeof(size)) | ||
67 | #define OD_IORW(type,number,size) OD_IOC(3,type,number,sizeof(size)) | ||
68 | |||
69 | using namespace Opie; | ||
70 | |||
71 | class Zaurus : public ODevice | ||
72 | { | ||
73 | |||
74 | protected: | ||
75 | virtual void init(); | ||
76 | virtual void initButtons(); | ||
77 | |||
78 | public: | ||
79 | virtual bool setSoftSuspend ( bool soft ); | ||
80 | |||
81 | virtual bool setDisplayBrightness ( int b ); | ||
82 | virtual int displayBrightnessResolution() const; | ||
83 | |||
84 | virtual void alarmSound(); | ||
85 | virtual void keySound(); | ||
86 | virtual void touchSound(); | ||
87 | |||
88 | virtual QValueList <OLed> ledList() const; | ||
89 | virtual QValueList <OLedState> ledStateList ( OLed led ) const; | ||
90 | virtual OLedState ledState( OLed led ) const; | ||
91 | virtual bool setLedState( OLed led, OLedState st ); | ||
92 | |||
93 | virtual bool hasHingeSensor() const; | ||
94 | virtual OHingeStatus readHingeSensor(); | ||
95 | |||
96 | static bool isZaurus(); | ||
97 | |||
98 | virtual bool suspend(); | ||
99 | virtual Transformation rotation() const; | ||
100 | virtual ODirection direction() const; | ||
101 | |||
102 | protected: | ||
103 | virtual void buzzer ( int snd ); | ||
104 | |||
105 | OLedState m_leds [1]; | ||
106 | bool m_embedix; | ||
107 | }; | ||
108 | |||
109 | struct z_button { | ||
110 | Qt::Key code; | ||
111 | char *utext; | ||
112 | char *pix; | ||
113 | char *fpressedservice; | ||
114 | char *fpressedaction; | ||
115 | char *fheldservice; | ||
116 | char *fheldaction; | ||
117 | } z_buttons [] = { | ||
118 | { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"), | ||
119 | "devicebuttons/z_calendar", | ||
120 | "datebook", "nextView()", | ||
121 | "today", "raise()" }, | ||
122 | { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"), | ||
123 | "devicebuttons/z_contact", | ||
124 | "addressbook", "raise()", | ||
125 | "addressbook", "beamBusinessCard()" }, | ||
126 | { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"), | ||
127 | "devicebuttons/z_home", | ||
128 | "QPE/Launcher", "home()", | ||
129 | "buttonsettings", "raise()" }, | ||
130 | { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"), | ||
131 | "devicebuttons/z_menu", | ||
132 | "QPE/TaskBar", "toggleMenu()", | ||
133 | "QPE/TaskBar", "toggleStartMenu()" }, | ||
134 | { Qt::Key_F13, QT_TRANSLATE_NOOP("Button", "Mail Button"), | ||
135 | "devicebuttons/z_mail", | ||
136 | "mail", "raise()", | ||
137 | "mail", "newMail()" }, | ||
138 | }; | ||
139 | |||
140 | struct z_button z_buttons_c700 [] = { | ||
141 | { Qt::Key_F9, QT_TRANSLATE_NOOP("Button", "Calendar Button"), | ||
142 | "devicebuttons/z_calendar", | ||
143 | "datebook", "nextView()", | ||
144 | "today", "raise()" }, | ||
145 | { Qt::Key_F10, QT_TRANSLATE_NOOP("Button", "Contacts Button"), | ||
146 | "devicebuttons/z_contact", | ||
147 | "addressbook", "raise()", | ||
148 | "addressbook", "beamBusinessCard()" }, | ||
149 | { Qt::Key_F12, QT_TRANSLATE_NOOP("Button", "Home Button"), | ||
150 | "devicebuttons/z_home", | ||
151 | "QPE/Launcher", "home()", | ||
152 | "buttonsettings", "raise()" }, | ||
153 | { Qt::Key_F11, QT_TRANSLATE_NOOP("Button", "Menu Button"), | ||
154 | "devicebuttons/z_menu", | ||
155 | "QPE/TaskBar", "toggleMenu()", | ||
156 | "QPE/TaskBar", "toggleStartMenu()" }, | ||
157 | { Qt::Key_F14, QT_TRANSLATE_NOOP("Button", "Display Rotate"), | ||
158 | "devicebuttons/z_hinge", | ||
159 | "QPE/Rotation", "rotateDefault()", | ||
160 | "QPE/Dummy", "doNothing()" }, | ||
161 | }; | ||
162 | |||
163 | // Check whether this device is the sharp zaurus.. | ||
164 | // FIXME This gets unnecessary complicated. We should think about splitting the Zaurus | ||
165 | // class up into individual classes. We need three classes | ||
166 | // | ||
167 | // Zaurus-Collie (SA-model w/ 320x240 lcd, for SL5500 and SL5000) | ||
168 | // Zaurus-Poodle (PXA-model w/ 320x240 lcd, for SL5600) | ||
169 | // Zaurus-Corgi (PXA-model w/ 640x480 lcd, for C700, C750, C760, and C860) | ||
170 | // | ||
171 | // Only question right now is: Do we really need to do it? Because as soon | ||
172 | // as the OpenZaurus kernel is ready, there will be a unified interface for all | ||
173 | // Zaurus models (concerning apm, backlight, buttons, etc.) | ||
174 | // | ||
175 | // Comments? - mickeyl. | ||
176 | |||
177 | bool Zaurus::isZaurus() | ||
178 | { | ||
179 | |||
180 | // If the special devices by embedix exist, it is quite simple: it is a Zaurus ! | ||
181 | if ( QFile::exists ( "/dev/sharp_buz" ) || QFile::exists ( "/dev/sharp_led" ) ){ | ||
182 | return true; | ||
183 | } | ||
184 | |||
185 | // On non-embedix kernels, we have to look closer. | ||
186 | bool is_zaurus = false; | ||
187 | QFile f ( "/proc/cpuinfo" ); | ||
188 | if ( f. open ( IO_ReadOnly ) ) { | ||
189 | QString model; | ||
190 | QFile f ( "/proc/cpuinfo" ); | ||
191 | |||
192 | QTextStream ts ( &f ); | ||
193 | QString line; | ||
194 | while( line = ts. readLine() ) { | ||
195 | if ( line. left ( 8 ) == "Hardware" ) | ||
196 | break; | ||
197 | } | ||
198 | int loc = line. find ( ":" ); | ||
199 | if ( loc != -1 ) | ||
200 | model = line. mid ( loc + 2 ). simplifyWhiteSpace( ); | ||
201 | |||
202 | if ( model == "Sharp-Collie" | ||
203 | || model == "Collie" | ||
204 | || model == "SHARP Corgi" | ||
205 | || model == "SHARP Shepherd" | ||
206 | || model == "SHARP Poodle" | ||
207 | || model == "SHARP Husky" | ||
208 | ) | ||
209 | is_zaurus = true; | ||
210 | |||
211 | } | ||
212 | return is_zaurus; | ||
213 | } | ||
214 | |||
215 | |||
216 | void Zaurus::init() | ||
217 | { | ||
218 | d->m_vendorstr = "Sharp"; | ||
219 | d->m_vendor = Vendor_Sharp; | ||
220 | m_embedix = true; // Not openzaurus means: It has an embedix kernel ! | ||
221 | |||
222 | // QFile f ( "/proc/filesystems" ); | ||
223 | QString model; | ||
224 | |||
225 | // It isn't a good idea to check the system configuration to | ||
226 | // detect the distribution ! | ||
227 | // Otherwise it may happen that any other distribution is detected as openzaurus, just | ||
228 | // because it uses a jffs2 filesystem.. | ||
229 | // (eilers) | ||
230 | // if ( f. open ( IO_ReadOnly ) && ( QTextStream ( &f ). read(). find ( "\tjffs2\n" ) >= 0 )) { | ||
231 | QFile f ("/etc/oz_version"); | ||
232 | if ( f.exists() ){ | ||
233 | d->m_vendorstr = "OpenZaurus Team"; | ||
234 | d->m_systemstr = "OpenZaurus"; | ||
235 | d->m_system = System_OpenZaurus; | ||
236 | |||
237 | if ( f. open ( IO_ReadOnly )) { | ||
238 | QTextStream ts ( &f ); | ||
239 | d->m_sysverstr = ts. readLine();//. mid ( 10 ); | ||
240 | f. close(); | ||
241 | } | ||
242 | |||
243 | // Openzaurus sometimes uses the embedix kernel! | ||
244 | // => Check whether this is an embedix kernel | ||
245 | FILE *uname = popen("uname -r", "r"); | ||
246 | QString line; | ||
247 | if ( f.open(IO_ReadOnly, uname) ) { | ||
248 | QTextStream ts ( &f ); | ||
249 | line = ts. readLine(); | ||
250 | int loc = line. find ( "embedix" ); | ||
251 | if ( loc != -1 ) | ||
252 | m_embedix = true; | ||
253 | else | ||
254 | m_embedix = false; | ||
255 | f. close(); | ||
256 | } | ||
257 | pclose(uname); | ||
258 | } | ||
259 | else { | ||
260 | d->m_systemstr = "Zaurus"; | ||
261 | d->m_system = System_Zaurus; | ||
262 | } | ||
263 | |||
264 | f. setName ( "/proc/cpuinfo" ); | ||
265 | if ( f. open ( IO_ReadOnly ) ) { | ||
266 | QTextStream ts ( &f ); | ||
267 | QString line; | ||
268 | while( line = ts. readLine() ) { | ||
269 | if ( line. left ( 8 ) == "Hardware" ) | ||
270 | break; | ||
271 | } | ||
272 | int loc = line. find ( ":" ); | ||
273 | if ( loc != -1 ) | ||
274 | model = line. mid ( loc + 2 ). simplifyWhiteSpace( ); | ||
275 | } | ||
276 | |||
277 | if ( model == "SHARP Corgi" ) { | ||
278 | d->m_model = Model_Zaurus_SLC7x0; | ||
279 | d->m_modelstr = "Zaurus SL-C700"; | ||
280 | } else if ( model == "SHARP Shepherd" ) { | ||
281 | d->m_model = Model_Zaurus_SLC7x0; | ||
282 | d->m_modelstr = "Zaurus SL-C750"; | ||
283 | } else if ( model == "SHARP Husky" ) { | ||
284 | d->m_model = Model_Zaurus_SLC7x0; | ||
285 | d->m_modelstr = "Zaurus SL-C760"; | ||
286 | } else if ( model == "SHARP Poodle" ) { | ||
287 | d->m_model = Model_Zaurus_SLB600; | ||
288 | d->m_modelstr = "Zaurus SL-B500 or SL-5600"; | ||
289 | } else if ( model == "Sharp-Collie" || model == "Collie" ) { | ||
290 | d->m_model = Model_Zaurus_SL5500; | ||
291 | d->m_modelstr = "Zaurus SL-5500 or SL-5000d"; | ||
292 | } else { | ||
293 | d->m_model = Model_Zaurus_SL5500; | ||
294 | d->m_modelstr = "Zaurus (Model unknown)"; | ||
295 | } | ||
296 | |||
297 | bool flipstate = false; | ||
298 | switch ( d->m_model ) { | ||
299 | case Model_Zaurus_SLA300: | ||
300 | d->m_rotation = Rot0; | ||
301 | break; | ||
302 | case Model_Zaurus_SLC7x0: | ||
303 | d->m_rotation = rotation(); | ||
304 | d->m_direction = direction(); | ||
305 | break; | ||
306 | case Model_Zaurus_SLB600: | ||
307 | case Model_Zaurus_SL5500: | ||
308 | case Model_Zaurus_SL5000: | ||
309 | default: | ||
310 | d->m_rotation = Rot270; | ||
311 | break; | ||
312 | } | ||
313 | m_leds [0] = Led_Off; | ||
314 | } | ||
315 | |||
316 | void Zaurus::initButtons() | ||
317 | { | ||
318 | if ( d->m_buttons ) | ||
319 | return; | ||
320 | |||
321 | d->m_buttons = new QValueList <ODeviceButton>; | ||
322 | |||
323 | struct z_button * pz_buttons; | ||
324 | int buttoncount; | ||
325 | switch ( d->m_model ) { | ||
326 | case Model_Zaurus_SLC7x0: | ||
327 | pz_buttons = z_buttons_c700; | ||
328 | buttoncount = ARRAY_SIZE(z_buttons_c700); | ||
329 | break; | ||
330 | default: | ||
331 | pz_buttons = z_buttons; | ||
332 | buttoncount = ARRAY_SIZE(z_buttons); | ||
333 | break; | ||
334 | } | ||
335 | |||
336 | for ( int i = 0; i < buttoncount; i++ ) { | ||
337 | struct z_button *zb = pz_buttons + i; | ||
338 | ODeviceButton b; | ||
339 | |||
340 | b. setKeycode ( zb->code ); | ||
341 | b. setUserText ( QObject::tr ( "Button", zb->utext )); | ||
342 | b. setPixmap ( Resource::loadPixmap ( zb->pix )); | ||
343 | b. setFactoryPresetPressedAction ( OQCopMessage ( makeChannel ( zb->fpressedservice ), | ||
344 | zb->fpressedaction )); | ||
345 | b. setFactoryPresetHeldAction ( OQCopMessage ( makeChannel ( zb->fheldservice ), | ||
346 | zb->fheldaction )); | ||
347 | |||
348 | d->m_buttons->append ( b ); | ||
349 | } | ||
350 | |||
351 | reloadButtonMapping(); | ||
352 | |||
353 | QCopChannel *sysch = new QCopChannel ( "QPE/System", this ); | ||
354 | connect ( sysch, SIGNAL( received( const QCString &, const QByteArray & )), | ||
355 | this, SLOT( systemMessage ( const QCString &, const QByteArray & ))); | ||
356 | } | ||
357 | |||
358 | #include <unistd.h> | ||
359 | #include <fcntl.h> | ||
360 | #include <sys/ioctl.h> | ||
361 | |||
362 | //#include <asm/sharp_char.h> // including kernel headers is evil ... | ||
363 | |||
364 | #define SHARP_DEV_IOCTL_COMMAND_START 0x5680 | ||
365 | |||
366 | #defineSHARP_BUZZER_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START) | ||
367 | #define SHARP_BUZZER_MAKESOUND (SHARP_BUZZER_IOCTL_START) | ||
368 | |||
369 | #define SHARP_BUZ_TOUCHSOUND 1 /* touch panel sound */ | ||
370 | #define SHARP_BUZ_KEYSOUND 2 /* key sound */ | ||
371 | #define SHARP_BUZ_SCHEDULE_ALARM 11 /* schedule alarm */ | ||
372 | |||
373 | /* --- for SHARP_BUZZER device --- */ | ||
374 | |||
375 | //#defineSHARP_BUZZER_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START) | ||
376 | //#define SHARP_BUZZER_MAKESOUND (SHARP_BUZZER_IOCTL_START) | ||
377 | |||
378 | #define SHARP_BUZZER_SETVOLUME (SHARP_BUZZER_IOCTL_START+1) | ||
379 | #define SHARP_BUZZER_GETVOLUME (SHARP_BUZZER_IOCTL_START+2) | ||
380 | #define SHARP_BUZZER_ISSUPPORTED (SHARP_BUZZER_IOCTL_START+3) | ||
381 | #define SHARP_BUZZER_SETMUTE (SHARP_BUZZER_IOCTL_START+4) | ||
382 | #define SHARP_BUZZER_STOPSOUND (SHARP_BUZZER_IOCTL_START+5) | ||
383 | |||
384 | //#define SHARP_BUZ_TOUCHSOUND 1 /* touch panel sound */ | ||
385 | //#define SHARP_BUZ_KEYSOUND 2 /* key sound */ | ||
386 | |||
387 | //#define SHARP_PDA_ILLCLICKSOUND 3 /* illegal click */ | ||
388 | //#define SHARP_PDA_WARNSOUND 4 /* warning occurred */ | ||
389 | //#define SHARP_PDA_ERRORSOUND 5 /* error occurred */ | ||
390 | //#define SHARP_PDA_CRITICALSOUND 6 /* critical error occurred */ | ||
391 | //#define SHARP_PDA_SYSSTARTSOUND 7 /* system start */ | ||
392 | //#define SHARP_PDA_SYSTEMENDSOUND 8 /* system shutdown */ | ||
393 | //#define SHARP_PDA_APPSTART 9 /* application start */ | ||
394 | //#define SHARP_PDA_APPQUIT 10 /* application ends */ | ||
395 | |||
396 | //#define SHARP_BUZ_SCHEDULE_ALARM 11 /* schedule alarm */ | ||
397 | //#define SHARP_BUZ_DAILY_ALARM 12 /* daily alarm */ | ||
398 | //#define SHARP_BUZ_GOT_PHONE_CALL 13 /* phone call sound */ | ||
399 | //#define SHARP_BUZ_GOT_MAIL 14 /* mail sound */ | ||
400 | // | ||
401 | |||
402 | #defineSHARP_LED_IOCTL_START (SHARP_DEV_IOCTL_COMMAND_START) | ||
403 | #define SHARP_LED_SETSTATUS (SHARP_LED_IOCTL_START+1) | ||
404 | |||
405 | #define SHARP_IOCTL_GET_ROTATION 0x413c | ||
406 | |||
407 | typedef struct sharp_led_status { | ||
408 | int which; /* select which LED status is wanted. */ | ||
409 | int status; /* set new led status if you call SHARP_LED_SETSTATUS */ | ||
410 | } sharp_led_status; | ||
411 | |||
412 | #define SHARP_LED_MAIL_EXISTS 9 /* mail status (exists or not) */ | ||
413 | |||
414 | #define LED_MAIL_NO_UNREAD_MAIL 0 /* for SHARP_LED_MAIL_EXISTS */ | ||
415 | #define LED_MAIL_NEWMAIL_EXISTS 1 /* for SHARP_LED_MAIL_EXISTS */ | ||
416 | #define LED_MAIL_UNREAD_MAIL_EX 2 /* for SHARP_LED_MAIL_EXISTS */ | ||
417 | |||
418 | // #include <asm/sharp_apm.h> // including kernel headers is evil ... | ||
419 | |||
420 | #define APM_IOCGEVTSRC OD_IOR( 'A', 203, int ) | ||
421 | #define APM_IOCSEVTSRC OD_IORW( 'A', 204, int ) | ||
422 | #define APM_EVT_POWER_BUTTON (1 << 0) | ||
423 | |||
424 | #define FL_IOCTL_STEP_CONTRAST 100 | ||
425 | |||
426 | |||
427 | void Zaurus::buzzer ( int sound ) | ||
428 | { | ||
429 | #ifndef QT_NO_SOUND | ||
430 | QString soundname; | ||
431 | |||
432 | // Not all devices have real sound | ||
433 | if ( d->m_model == Model_Zaurus_SLC7x0 | ||
434 | || d->m_model == Model_Zaurus_SLB600 ){ | ||
435 | |||
436 | switch ( sound ){ | ||
437 | case SHARP_BUZ_SCHEDULE_ALARM: | ||
438 | soundname = "alarm"; | ||
439 | break; | ||
440 | case SHARP_BUZ_TOUCHSOUND: | ||
441 | soundname = "touchsound"; | ||
442 | break; | ||
443 | case SHARP_BUZ_KEYSOUND: | ||
444 | soundname = "keysound"; | ||
445 | break; | ||
446 | default: | ||
447 | soundname = "alarm"; | ||
448 | |||
449 | } | ||
450 | } | ||
451 | |||
452 | // If a soundname is defined, we expect that this device has | ||
453 | // sound capabilities.. Otherwise we expect to have the buzzer | ||
454 | // device.. | ||
455 | if ( !soundname.isEmpty() ){ | ||
456 | int fd; | ||
457 | int vol; | ||
458 | bool vol_reset = false; | ||
459 | |||
460 | Sound snd ( soundname ); | ||
461 | |||
462 | if (( fd = ::open ( "/dev/sound/mixer", O_RDWR )) >= 0 ) { | ||
463 | if ( ::ioctl ( fd, MIXER_READ( 0 ), &vol ) >= 0 ) { | ||
464 | Config cfg ( "qpe" ); | ||
465 | cfg. setGroup ( "Volume" ); | ||
466 | |||
467 | int volalarm = cfg. readNumEntry ( "AlarmPercent", 50 ); | ||
468 | if ( volalarm < 0 ) | ||
469 | volalarm = 0; | ||
470 | else if ( volalarm > 100 ) | ||
471 | volalarm = 100; | ||
472 | volalarm |= ( volalarm << 8 ); | ||
473 | |||
474 | if ( ::ioctl ( fd, MIXER_WRITE( 0 ), &volalarm ) >= 0 ) | ||
475 | vol_reset = true; | ||
476 | } | ||
477 | } | ||
478 | |||
479 | snd. play(); | ||
480 | while ( !snd. isFinished()) | ||
481 | qApp->processEvents(); | ||
482 | |||
483 | if ( fd >= 0 ) { | ||
484 | if ( vol_reset ) | ||
485 | ::ioctl ( fd, MIXER_WRITE( 0 ), &vol ); | ||
486 | ::close ( fd ); | ||
487 | } | ||
488 | } else { | ||
489 | int fd = ::open ( "/dev/sharp_buz", O_WRONLY|O_NONBLOCK ); | ||
490 | |||
491 | if ( fd >= 0 ) { | ||
492 | ::ioctl ( fd, SHARP_BUZZER_MAKESOUND, sound ); | ||
493 | ::close ( fd ); | ||
494 | } | ||
495 | |||
496 | } | ||
497 | #endif | ||
498 | } | ||
499 | |||
500 | |||
501 | void Zaurus::alarmSound() | ||
502 | { | ||
503 | buzzer ( SHARP_BUZ_SCHEDULE_ALARM ); | ||
504 | } | ||
505 | |||
506 | void Zaurus::touchSound() | ||
507 | { | ||
508 | buzzer ( SHARP_BUZ_TOUCHSOUND ); | ||
509 | } | ||
510 | |||
511 | void Zaurus::keySound() | ||
512 | { | ||
513 | buzzer ( SHARP_BUZ_KEYSOUND ); | ||
514 | } | ||
515 | |||
516 | |||
517 | QValueList <OLed> Zaurus::ledList() const | ||
518 | { | ||
519 | QValueList <OLed> vl; | ||
520 | vl << Led_Mail; | ||
521 | return vl; | ||
522 | } | ||
523 | |||
524 | QValueList <OLedState> Zaurus::ledStateList ( OLed l ) const | ||
525 | { | ||
526 | QValueList <OLedState> vl; | ||
527 | |||
528 | if ( l == Led_Mail ) | ||
529 | vl << Led_Off << Led_On << Led_BlinkSlow; | ||
530 | return vl; | ||
531 | } | ||
532 | |||
533 | OLedState Zaurus::ledState ( OLed which ) const | ||
534 | { | ||
535 | if ( which == Led_Mail ) | ||
536 | return m_leds [0]; | ||
537 | else | ||
538 | return Led_Off; | ||
539 | } | ||
540 | |||
541 | bool Zaurus::setLedState ( OLed which, OLedState st ) | ||
542 | { | ||
543 | if (!m_embedix) // Currently not supported on non_embedix kernels | ||
544 | return false; | ||
545 | |||
546 | static int fd = ::open ( "/dev/sharp_led", O_RDWR|O_NONBLOCK ); | ||
547 | |||
548 | if ( which == Led_Mail ) { | ||
549 | if ( fd >= 0 ) { | ||
550 | struct sharp_led_status leds; | ||
551 | ::memset ( &leds, 0, sizeof( leds )); | ||
552 | leds. which = SHARP_LED_MAIL_EXISTS; | ||
553 | bool ok = true; | ||
554 | |||
555 | switch ( st ) { | ||
556 | case Led_Off : leds. status = LED_MAIL_NO_UNREAD_MAIL; break; | ||
557 | case Led_On : leds. status = LED_MAIL_NEWMAIL_EXISTS; break; | ||
558 | case Led_BlinkSlow: leds. status = LED_MAIL_UNREAD_MAIL_EX; break; | ||
559 | default : ok = false; | ||
560 | } | ||
561 | |||
562 | if ( ok && ( ::ioctl ( fd, SHARP_LED_SETSTATUS, &leds ) >= 0 )) { | ||
563 | m_leds [0] = st; | ||
564 | return true; | ||
565 | } | ||
566 | } | ||
567 | } | ||
568 | return false; | ||
569 | } | ||
570 | |||
571 | bool Zaurus::setSoftSuspend ( bool soft ) | ||
572 | { | ||
573 | if (!m_embedix) { | ||
574 | /* non-Embedix kernels dont have kernel autosuspend */ | ||
575 | return ODevice::setSoftSuspend( soft ); | ||
576 | } | ||
577 | |||
578 | bool res = false; | ||
579 | int fd; | ||
580 | |||
581 | if ((( fd = ::open ( "/dev/apm_bios", O_RDWR )) >= 0 ) || | ||
582 | (( fd = ::open ( "/dev/misc/apm_bios",O_RDWR )) >= 0 )) { | ||
583 | |||
584 | int sources = ::ioctl ( fd, APM_IOCGEVTSRC, 0 ); // get current event sources | ||
585 | |||
586 | if ( sources >= 0 ) { | ||
587 | if ( soft ) | ||
588 | sources &= ~APM_EVT_POWER_BUTTON; | ||
589 | else | ||
590 | sources |= APM_EVT_POWER_BUTTON; | ||
591 | |||
592 | if ( ::ioctl ( fd, APM_IOCSEVTSRC, sources ) >= 0 ) // set new event sources | ||
593 | res = true; | ||
594 | else | ||
595 | perror ( "APM_IOCGEVTSRC" ); | ||
596 | } | ||
597 | else | ||
598 | perror ( "APM_IOCGEVTSRC" ); | ||
599 | |||
600 | ::close ( fd ); | ||
601 | } | ||
602 | else | ||
603 | perror ( "/dev/apm_bios or /dev/misc/apm_bios" ); | ||
604 | |||
605 | return res; | ||
606 | } | ||
607 | |||
608 | |||
609 | bool Zaurus::setDisplayBrightness ( int bright ) | ||
610 | { | ||
611 | //qDebug( "Zaurus::setDisplayBrightness( %d )", bright ); | ||
612 | bool res = false; | ||
613 | int fd; | ||
614 | |||
615 | if ( bright > 255 ) bright = 255; | ||
616 | if ( bright < 0 ) bright = 0; | ||
617 | |||
618 | if ( m_embedix ) | ||
619 | { | ||
620 | if ( d->m_model == Model_Zaurus_SLC7x0 ) | ||
621 | { | ||
622 | //qDebug( "using special treatment for devices with the corgi backlight interface" ); | ||
623 | // special treatment for devices with the corgi backlight interface | ||
624 | if (( fd = ::open ( "/proc/driver/fl/corgi-bl", O_WRONLY )) >= 0 ) | ||
625 | { | ||
626 | int value = ( bright == 1 ) ? 1 : bright * ( 17.0 / 255.0 ); | ||
627 | char writeCommand[100]; | ||
628 | const int count = sprintf( writeCommand, "0x%x\n", value ); | ||
629 | res = ( ::write ( fd, writeCommand, count ) != -1 ); | ||
630 | ::close ( fd ); | ||
631 | } | ||
632 | return res; | ||
633 | } | ||
634 | else | ||
635 | { | ||
636 | // standard treatment for devices with the dumb embedix frontlight interface | ||
637 | if (( fd = ::open ( "/dev/fl", O_WRONLY )) >= 0 ) { | ||
638 | int bl = ( bright * 4 + 127 ) / 255; // only 4 steps on zaurus | ||
639 | if ( bright && !bl ) | ||
640 | bl = 1; | ||
641 | res = ( ::ioctl ( fd, FL_IOCTL_STEP_CONTRAST, bl ) == 0 ); | ||
642 | ::close ( fd ); | ||
643 | } | ||
644 | } | ||
645 | } | ||
646 | else | ||
647 | { | ||
648 | // special treatment for the OpenZaurus unified interface | ||
649 | #define FB_BACKLIGHT_SET_BRIGHTNESS _IOW('F', 1, u_int) /* set brightness */ | ||
650 | if (( fd = ::open ( "/dev/fb0", O_WRONLY )) >= 0 ) { | ||
651 | res = ( ::ioctl ( fd , FB_BACKLIGHT_SET_BRIGHTNESS, bright ) == 0 ); | ||
652 | ::close ( fd ); | ||
653 | } | ||
654 | } | ||
655 | return res; | ||
656 | } | ||
657 | |||
658 | bool Zaurus::suspend() | ||
659 | { | ||
660 | qDebug("ODevice::suspend"); | ||
661 | if ( !isQWS( ) ) // only qwsserver is allowed to suspend | ||
662 | return false; | ||
663 | |||
664 | if ( d->m_model == Model_Unknown ) // better don't suspend in qvfb / on unkown devices | ||
665 | return false; | ||
666 | |||
667 | bool res = false; | ||
668 | |||
669 | struct timeval tvs, tvn; | ||
670 | ::gettimeofday ( &tvs, 0 ); | ||
671 | |||
672 | ::sync(); // flush fs caches | ||
673 | res = ( ::system ( "apm --suspend" ) == 0 ); | ||
674 | |||
675 | // This is needed because the iPAQ apm implementation is asynchronous and we | ||
676 | // can not be sure when exactly the device is really suspended | ||
677 | // This can be deleted as soon as a stable familiar with a synchronous apm implementation exists. | ||
678 | |||
679 | if ( res ) { | ||
680 | do { // Yes, wait 15 seconds. This APM bug sucks big time. | ||
681 | ::usleep ( 200 * 1000 ); | ||
682 | ::gettimeofday ( &tvn, 0 ); | ||
683 | } while ((( tvn. tv_sec - tvs. tv_sec ) * 1000 + ( tvn. tv_usec - tvs. tv_usec ) / 1000 ) < 15000 ); | ||
684 | } | ||
685 | |||
686 | QCopEnvelope ( "QPE/Rotation", "rotateDefault()" ); | ||
687 | return res; | ||
688 | } | ||
689 | |||
690 | |||
691 | Transformation Zaurus::rotation() const | ||
692 | { | ||
693 | Transformation rot; | ||
694 | int handle = 0; | ||
695 | int retval = 0; | ||
696 | |||
697 | switch ( d->m_model ) { | ||
698 | case Model_Zaurus_SLC7x0: | ||
699 | handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK); | ||
700 | if (handle == -1) { | ||
701 | return Rot270; | ||
702 | } else { | ||
703 | retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION); | ||
704 | ::close (handle); | ||
705 | |||
706 | if (retval == 2 ) | ||
707 | rot = Rot0; | ||
708 | else | ||
709 | rot = Rot270; | ||
710 | } | ||
711 | break; | ||
712 | case Model_Zaurus_SLA300: | ||
713 | case Model_Zaurus_SLB600: | ||
714 | case Model_Zaurus_SL5500: | ||
715 | case Model_Zaurus_SL5000: | ||
716 | default: | ||
717 | rot = d->m_rotation; | ||
718 | break; | ||
719 | } | ||
720 | |||
721 | return rot; | ||
722 | } | ||
723 | ODirection Zaurus::direction() const | ||
724 | { | ||
725 | ODirection dir; | ||
726 | int handle = 0; | ||
727 | int retval = 0; | ||
728 | switch ( d->m_model ) { | ||
729 | case Model_Zaurus_SLC7x0: | ||
730 | handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK); | ||
731 | if (handle == -1) { | ||
732 | dir = CW; | ||
733 | } else { | ||
734 | retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION); | ||
735 | ::close (handle); | ||
736 | if (retval == 2 ) | ||
737 | dir = CCW; | ||
738 | else | ||
739 | dir = CW; | ||
740 | } | ||
741 | break; | ||
742 | case Model_Zaurus_SLA300: | ||
743 | case Model_Zaurus_SLB600: | ||
744 | case Model_Zaurus_SL5500: | ||
745 | case Model_Zaurus_SL5000: | ||
746 | default: | ||
747 | dir = d->m_direction; | ||
748 | break; | ||
749 | } | ||
750 | return dir; | ||
751 | |||
752 | } | ||
753 | |||
754 | int Zaurus::displayBrightnessResolution() const | ||
755 | { | ||
756 | if (m_embedix) | ||
757 | return d->m_model == Model_Zaurus_SLC7x0 ? 18 : 5; | ||
758 | else | ||
759 | return 256; | ||
760 | } | ||
761 | |||
762 | bool Zaurus::hasHingeSensor() const | ||
763 | { | ||
764 | return d->m_model == Model_Zaurus_SLC7x0; | ||
765 | } | ||
766 | |||
767 | OHingeStatus Zaurus::readHingeSensor() | ||
768 | { | ||
769 | int handle = ::open("/dev/apm_bios", O_RDWR|O_NONBLOCK); | ||
770 | if (handle == -1) | ||
771 | { | ||
772 | qWarning("Zaurus::readHingeSensor() - failed (%s)", "unknown reason" ); //FIXME: use strerror | ||
773 | return CASE_UNKNOWN; | ||
774 | } | ||
775 | else | ||
776 | { | ||
777 | int retval = ::ioctl(handle, SHARP_IOCTL_GET_ROTATION); | ||
778 | ::close (handle); | ||
779 | if ( retval == CASE_CLOSED || retval == CASE_PORTRAIT || retval == CASE_LANDSCAPE ) | ||
780 | { | ||
781 | qDebug( "Zaurus::readHingeSensor() - result = %d", retval ); | ||
782 | return static_cast<OHingeStatus>( retval ); | ||
783 | } | ||
784 | else | ||
785 | { | ||
786 | qWarning("Zaurus::readHingeSensor() - couldn't compute hinge status!" ); | ||
787 | return CASE_UNKNOWN; | ||
788 | } | ||
789 | } | ||
790 | } | ||
diff --git a/libopie2/opiecore/device/odevicebutton.cpp b/libopie2/opiecore/device/odevicebutton.cpp new file mode 100644 index 0000000..0b593d5 --- a/dev/null +++ b/libopie2/opiecore/device/odevicebutton.cpp | |||
@@ -0,0 +1,246 @@ | |||
1 | /* | ||
2 | This file is part of the Opie Project | ||
3 | Copyright (C) The Opie Team <opie-devel@handhelds.org> | ||
4 | =. | ||
5 | .=l. | ||
6 | .>+-= | ||
7 | _;:, .> :=|. This program is free software; you can | ||
8 | .> <`_, > . <= redistribute it and/or modify it under | ||
9 | :`=1 )Y*s>-.-- : the terms of the GNU Library General Public | ||
10 | .="- .-=="i, .._ License as published by the Free Software | ||
11 | - . .-<_> .<> Foundation; either version 2 of the License, | ||
12 | ._= =} : or (at your option) any later version. | ||
13 | .%`+i> _;_. | ||
14 | .i_,=:_. -<s. This program is distributed in the hope that | ||
15 | + . -:. = it will be useful, but WITHOUT ANY WARRANTY; | ||
16 | : .. .:, . . . without even the implied warranty of | ||
17 | =_ + =;=|` MERCHANTABILITY or FITNESS FOR A | ||
18 | _.=:. : :=>`: PARTICULAR PURPOSE. See the GNU | ||
19 | ..}^=.= = ; Library General Public License for more | ||
20 | ++= -. .` .: details. | ||
21 | : = ...= . :.=- | ||
22 | -. .:....=;==+<; You should have received a copy of the GNU | ||
23 | -_. . . )=. = Library General Public License along with | ||
24 | -- :-=` this library; see the file COPYING.LIB. | ||
25 | If not, write to the Free Software Foundation, | ||
26 | Inc., 59 Temple Place - Suite 330, | ||
27 | Boston, MA 02111-1307, USA. | ||
28 | */ | ||
29 | |||
30 | #include <qpixmap.h> | ||
31 | #include <qstring.h> | ||
32 | |||
33 | #include <qpe/qcopenvelope_qws.h> | ||
34 | #include <opie2/odevicebutton.h> | ||
35 | |||
36 | using namespace Opie; | ||
37 | |||
38 | class OQCopMessageData | ||
39 | { | ||
40 | public: | ||
41 | QCString m_channel; | ||
42 | QCString m_message; | ||
43 | QByteArray m_data; | ||
44 | }; | ||
45 | |||
46 | |||
47 | OQCopMessage::OQCopMessage() | ||
48 | : d ( 0 ) | ||
49 | { | ||
50 | init ( QCString(), QCString(), QByteArray()); | ||
51 | } | ||
52 | |||
53 | OQCopMessage::OQCopMessage ( const OQCopMessage © ) | ||
54 | : d ( 0 ) | ||
55 | { | ||
56 | init ( copy. channel(), copy. message(), copy. data()); | ||
57 | } | ||
58 | |||
59 | OQCopMessage &OQCopMessage::operator = ( const OQCopMessage &assign ) | ||
60 | { | ||
61 | init ( assign. channel(), assign. message(), assign. data()); | ||
62 | return *this; | ||
63 | } | ||
64 | |||
65 | OQCopMessage::OQCopMessage ( const QCString &ch, const QCString &m, const QByteArray &arg ) | ||
66 | : d ( 0 ) | ||
67 | { | ||
68 | init ( ch, m, arg ); | ||
69 | } | ||
70 | |||
71 | void OQCopMessage::init ( const QCString &ch, const QCString &m, const QByteArray &arg ) | ||
72 | { | ||
73 | if ( !d ) | ||
74 | d = new OQCopMessageData(); | ||
75 | d->m_channel = ch; | ||
76 | d->m_message = m; | ||
77 | d->m_data = arg; | ||
78 | } | ||
79 | |||
80 | bool OQCopMessage::send() | ||
81 | { | ||
82 | if ( d->m_channel. isEmpty() || d->m_message. isEmpty() ) | ||
83 | return false; | ||
84 | |||
85 | QCopEnvelope e ( d->m_channel, d->m_message ); | ||
86 | |||
87 | if ( d->m_data. size()) | ||
88 | e. writeRawBytes ( d->m_data. data(), d->m_data. size()); | ||
89 | |||
90 | return true; | ||
91 | } | ||
92 | |||
93 | QCString OQCopMessage::channel() const | ||
94 | { | ||
95 | return d->m_channel; | ||
96 | } | ||
97 | |||
98 | QCString OQCopMessage::message() const | ||
99 | { | ||
100 | return d->m_message; | ||
101 | } | ||
102 | |||
103 | QByteArray OQCopMessage::data() const | ||
104 | { | ||
105 | return d->m_data; | ||
106 | } | ||
107 | |||
108 | bool OQCopMessage::isNull() const | ||
109 | { | ||
110 | return d->m_message.isNull() || d->m_channel.isNull(); | ||
111 | } | ||
112 | void OQCopMessage::setChannel ( const QCString &ch ) | ||
113 | { | ||
114 | d->m_channel = ch; | ||
115 | } | ||
116 | |||
117 | void OQCopMessage::setMessage ( const QCString &m ) | ||
118 | { | ||
119 | d->m_message = m; | ||
120 | } | ||
121 | |||
122 | void OQCopMessage::setData ( const QByteArray &data ) | ||
123 | { | ||
124 | d->m_data = data; | ||
125 | } | ||
126 | |||
127 | /*! \class Opie::ODeviceButton | ||
128 | \brief The Opie::ODeviceButton class represents a physical user mappable button on a Qtopia device. | ||
129 | |||
130 | This class represents a physical button on a Qtopia device. A | ||
131 | device may have "user programmable" buttons. | ||
132 | The location and number of buttons will vary from device to | ||
133 | device. userText() and pixmap() may be used to describe this button | ||
134 | to the user in help documentation. | ||
135 | |||
136 | \ingroup qtopiaemb | ||
137 | \internal | ||
138 | */ | ||
139 | |||
140 | ODeviceButton::ODeviceButton() | ||
141 | {} | ||
142 | |||
143 | ODeviceButton::~ODeviceButton() | ||
144 | {} | ||
145 | |||
146 | /*! | ||
147 | Returns the button's keycode. | ||
148 | */ | ||
149 | ushort ODeviceButton::keycode() const | ||
150 | { | ||
151 | return m_Keycode; | ||
152 | } | ||
153 | |||
154 | |||
155 | /*! | ||
156 | This function returns a human readable, translated description of the button. | ||
157 | */ | ||
158 | QString ODeviceButton::userText() const | ||
159 | { | ||
160 | return m_UserText; | ||
161 | } | ||
162 | |||
163 | /*! | ||
164 | This function returns the pixmap for this button. If there isn't one | ||
165 | it will return an empty (null) pixmap. | ||
166 | */ | ||
167 | QPixmap ODeviceButton::pixmap() const | ||
168 | { | ||
169 | return m_Pixmap; | ||
170 | } | ||
171 | |||
172 | /*! | ||
173 | This function returns the factory preset (default) action for when this button | ||
174 | is pressed. The return value is a legal QCop message. | ||
175 | */ | ||
176 | OQCopMessage ODeviceButton::factoryPresetPressedAction() const | ||
177 | { | ||
178 | return m_FactoryPresetPressedAction; | ||
179 | } | ||
180 | |||
181 | /*! | ||
182 | This function returns the user assigned action for when this button is pressed. | ||
183 | If no action is assigned, factoryPresetAction() is returned. | ||
184 | */ | ||
185 | OQCopMessage ODeviceButton::pressedAction() const | ||
186 | { | ||
187 | if (m_PressedAction.channel().isEmpty()) | ||
188 | return factoryPresetPressedAction(); | ||
189 | return m_PressedAction; | ||
190 | } | ||
191 | |||
192 | /*! | ||
193 | This function returns the factory preset (default) action for when this button | ||
194 | is pressed and held. The return value is a legal QCop message. | ||
195 | */ | ||
196 | OQCopMessage ODeviceButton::factoryPresetHeldAction() const | ||
197 | { | ||
198 | return m_FactoryPresetHeldAction; | ||
199 | } | ||
200 | |||
201 | /*! | ||
202 | This function returns the user assigned action for when this button is pressed | ||
203 | and held. If no action is assigned, factoryPresetAction() is returned. | ||
204 | */ | ||
205 | OQCopMessage ODeviceButton::heldAction() const | ||
206 | { | ||
207 | if (m_HeldAction.channel().isEmpty()) | ||
208 | return factoryPresetHeldAction(); | ||
209 | return m_HeldAction; | ||
210 | } | ||
211 | |||
212 | void ODeviceButton::setKeycode(ushort keycode) | ||
213 | { | ||
214 | m_Keycode = keycode; | ||
215 | } | ||
216 | |||
217 | void ODeviceButton::setUserText(const QString& text) | ||
218 | { | ||
219 | m_UserText = text; | ||
220 | } | ||
221 | |||
222 | void ODeviceButton::setPixmap(const QPixmap& picture) | ||
223 | { | ||
224 | m_Pixmap = picture; | ||
225 | } | ||
226 | |||
227 | void ODeviceButton::setFactoryPresetPressedAction(const OQCopMessage& action) | ||
228 | { | ||
229 | m_FactoryPresetPressedAction = action; | ||
230 | } | ||
231 | |||
232 | |||
233 | void ODeviceButton::setPressedAction(const OQCopMessage& action) | ||
234 | { | ||
235 | m_PressedAction = action; | ||
236 | } | ||
237 | |||
238 | void ODeviceButton::setFactoryPresetHeldAction(const OQCopMessage& action) | ||
239 | { | ||
240 | m_FactoryPresetHeldAction = action; | ||
241 | } | ||
242 | |||
243 | void ODeviceButton::setHeldAction(const OQCopMessage& action) | ||
244 | { | ||
245 | m_HeldAction = action; | ||
246 | } | ||
diff --git a/libopie2/opiecore/device/odevicebutton.h b/libopie2/opiecore/device/odevicebutton.h new file mode 100644 index 0000000..a66b88f --- a/dev/null +++ b/libopie2/opiecore/device/odevicebutton.h | |||
@@ -0,0 +1,108 @@ | |||
1 | /********************************************************************** | ||
2 | ** Copyright (C) 2000-2002 Trolltech AS. All rights reserved. | ||
3 | ** | ||
4 | ** This file is part of the Qtopia Environment. | ||
5 | ** | ||
6 | ** This file may be distributed and/or modified under the terms of the | ||
7 | ** GNU General Public License version 2 as published by the Free Software | ||
8 | ** Foundation and appearing in the file LICENSE.GPL included in the | ||
9 | ** packaging of this file. | ||
10 | ** | ||
11 | ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE | ||
12 | ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. | ||
13 | ** | ||
14 | ** See http://www.trolltech.com/gpl/ for GPL licensing information. | ||
15 | ** | ||
16 | ** Contact info@trolltech.com if any conditions of this licensing are | ||
17 | ** not clear to you. | ||
18 | ** | ||
19 | **********************************************************************/ | ||
20 | #ifndef DEVICE_BUTTON_H | ||
21 | #define DEVICE_BUTTON_H | ||
22 | |||
23 | #include <qpixmap.h> | ||
24 | #include <qstring.h> | ||
25 | |||
26 | class OQCopMessageData; | ||
27 | |||
28 | namespace Opie | ||
29 | { | ||
30 | |||
31 | class OQCopMessage | ||
32 | { | ||
33 | public: | ||
34 | OQCopMessage ( ); | ||
35 | OQCopMessage ( const OQCopMessage © ); | ||
36 | OQCopMessage ( const QCString &m_channel, const QCString &message, const QByteArray &args = QByteArray ( )); | ||
37 | |||
38 | OQCopMessage &operator = ( const OQCopMessage &assign ); | ||
39 | |||
40 | void setChannel ( const QCString &channel ); | ||
41 | void setMessage ( const QCString &message ); | ||
42 | void setData ( const QByteArray &ba ); | ||
43 | |||
44 | QCString channel ( ) const; | ||
45 | QCString message ( ) const; | ||
46 | QByteArray data ( ) const; | ||
47 | |||
48 | bool isNull()const; | ||
49 | |||
50 | bool send ( ); | ||
51 | |||
52 | private: | ||
53 | void init ( const QCString &m_channel, const QCString &message, const QByteArray &args ); | ||
54 | |||
55 | OQCopMessageData *d; | ||
56 | class Private; | ||
57 | Private* m_data; | ||
58 | }; | ||
59 | |||
60 | |||
61 | /** | ||
62 | * This class represents a physical button on a Qtopia device. A device may | ||
63 | * have n "user programmable" buttons, which are number 1..n. The location | ||
64 | * and number of buttons will vary from device to device. userText() and pixmap() | ||
65 | * may be used to describe this button to the user in help documentation. | ||
66 | * | ||
67 | * @version 1.0 | ||
68 | * @author Trolltech | ||
69 | * @short A representation of buttons | ||
70 | */ | ||
71 | |||
72 | class ODeviceButton | ||
73 | { | ||
74 | public: | ||
75 | ODeviceButton(); | ||
76 | virtual ~ODeviceButton(); | ||
77 | |||
78 | ushort keycode ( ) const; | ||
79 | QString userText ( ) const; | ||
80 | QPixmap pixmap ( ) const; | ||
81 | OQCopMessage factoryPresetPressedAction ( ) const; | ||
82 | OQCopMessage pressedAction ( ) const; | ||
83 | OQCopMessage factoryPresetHeldAction ( ) const; | ||
84 | OQCopMessage heldAction ( ) const; | ||
85 | |||
86 | void setKeycode ( ushort keycode ); | ||
87 | void setUserText ( const QString& text ); | ||
88 | void setPixmap ( const QPixmap& picture ); | ||
89 | void setFactoryPresetPressedAction ( const OQCopMessage& qcopMessage ); | ||
90 | void setPressedAction ( const OQCopMessage& qcopMessage ); | ||
91 | void setFactoryPresetHeldAction ( const OQCopMessage& qcopMessage ); | ||
92 | void setHeldAction ( const OQCopMessage& qcopMessage ); | ||
93 | |||
94 | private: | ||
95 | ushort m_Keycode; | ||
96 | QString m_UserText; | ||
97 | QPixmap m_Pixmap; | ||
98 | OQCopMessage m_FactoryPresetPressedAction; | ||
99 | OQCopMessage m_PressedAction; | ||
100 | OQCopMessage m_FactoryPresetHeldAction; | ||
101 | OQCopMessage m_HeldAction; | ||
102 | class Private; | ||
103 | Private *d; | ||
104 | }; | ||
105 | |||
106 | } | ||
107 | |||
108 | #endif | ||