apps/gui/usb_screen.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2002 Björn Stenberg
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdio.h>
  23 #include <stdbool.h>
  24 #include "action.h"
  25 #include "font.h"
  26 #ifdef HAVE_REMOTE_LCD
  27 #include "lcd-remote.h"
  28 #endif
  29 #include "lang.h"
  30 #include "usb.h"
  31 #if defined(HAVE_USBSTACK)
  32 #include "usb_core.h"
  33 #ifdef USB_ENABLE_HID
  34 #include "usb_keymaps.h"
  35 #endif
  36 #endif
  37 #include "settings.h"
  38 #include "led.h"
  39 #include "appevents.h"
  40 #include "usb_screen.h"
  41
  42 #ifdef HAVE_LCD_BITMAP
  43 #include "bitmaps/usblogo.h"
  44 #endif
  45
  46 #ifdef HAVE_REMOTE_LCD
  47 #include "bitmaps/remote_usblogo.h"
  48 #endif
  49
  50 #if (CONFIG_STORAGE & STORAGE_MMC)
  51 #include "ata_mmc.h"
  52 #endif
  53
  54 #ifdef USB_ENABLE_HID
  55 int usb_keypad_mode;
  56 static bool usb_hid;
  57 #endif
  58
  59 #ifndef SIMULATOR
  60
  61 static int handle_usb_events(void)
  62 {
  63 #if (CONFIG_STORAGE & STORAGE_MMC)
  64     int next_update=0;
  65 #endif /* STORAGE_MMC */
  66
  67     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
  68     while(1)
  69     {
  70         int button;
  71 #ifdef USB_ENABLE_HID
  72         if (usb_hid)
  73         {
  74             button = get_hid_usb_action();
  75
  76             /* On mode change, we need to refresh the screen */
  77             if (button == ACTION_USB_HID_MODE_SWITCH_NEXT ||
  78                     button == ACTION_USB_HID_MODE_SWITCH_PREV)
  79             {
  80                 break;
  81             }
  82         }
  83         else
  84 #endif
  85         {
  86             button = button_get_w_tmo(HZ/2);
  87             /* hid emits the event in get_action */
  88             send_event(GUI_EVENT_ACTIONUPDATE, NULL);
  89         }
  90
  91         switch(button)
  92         {
  93             case SYS_USB_DISCONNECTED:
  94                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
  95                 return 1;
  96             case SYS_CHARGER_DISCONNECTED:
  97                 /*reset rockbox battery runtime*/
  98                 global_status.runtime = 0;
  99                 break;
 100             case SYS_TIMEOUT:
 101                 break;
 102         }
 103
 104 #if (CONFIG_STORAGE & STORAGE_MMC) /* USB-MMC bridge can report activity */
 105         if(TIME_AFTER(current_tick,next_update))
 106         {
 107             if(usb_inserted()) {
 108                 led(mmc_usb_active(HZ));
 109             }
 110             next_update=current_tick+HZ/2;
 111         }
 112 #endif /* STORAGE_MMC */
 113     }
 114
 115     return 0;
 116 }
 117 #endif /* SIMULATOR */
 118
 119 #define MODE_NAME_LEN 32
 120
 121 struct usb_screen_vps_t
 122 {
 123     struct viewport parent;
 124 #ifdef HAVE_LCD_BITMAP
 125     struct viewport logo;
 126 #ifdef USB_ENABLE_HID
 127     struct viewport title;
 128 #endif
 129 #endif
 130 };
 131
 132 #ifdef HAVE_LCD_BITMAP
 133 static void usb_screen_fix_viewports(struct screen *screen,
 134         struct usb_screen_vps_t *usb_screen_vps)
 135 {
 136     bool disable = true;
 137     int logo_width, logo_height;
 138     struct viewport *parent = &usb_screen_vps->parent;
 139     struct viewport *logo = &usb_screen_vps->logo;
 140
 141 #ifdef HAVE_REMOTE_LCD
 142     if (screen->screen_type == SCREEN_REMOTE)
 143     {
 144         logo_width = BMPWIDTH_remote_usblogo;
 145         logo_height = BMPHEIGHT_remote_usblogo;
 146     }
 147     else
 148 #endif
 149     {
 150         logo_width = BMPWIDTH_usblogo;
 151         logo_height = BMPHEIGHT_usblogo;
 152     }
 153
 154     viewport_set_defaults(parent, screen->screen_type);
 155     disable = (parent->width < logo_width || parent->height < logo_height);
 156     viewportmanager_theme_enable(screen->screen_type, !disable, parent);
 157
 158     *logo = *parent;
 159     logo->x = parent->x + parent->width - logo_width;
 160     logo->y = parent->y + (parent->height - logo_height) / 2;
 161     logo->width = logo_width;
 162     logo->height = logo_height;
 163
 164 #ifdef USB_ENABLE_HID
 165     if (usb_hid)
 166     {
 167         struct viewport *title = &usb_screen_vps->title;
 168         int char_height = font_get(parent->font)->height;
 169         *title = *parent;
 170         title->y = logo->y + logo->height + char_height;
 171         title->height = char_height;
 172         /* try to fit logo and title to parent */
 173         if (parent->y + parent->height < title->y + title->height)
 174         {
 175             logo->y = parent->y;
 176             title->y = parent->y + logo->height;
 177         }
 178     }
 179 #endif
 180 }
 181 #endif
 182
 183 static void usb_screens_draw(struct usb_screen_vps_t *usb_screen_vps_ar)
 184 {
 185     int i;
 186
 187     /* Clear main and remote screens to remove scrolling line artifacts */
 188     lcd_clear_display();
 189 #ifdef HAVE_LCD_REMOTE
 190     lcd_remote_clear_display();
 191 #endif
 192
 193     FOR_NB_SCREENS(i)
 194     {
 195         struct screen *screen = &screens[i];
 196
 197         struct usb_screen_vps_t *usb_screen_vps = &usb_screen_vps_ar[i];
 198         struct viewport *parent = &usb_screen_vps->parent;
 199 #ifdef HAVE_LCD_BITMAP
 200         struct viewport *logo = &usb_screen_vps->logo;
 201 #endif
 202
 203         screen->set_viewport(parent);
 204         screen->clear_viewport();
 205         screen->backlight_on();
 206
 207 #ifdef HAVE_LCD_BITMAP
 208         screen->set_viewport(logo);
 209 #ifdef HAVE_REMOTE_LCD
 210         if (i == SCREEN_REMOTE)
 211         {
 212             screen->bitmap(remote_usblogo, 0, 0, logo->width,
 213                 logo->height);
 214         }
 215         else
 216 #endif
 217         {
 218             screen->transparent_bitmap(usblogo, 0, 0, logo->width,
 219                 logo->height);
 220 #ifdef USB_ENABLE_HID
 221             if (usb_hid)
 222             {
 223                 char modestring[100];
 224                 screen->set_viewport(&usb_screen_vps->title);
 225                 usb_screen_vps->title.flags |= VP_FLAG_ALIGN_CENTER;
 226                 snprintf(modestring, sizeof(modestring), "%s: %s",
 227                         str(LANG_USB_KEYPAD_MODE),
 228                         str(keypad_mode_name_get()));
 229                 screen->puts_scroll(0, 0, modestring);
 230             }
 231 #endif /* USB_ENABLE_HID */
 232         }
 233         screen->set_viewport(parent);
 234
 235 #else /* HAVE_LCD_BITMAP */
 236         screen->double_height(false);
 237         screen->puts_scroll(0, 0, "[USB Mode]");
 238         status_set_param(false);
 239         status_set_audio(false);
 240         status_set_usb(true);
 241 #endif /* HAVE_LCD_BITMAP */
 242
 243         screen->set_viewport(NULL);
 244         screen->update_viewport();
 245     }
 246 }
 247
 248 void gui_usb_screen_run(void)
 249 {
 250     int i;
 251     struct usb_screen_vps_t usb_screen_vps_ar[NB_SCREENS];
 252 #if defined HAVE_TOUCHSCREEN
 253     enum touchscreen_mode old_mode = touchscreen_get_mode();
 254
 255     /* TODO: Paint buttons on screens OR switch to point mode and use
 256      * touchscreen as a touchpad to move the host's mouse cursor */
 257     touchscreen_set_mode(TOUCHSCREEN_BUTTON);
 258 #endif
 259
 260 #ifndef SIMULATOR
 261     usb_acknowledge(SYS_USB_CONNECTED_ACK);
 262 #endif
 263
 264 #ifdef USB_ENABLE_HID
 265     usb_hid = global_settings.usb_hid;
 266     usb_keypad_mode = global_settings.usb_keypad_mode;
 267 #endif
 268
 269     FOR_NB_SCREENS(i)
 270     {
 271         struct screen *screen = &screens[i];
 272
 273         screen->set_viewport(NULL);
 274 #ifdef HAVE_LCD_CHARCELLS
 275         /* Quick fix. Viewports should really be enabled proper for charcell */
 276         viewport_set_defaults(&usb_screen_vps_ar[i].parent, i);
 277 #else
 278         usb_screen_fix_viewports(screen, &usb_screen_vps_ar[i]);
 279 #endif
 280     }
 281
 282     while (1)
 283     {
 284         usb_screens_draw(usb_screen_vps_ar);
 285 #ifdef SIMULATOR
 286         if (button_get_w_tmo(HZ/2))
 287             break;
 288         send_event(GUI_EVENT_ACTIONUPDATE, NULL);
 289 #else
 290         if (handle_usb_events())
 291             break;
 292 #endif /* SIMULATOR */
 293     }
 294
 295     FOR_NB_SCREENS(i)
 296     {
 297         const struct viewport* vp = NULL;
 298
 299 #if defined(HAVE_LCD_BITMAP) && defined(USB_ENABLE_HID)
 300         vp = usb_hid ? &usb_screen_vps_ar[i].title : NULL;
 301 #elif !defined(HAVE_LCD_BITMAP)
 302         vp = &usb_screen_vps_ar[i].parent;
 303 #endif
 304         if (vp)
 305             screens[i].scroll_stop(vp);
 306     }
 307 #ifdef USB_ENABLE_HID
 308     if (global_settings.usb_keypad_mode != usb_keypad_mode)
 309     {
 310         global_settings.usb_keypad_mode = usb_keypad_mode;
 311         settings_save();
 312     }
 313 #endif
 314
 315 #ifdef HAVE_TOUCHSCREEN
 316     touchscreen_set_mode(old_mode);
 317 #endif
 318
 319 #ifdef HAVE_LCD_CHARCELLS
 320     status_set_usb(false);
 321 #endif /* HAVE_LCD_CHARCELLS */
 322     FOR_NB_SCREENS(i)
 323     {
 324         screens[i].backlight_on();
 325         viewportmanager_theme_undo(i, false);
 326     }
 327
 328 }
 329