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