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