src/runtime.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * runtime.h: Core surface.
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #ifndef __RUNTIME_H__
  15 #define __RUNTIME_H__
  16
  17 #include <gtk/gtkwidget.h>
  18 #include <cairo.h>
  19
  20 #include "point.h"
  21 #include "uielement.h"
  22 #include "dependencyobject.h"
  23 #include "dirty.h"
  24 #include "value.h"
  25 #include "type.h"
  26 #include "list.h"
  27 #include "error.h"
  28 #include "window.h"
  29 #include "mutex.h"
  30
  31 #define MAXIMUM_CACHE_SIZE 6000000
  32
  33 #define FRONT_TO_BACK_STATS 0
  34
  35 #define TIMERS 0
  36 #define DEBUG_MARKER_KEY 0
  37 #if TIMERS
  38 #define STARTTIMER(id,str) TimeSpan id##_t_start = get_now(); printf ("timing of '%s' started at %" G_GINT64_FORMAT "\n", str, id##_t_start)
  39 #define ENDTIMER(id,str) TimeSpan id##_t_end = get_now(); printf ("timing of '%s' ended at %" G_GINT64_FORMAT " (%f seconds)\n", str, id##_t_end, (double)(id##_t_end - id##_t_start) / 10000000)
  40 #else
  41 #define STARTTIMER(id,str)
  42 #define ENDTIMER(id,str)
  43 #endif
  44
  45 #if SANITY
  46 #define VERIFY_MAIN_THREAD \
  47         if (!Surface::InMainThread ()) {        \
  48                 printf ("Moonlight: This method should only be called from the main thread (%s)\n", __PRETTY_FUNCTION__);       \
  49                 print_stack_trace (); \
  50         }
  51 #else
  52 #define VERIFY_MAIN_THREAD
  53 #endif
  54
  55 enum RuntimeInitFlags {
  56         RUNTIME_INIT_PANGO_TEXT_LAYOUT     = 1 << 0,
  57         // (not used)                      = 1 << 1,
  58         RUNTIME_INIT_MANUAL_TIMESOURCE     = 1 << 2,
  59         RUNTIME_INIT_DISABLE_AUDIO         = 1 << 3,
  60         RUNTIME_INIT_SHOW_EXPOSE           = 1 << 4,
  61         RUNTIME_INIT_SHOW_CLIPPING         = 1 << 5,
  62         RUNTIME_INIT_SHOW_BOUNDING_BOXES   = 1 << 6,
  63         RUNTIME_INIT_SHOW_TEXTBOXES        = 1 << 7,
  64         RUNTIME_INIT_SHOW_FPS              = 1 << 8,
  65         RUNTIME_INIT_RENDER_FRONT_TO_BACK  = 1 << 9,
  66         RUNTIME_INIT_SHOW_CACHE_SIZE       = 1 << 10,
  67         RUNTIME_INIT_FFMPEG_YUV_CONVERTER  = 1 << 11,
  68         RUNTIME_INIT_USE_SHAPE_CACHE       = 1 << 12,
  69         RUNTIME_INIT_USE_UPDATE_POSITION   = 1 << 13,
  70         RUNTIME_INIT_ALLOW_WINDOWLESS      = 1 << 14,
  71         RUNTIME_INIT_AUDIO_ALSA_MMAP       = 1 << 15,
  72         RUNTIME_INIT_AUDIO_ALSA_RW         = 1 << 16,
  73         RUNTIME_INIT_AUDIO_ALSA            = 1 << 17,
  74         RUNTIME_INIT_AUDIO_PULSE           = 1 << 18,
  75         RUNTIME_INIT_USE_IDLE_HINT         = 1 << 19,
  76         RUNTIME_INIT_USE_BACKEND_XLIB      = 1 << 20,
  77         RUNTIME_INIT_KEEP_MEDIA            = 1 << 21,
  78         RUNTIME_INIT_ENABLE_MS_CODECS      = 1 << 22,
  79         RUNTIME_INIT_DISABLE_FFMPEG_CODECS = 1 << 23,
  80         RUNTIME_INIT_ALL_IMAGE_FORMATS     = 1 << 24,
  81         RUNTIME_INIT_CREATE_ROOT_DOMAIN    = 1 << 25,
  82         RUNTIME_INIT_DESKTOP_EXTENSIONS    = 1 << 26,
  83         RUNTIME_INIT_OUT_OF_BROWSER        = 1 << 27,
  84 };
  85
  86 extern guint32 moonlight_flags;
  87
  88
  89 #if LOGGING || DEBUG
  90 enum RuntimeDebugFlags {
  91         RUNTIME_DEBUG_ALSA              = 1 << 0,
  92         RUNTIME_DEBUG_AUDIO             = 1 << 1,
  93         RUNTIME_DEBUG_PULSE             = 1 << 2,
  94         RUNTIME_DEBUG_HTTPSTREAMING     = 1 << 3,
  95         RUNTIME_DEBUG_MARKERS           = 1 << 4,
  96         RUNTIME_DEBUG_MMS               = 1 << 5,
  97         RUNTIME_DEBUG_MEDIAPLAYER       = 1 << 6,
  98         RUNTIME_DEBUG_PIPELINE          = 1 << 7,
  99         RUNTIME_DEBUG_PIPELINE_ERROR    = 1 << 8,
 100         RUNTIME_DEBUG_FRAMEREADERLOOP   = 1 << 9,
 101         RUNTIME_DEBUG_FFMPEG            = 1 << 10,
 102         RUNTIME_DEBUG_UI                = 1 << 11,
 103         RUNTIME_DEBUG_CODECS            = 1 << 12,
 104         RUNTIME_DEBUG_DP                = 1 << 13,
 105         RUNTIME_DEBUG_DOWNLOADER        = 1 << 14,
 106         RUNTIME_DEBUG_FONT              = 1 << 15,
 107         RUNTIME_DEBUG_LAYOUT            = 1 << 16,
 108         RUNTIME_DEBUG_MEDIA             = 1 << 17,
 109         RUNTIME_DEBUG_MEDIAELEMENT      = 1 << 18,
 110         RUNTIME_DEBUG_BUFFERING         = 1 << 19,
 111         RUNTIME_DEBUG_ASF               = 1 << 20,
 112         RUNTIME_DEBUG_PLAYLIST          = 1 << 21,
 113         RUNTIME_DEBUG_TEXT              = 1 << 22,
 114         RUNTIME_DEBUG_XAML              = 1 << 23,
 115         RUNTIME_DEBUG_DEPLOYMENT        = 1 << 24,
 116         RUNTIME_DEBUG_MSI               = 1 << 25,
 117         RUNTIME_DEBUG_MP3               = 1 << 26,
 118         RUNTIME_DEBUG_VALUE             = 1 << 27,
 119 };
 120
 121 enum RuntimeDebugFlagsExtra {
 122         RUNTIME_DEBUG_ALSA_EX           = 1 << 0,
 123         RUNTIME_DEBUG_AUDIO_EX          = 1 << 1,
 124         RUNTIME_DEBUG_PULSE_EX          = 1 << 2,
 125         RUNTIME_DEBUG_MARKERS_EX        = 1 << 3,
 126         RUNTIME_DEBUG_MEDIAPLAYER_EX    = 1 << 4,
 127         RUNTIME_DEBUG_MEDIAELEMENT_EX   = 1 << 5,
 128         RUNTIME_DEBUG_PLAYLIST_EX       = 1 << 6,
 129         RUNTIME_DEBUG_PIPELINE_EX       = 1 << 7,
 130 };
 131
 132 extern guint32 debug_flags_ex;
 133 extern guint32 debug_flags;
 134 #endif
 135
 136
 137 class TimeManager;
 138 class Surface;
 139 class Downloader;
 140
 141 typedef void (* MoonlightFPSReportFunc) (Surface *surface, int nframes, float nsecs, void *user_data);
 142 typedef void (* MoonlightCacheReportFunc) (Surface *surface, long size, void *user_data);
 143 typedef bool (* MoonlightEventEmitFunc) (UIElement *element, GdkEvent *event);
 144 typedef void (* MoonlightExposeHandoffFunc) (Surface *surface, TimeSpan time, void *user_data);
 145
 146 /* @Namespace=None,ManagedEvents=Manual */
 147 class Surface : public EventObject {
 148 public:
 149         /* @GenerateCBinding,GeneratePInvoke */
 150         Surface (MoonWindow *window);
 151         virtual void Dispose ();
 152
 153         /* @GenerateCBinding */
 154         MoonWindow *GetWindow () { return active_window; }
 155         MoonWindow *DetachWindow ();
 156
 157         // allows you to redirect painting of the surface to an
 158         // arbitrary cairo context.
 159         void Paint (cairo_t *ctx, Region *region);
 160         /* @GenerateCBinding,GeneratePInvoke */
 161         void Paint (cairo_t *ctx, int x, int y, int width, int height);
 162
 163         /* @GenerateCBinding,GeneratePInvoke */
 164         void Attach (UIElement *toplevel);
 165
 166         void AttachLayer (UIElement *layer);
 167
 168         void DetachLayer (UIElement *layer);
 169
 170         void SetCursor (MouseCursor cursor);
 171
 172         void ReleaseMouseCapture (UIElement *capture);
 173         bool SetMouseCapture (UIElement *capture);
 174
 175         /* @GenerateCBinding,GeneratePInvoke */
 176         void Resize (int width, int height);
 177
 178         void EmitSourceDownloadComplete ();
 179         void EmitSourceDownloadProgressChanged (DownloadProgressEventArgs *args);
 180         void EmitError (ErrorEventArgs *args);
 181         /* @GenerateCBinding,GeneratePInvoke */
 182         void EmitError (int number, int code, const char *message);
 183
 184         void EmitLoad ();
 185
 186         void SetBackgroundColor (Color *color);
 187         /* @GenerateCBinding,GeneratePInvoke */
 188         Color *GetBackgroundColor ();
 189
 190         int GetFrameCount () { return frames; }
 191         void ResetFrameCount () { frames = 0; }
 192
 193         virtual void Invalidate (Rect r);
 194         virtual void ProcessUpdates ();
 195
 196         /* @GenerateCBinding,GeneratePInvoke */
 197         UIElement *GetToplevel() { return toplevel; }
 198         bool IsTopLevel (UIElement *top);
 199
 200         /* @GenerateCBinding,GeneratePInvoke,Version=2.0 */
 201         UIElement *GetFocusedElement () { return focused_element; }
 202
 203         bool FocusElement (UIElement *element);
 204
 205         /* @GenerateCBinding,GeneratePInvoke */
 206         bool IsLoaded () { return toplevel != NULL && ticked_after_attach; }
 207
 208         /* @GenerateCBinding,GeneratePInvoke */
 209         static bool IsVersionSupported (const char *version);
 210
 211         const static int ResizeEvent;
 212         const static int FullScreenChangeEvent;
 213         const static int ErrorEvent;
 214         const static int LoadEvent;
 215         const static int SourceDownloadProgressChangedEvent;
 216         const static int SourceDownloadCompleteEvent;
 217
 218         /* @GenerateCBinding,GeneratePInvoke,Version=2.0 */
 219         bool GetFullScreen () { return full_screen; }
 220         /* @GenerateCBinding,GeneratePInvoke,Version=2.0 */
 221         void SetFullScreen (bool value);
 222
 223         void SetUserInitiatedEvent (bool value);
 224
 225         bool FirstUserInitiatedEvent () { return first_user_initiated_event; }
 226         /* @GenerateCBinding,GeneratePInvoke,Version=2.0 */
 227         bool IsUserInitiatedEvent () { return user_initiated_event; }
 228
 229         const char* GetSourceLocation ();
 230         void SetSourceLocation (const char *location);
 231         bool FullScreenKeyHandled (GdkEventKey *key);
 232
 233         /* @GenerateCBinding,GeneratePInvoke */
 234         TimeManager *GetTimeManager () { return time_manager; }
 235         TimeManager *GetTimeManagerReffed ();
 236
 237         void SetDownloaderContext (gpointer context) { downloader_context = context; }
 238         gpointer GetDownloaderContext () { return downloader_context; }
 239
 240         /* @GenerateCBinding,GeneratePInvoke */
 241         Downloader *CreateDownloader ();
 242         static Downloader *CreateDownloader (EventObject *obj);
 243
 244         void SetFPSReportFunc (MoonlightFPSReportFunc report, void *user_data);
 245         void SetCacheReportFunc (MoonlightCacheReportFunc report, void *user_data);
 246         void SetExposeHandoffFunc (MoonlightExposeHandoffFunc func, void *user_data);
 247
 248         bool VerifyWithCacheSizeCounter (int w, int h);
 249         gint64 AddToCacheSizeCounter (int w, int h);
 250         void RemoveFromCacheSizeCounter (gint64 size);
 251
 252         // called from the plugin if the surface is headed for death.
 253         // stops event emission (since the plugin counterparts to xaml
 254         // objects will be destroyed)
 255         void Zombify ();
 256
 257         bool IsZombie () { return zombie; }
 258
 259         void DetachDownloaders ();
 260
 261 #if FRONT_TO_BACK_STATS
 262         int uielements_rendered_front_to_back;
 263         int uielements_rendered_back_to_front;
 264 #endif
 265
 266 #ifdef DEBUG
 267         UIElement *debug_selected_element;
 268 #endif
 269
 270         void PaintToDrawable (GdkDrawable *drawable, GdkVisual *visual, GdkEventExpose *event, int off_x, int off_y, bool transparent, bool clear_transparent);
 271
 272
 273         gboolean HandleUIMotion (GdkEventMotion *event);
 274         gboolean HandleUICrossing (GdkEventCrossing *event);
 275         gboolean HandleUIKeyPress (GdkEventKey *event);
 276         gboolean HandleUIKeyRelease (GdkEventKey *event);
 277         gboolean HandleUIButtonRelease (GdkEventButton *event);
 278         gboolean HandleUIButtonPress (GdkEventButton *event);
 279         gboolean HandleUIScroll (GdkEventScroll *event);
 280         gboolean HandleUIFocusIn (GdkEventFocus *event);
 281         gboolean HandleUIFocusOut (GdkEventFocus *event);
 282         void HandleUIWindowAllocation (bool emit_resize);
 283         void HandleUIWindowAvailable ();
 284         void HandleUIWindowUnavailable ();
 285         void HandleUIWindowDestroyed (MoonWindow *window);
 286
 287         // bad, but these live in dirty.cpp, not runtime.cpp
 288         void AddDirtyElement (UIElement *element, DirtyType dirt);
 289         void UpdateLayout ();
 290         void RemoveDirtyElement (UIElement *element);
 291         bool ProcessDirtyElements ();
 292         void PropagateDirtyFlagToChildren (UIElement *element, DirtyType dirt);
 293
 294         static bool main_thread_inited;
 295         static pthread_t main_thread;
 296         /* @GenerateCBinding,GeneratePInvoke */
 297         static bool InMainThread () { return (!main_thread_inited || pthread_equal (main_thread, pthread_self ())); }
 298
 299 protected:
 300         // The current window we are drawing to
 301         MoonWindow *active_window;
 302
 303         virtual ~Surface();
 304
 305 private:
 306         // are we headed for death?
 307         bool zombie;
 308
 309         // bad, but these two live in dirty.cpp, not runtime.cpp
 310         void ProcessDownDirtyElements ();
 311         void ProcessUpDirtyElements ();
 312
 313         DirtyLists *down_dirty;
 314         DirtyLists *up_dirty;
 315
 316         gpointer downloader_context;
 317         List *downloaders;
 318         static void OnDownloaderDestroyed (EventObject *sender, EventArgs *args, gpointer closure);
 319
 320         Color *background_color;
 321
 322         // This is the normal-sized window
 323         MoonWindow *normal_window;
 324
 325         // We set active_window to this whenever we are in fullscreen mode.
 326         MoonWindow *fullscreen_window;
 327
 328         // We can have multiple top level elements, these are stored as layers
 329         HitTestCollection *layers;
 330
 331         UIElement *toplevel;
 332
 333         // The element holding the keyboard focus, and the one that
 334         // held it previously (so we can emit lostfocus events async)
 335         UIElement *focused_element;
 336         List *focus_changed_events;
 337
 338         // the list of elements (from most deeply nested to the
 339         // toplevel) we've most recently sent a mouse event to.
 340         List *input_list;
 341
 342         // is the mouse captured?  if it is, it'll be by the first element in input_list.
 343         UIElement *captured;
 344         UIElement *pendingCapture;
 345         bool pendingReleaseCapture;
 346
 347         // are we currently emitting a mouse event?
 348         bool emittingMouseEvent;
 349
 350         // the currently shown cursor
 351         MouseCursor cursor;
 352
 353         // Fullscreen support
 354         bool full_screen;
 355         Panel *full_screen_message;
 356         char *source_location;
 357
 358         Panel *incomplete_support_message;
 359
 360         // True once we have received at least one user initiated event
 361         bool first_user_initiated_event;
 362         // Should be set to true only while executing MouseLeftButtonDown,
 363         // MouseLeftButtonUp, KeyDown, and KeyUp event handlers
 364         bool user_initiated_event;
 365
 366         void UpdateFullScreen (bool value);
 367
 368         TimeManager *time_manager;
 369         Mutex time_manager_mutex;
 370         bool ticked_after_attach;
 371         static void tick_after_attach_reached (EventObject *data);
 372
 373         int frames;
 374
 375         GdkEvent *mouse_event;
 376
 377         // Variables for reporting FPS
 378         MoonlightFPSReportFunc fps_report;
 379         gint64 fps_start;
 380         int fps_nframes;
 381         void *fps_data;
 382
 383         // Variables for reporting cache size
 384         MoonlightCacheReportFunc cache_report;
 385         gint64 cache_size_in_bytes;
 386         int cache_size_ticker;
 387         void *cache_data;
 388         int cache_size_multiplier;
 389
 390         // Expose handoff
 391         TimeSpan expose_handoff_last_timespan;
 392         MoonlightExposeHandoffFunc expose_handoff;
 393         void *expose_handoff_data;
 394
 395         void Realloc ();
 396
 397         void ShowFullScreenMessage ();
 398         void HideFullScreenMessage ();
 399         static void HideFullScreenMessageCallback (EventObject *sender, EventArgs *args, gpointer closure);
 400
 401         void ShowIncompleteSilverlightSupportMessage ();
 402         void HideIncompleteSilverlightSupportMessage ();
 403         static void HideIncompleteSilverlightSupportMessageCallback (EventObject *sender, EventArgs *args, gpointer closure);
 404
 405         void CreateSimilarSurface ();
 406
 407         static void render_cb (EventObject *sender, EventArgs *calldata, gpointer closure);
 408         static void update_input_cb (EventObject *sender, EventArgs *calldata, gpointer closure);
 409         static void widget_destroyed (GtkWidget *w, gpointer data);
 410
 411         EventArgs* CreateArgsForEvent (int event_id, GdkEvent *event);
 412
 413         List* ElementPathToRoot (UIElement *source);
 414         void EmitFocusChangeEvents();
 415         static void EmitFocusChangeEventsAsync (EventObject *sender);
 416
 417         void FindFirstCommonElement (List *l1, int *index1, List *l2, int *index2);
 418         bool EmitEventOnList (int event_id, List *element_list, GdkEvent *event, int end_idx);
 419         void UpdateCursorFromInputList ();
 420         bool HandleMouseEvent (int event_id, bool emit_leave, bool emit_enter, bool force_emit, GdkEvent *event);
 421         void PerformCapture (UIElement *capture);
 422         void PerformReleaseCapture ();
 423
 424         static void toplevel_loaded (EventObject *sender, EventArgs *args, gpointer closure);
 425         void ToplevelLoaded (UIElement *element);
 426 };
 427
 428 /* for hit testing */
 429 class UIElementNode : public List::Node {
 430 public:
 431         UIElement *uielement;
 432
 433         UIElementNode (UIElement *el);
 434         virtual ~UIElementNode ();
 435 };
 436
 437 /* for rendering */
 438 typedef void (*RenderFunc) (cairo_t *ctx, UIElement *uielement, Region *region, bool front_to_back);
 439
 440 class RenderNode : public List::Node {
 441 public:
 442         RenderNode (UIElement *el, Region *region, bool render_element, RenderFunc pre, RenderFunc post);
 443
 444         void Render (cairo_t *cr);
 445
 446         virtual ~RenderNode ();
 447
 448 private:
 449         UIElement *uielement;
 450         Region *region;
 451         bool render_element;
 452         RenderFunc pre_render;
 453         RenderFunc post_render;
 454
 455 };
 456
 457 G_BEGIN_DECLS
 458
 459 void     runtime_init (const char *platform_dir, guint32 flags);
 460
 461 void     runtime_init_browser (const char *plugin_dir);
 462 /* @GeneratePInvoke */
 463 void     runtime_init_desktop ();
 464 /* @GeneratePInvoke */
 465 bool     runtime_is_running_out_of_browser ();
 466
 467 GList   *runtime_get_surface_list (void);
 468
 469 void     runtime_flags_set_manual_timesource (gboolean flag);
 470 void     runtime_flags_set_show_fps (gboolean flag);
 471 void     runtime_flags_set_use_shapecache (gboolean flag);
 472
 473 void     runtime_shutdown (void);
 474
 475 G_END_DECLS
 476
 477 #endif