apps/gui/usb_screen.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id: screens.c 23269 2009-10-19 20:06:51Z tomers $
   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 "action.h"
  23 #ifdef HAVE_REMOTE_LCD
  24 #include "lcd-remote.h"
  25 #endif
  26 #include "lang.h"
  27 #include "usb.h"
  28 #if defined(HAVE_USBSTACK)
  29 #include "usb_core.h"
  30 #ifdef USB_ENABLE_HID
  31 #include "usb_keymaps.h"
  32 #endif
  33 #endif
  34 #include "settings.h"
  35 #include "led.h"
  36 #include "appevents.h"
  37
  38 #ifdef HAVE_LCD_BITMAP
  39 #include "bitmaps/usblogo.h"
  40 #endif
  41
  42 #ifdef HAVE_REMOTE_LCD
  43 #include "bitmaps/remote_usblogo.h"
  44 #endif
  45
  46 #if (CONFIG_STORAGE & STORAGE_MMC)
  47 #include "ata_mmc.h"
  48 #endif
  49
  50 #ifdef USB_ENABLE_HID
  51 int usb_keypad_mode;
  52 #endif
  53
  54 #ifndef SIMULATOR
  55
  56 static int handle_usb_events(void)
  57 {
  58 #if (CONFIG_STORAGE & STORAGE_MMC)
  59     int next_update=0;
  60 #endif /* STORAGE_MMC */
  61
  62     /* Don't return until we get SYS_USB_DISCONNECTED or SYS_TIMEOUT */
  63     while(1)
  64     {
  65         int button;
  66 #ifdef USB_ENABLE_HID
  67         if (usb_core_driver_enabled(USB_DRIVER_HID))
  68         {
  69             button = get_hid_usb_action();
  70
  71             /* On mode change, we need to refresh the screen */
  72             if (button == ACTION_USB_HID_MODE_SWITCH_NEXT ||
  73                     button == ACTION_USB_HID_MODE_SWITCH_PREV)
  74             {
  75                 break;
  76             }
  77         }
  78         else
  79 #endif
  80         {
  81             button = button_get_w_tmo(HZ/2);
  82             /* hid emits the event in get_action */
  83             send_event(GUI_EVENT_ACTIONUPDATE, NULL);
  84         }
  85
  86         switch(button)
  87         {
  88             case SYS_USB_DISCONNECTED:
  89                 usb_acknowledge(SYS_USB_DISCONNECTED_ACK);
  90                 return 1;
  91             case SYS_TIMEOUT:
  92                 break;
  93         }
  94
  95 #if (CONFIG_STORAGE & STORAGE_MMC) /* USB-MMC bridge can report activity */
  96         if(TIME_AFTER(current_tick,next_update))
  97         {
  98             if(usb_inserted()) {
  99                 led(mmc_usb_active(HZ));
 100             }
 101             next_update=current_tick+HZ/2;
 102         }
 103 #endif /* STORAGE_MMC */
 104     }
 105
 106     return 0;
 107 }
 108 #endif
 109
 110 #ifdef USB_NONE
 111 void gui_usb_screen_run(void)
 112 {
 113 }
 114 #else
 115 #define MODE_NAME_LEN 32
 116
 117 struct usb_screen_vps_t
 118 {
 119     struct viewport parent;
 120 #ifdef HAVE_LCD_BITMAP
 121     struct viewport logo;
 122 #ifdef USB_ENABLE_HID
 123     struct viewport title;
 124 #endif
 125 #endif
 126 };
 127
 128 #ifdef HAVE_LCD_BITMAP
 129 static void usb_screen_fix_viewports(struct screen *screen,
 130         struct usb_screen_vps_t *usb_screen_vps)
 131 {
 132     int logo_width, logo_height;
 133     struct viewport *parent = &usb_screen_vps->parent;
 134     struct viewport *logo = &usb_screen_vps->logo;
 135
 136 #ifdef HAVE_REMOTE_LCD
 137     if (screen->screen_type == SCREEN_REMOTE)
 138     {
 139         logo_width = BMPWIDTH_remote_usblogo;
 140         logo_height = BMPHEIGHT_remote_usblogo;
 141     }
 142     else
 143 #endif
 144     {
 145         logo_width = BMPWIDTH_usblogo;
 146         logo_height = BMPHEIGHT_usblogo;
 147     }
 148
 149     viewport_set_defaults(parent, screen->screen_type);
 150     if (parent->width < logo_width || parent->height < logo_height)
 151         viewport_set_fullscreen(parent, screen->screen_type);
 152
 153     *logo = *parent;
 154     logo->x = parent->width - logo_width;
 155     logo->y = (parent->height - logo_height) / 2;
 156     logo->width = logo_width;
 157     logo->height = logo_height;
 158
 159 #ifdef USB_ENABLE_HID
 160     struct viewport *title = &usb_screen_vps->title;
 161     int char_height, nb_lines;
 162
 163     /* nb_lines only returns the number of fully visible lines, small screens
 164        or really large fonts could cause problems with the calculation below.
 165        */
 166     nb_lines = viewport_get_nb_lines(parent);
 167     if (nb_lines == 0)
 168         nb_lines++;
 169
 170     char_height = parent->height/nb_lines;
 171
 172     *title = *parent;
 173     title->y = logo->y + logo->height + char_height;
 174 #endif
 175 }
 176 #endif
 177
 178 static void usb_screens_draw(struct usb_screen_vps_t *usb_screen_vps_ar)
 179 {
 180     int i;
 181     int usb_bars = VP_SB_ALLSCREENS; /* force statusbars */
 182
 183     FOR_NB_SCREENS(i)
 184     {
 185         struct screen *screen = &screens[i];
 186
 187         struct usb_screen_vps_t *usb_screen_vps = &usb_screen_vps_ar[i];
 188         struct viewport *parent = &usb_screen_vps->parent;
 189 #ifdef HAVE_LCD_BITMAP
 190         struct viewport *logo = &usb_screen_vps->logo;
 191 #endif
 192
 193         screen->set_viewport(parent);
 194         screen->backdrop_show(BACKDROP_MAIN);
 195         screen->backlight_on();
 196         screen->clear_viewport();
 197
 198 #ifdef HAVE_LCD_BITMAP
 199         screen->set_viewport(logo);
 200 #ifdef HAVE_REMOTE_LCD
 201         if (i == SCREEN_REMOTE)
 202         {
 203             screen->bitmap(remote_usblogo, 0, 0, logo->width,
 204                 logo->height);
 205         }
 206         else
 207 #endif
 208         {
 209             screen->transparent_bitmap(usblogo, 0, 0, logo->width,
 210                 logo->height);
 211 #ifdef USB_ENABLE_HID
 212             screen->set_viewport(&usb_screen_vps->title);
 213             usb_screen_vps->title.flags |= VP_FLAG_ALIGN_CENTER;
 214             screen->puts_scroll(0, 0, str(keypad_mode_name_get()));
 215 #endif /* USB_ENABLE_HID */
 216         }
 217         screen->set_viewport(parent);
 218
 219 #else /* HAVE_LCD_BITMAP */
 220         screen->double_height(false);
 221         screen->puts_scroll(0, 0, "[USB Mode]");
 222         status_set_param(false);
 223         status_set_audio(false);
 224         status_set_usb(true);
 225 #endif /* HAVE_LCD_BITMAP */
 226
 227         screen->update_viewport();
 228         screen->set_viewport(NULL);
 229
 230         /* force statusbar by ignoring the setting */
 231         usb_bars |= VP_SB_IGNORE_SETTING(i);
 232     }
 233
 234     viewportmanager_set_statusbar(usb_bars);
 235 }
 236
 237 void gui_usb_screen_run(void)
 238 {
 239     int i;
 240     int old_bars  = viewportmanager_get_statusbar();
 241     struct usb_screen_vps_t usb_screen_vps_ar[NB_SCREENS];
 242 #if defined HAVE_TOUCHSCREEN
 243     enum touchscreen_mode old_mode = touchscreen_get_mode();
 244
 245     /* TODO: Paint buttons on screens OR switch to point mode and use
 246      * touchscreen as a touchpad to move the host's mouse cursor */
 247     touchscreen_set_mode(TOUCHSCREEN_BUTTON);
 248 #endif
 249
 250 #ifndef SIMULATOR
 251     usb_acknowledge(SYS_USB_CONNECTED_ACK);
 252 #endif
 253
 254 #ifdef USB_ENABLE_HID
 255     usb_keypad_mode = global_settings.usb_keypad_mode;
 256 #endif
 257
 258     FOR_NB_SCREENS(i)
 259     {
 260         struct screen *screen = &screens[i];
 261
 262         screen->set_viewport(NULL);
 263 #ifdef HAVE_LCD_BITMAP
 264         usb_screen_fix_viewports(screen, &usb_screen_vps_ar[i]);
 265 #endif
 266     }
 267
 268     while (1)
 269     {
 270         usb_screens_draw(usb_screen_vps_ar);
 271 #ifdef SIMULATOR
 272         if (button_get_w_tmo(HZ/2))
 273             break;
 274         send_event(GUI_EVENT_ACTIONUPDATE, NULL);
 275 #else
 276         if (handle_usb_events())
 277             break;
 278 #endif /* SIMULATOR */
 279     }
 280
 281     FOR_NB_SCREENS(i)
 282     {
 283         const struct viewport* vp = NULL;
 284
 285 #if defined(HAVE_LCD_BITMAP) && defined(USB_ENABLE_HID)
 286         vp = &usb_screen_vps_ar[i].title;
 287 #elif !defined(HAVE_LCD_BITMAP)
 288         vp = &usb_screen_vps_ar[i].parent;
 289 #endif
 290         if (vp)
 291             screens[i].scroll_stop(vp);
 292     }
 293 #ifdef USB_ENABLE_HID
 294     if (global_settings.usb_keypad_mode != usb_keypad_mode)
 295     {
 296         global_settings.usb_keypad_mode = usb_keypad_mode;
 297         settings_save();
 298     }
 299 #endif
 300
 301 #ifdef HAVE_TOUCHSCREEN
 302     touchscreen_set_mode(old_mode);
 303 #endif
 304
 305 #ifdef HAVE_LCD_CHARCELLS
 306     status_set_usb(false);
 307 #endif /* HAVE_LCD_CHARCELLS */
 308     FOR_NB_SCREENS(i)
 309     {
 310         screens[i].backlight_on();
 311     }
 312     viewportmanager_set_statusbar(old_bars);
 313     send_event(GUI_EVENT_REFRESH, NULL);
 314
 315 }
 316 #endif /* !defined(USB_NONE) */
 317