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