~vanvugt/compiz-core/tapping-panacea

« back to all changes in this revision

Viewing changes to include/core/screen.h

  • Committer: Daniel van Vugt
  • Author(s): Alan Griffiths
  • Date: 2012-03-05 03:33:53 UTC
  • mfrom: (3025.3.12 arg-tmp)
  • Revision ID: vanvugt@gmail.com-20120305033353-efxc624wqqssp205
Pulling out some more functional elements of PrivateScreen.

Show diffs side-by-side

added added

removed removed

Lines of Context:
353
353
    virtual void _outputChangeNotify() = 0;
354
354
};
355
355
 
356
 
/**
357
 
 * A wrapping of the X display screen. This takes care of communication to the
358
 
 * X server.
359
 
 */
360
 
class CompScreenImpl : public CompScreen
361
 
{
362
 
    public:
363
 
        CompScreenImpl ();
364
 
        ~CompScreenImpl ();
365
 
 
366
 
        bool init (const char *name);
367
 
 
368
 
        void eventLoop ();
369
 
 
370
 
        CompFileWatchHandle addFileWatch (const char        *path,
371
 
                                          int               mask,
372
 
                                          FileWatchCallBack callBack);
373
 
 
374
 
        void removeFileWatch (CompFileWatchHandle handle);
375
 
 
376
 
        const CompFileWatchList& getFileWatches () const;
377
 
 
378
 
        CompWatchFdHandle addWatchFd (int             fd,
379
 
                                      short int       events,
380
 
                                      FdWatchCallBack callBack);
381
 
 
382
 
        void removeWatchFd (CompWatchFdHandle handle);
383
 
 
384
 
        void storeValue (CompString key, CompPrivate value);
385
 
        bool hasValue (CompString key);
386
 
        CompPrivate getValue (CompString key);
387
 
        void eraseValue (CompString key);
388
 
 
389
 
        Display * dpy ();
390
 
 
391
 
        CompOption::Vector & getOptions ();
392
 
 
393
 
        bool setOption (const CompString &name, CompOption::Value &value);
394
 
 
395
 
        bool XRandr ();
396
 
 
397
 
        int randrEvent ();
398
 
 
399
 
        bool XShape ();
400
 
 
401
 
        int shapeEvent ();
402
 
 
403
 
        int syncEvent ();
404
 
 
405
 
        SnDisplay * snDisplay ();
406
 
 
407
 
        Window activeWindow ();
408
 
 
409
 
        Window autoRaiseWindow ();
410
 
 
411
 
        const char * displayString ();
412
 
 
413
 
 
414
 
        CompWindow * findWindow (Window id);
415
 
 
416
 
        CompWindow * findTopLevelWindow (Window id,
417
 
                                         bool   override_redirect = false);
418
 
 
419
 
        bool readImageFromFile (CompString &name,
420
 
                                CompString &pname,
421
 
                                CompSize   &size,
422
 
                                void       *&data);
423
 
 
424
 
        bool writeImageToFile (CompString &path,
425
 
                               const char *format,
426
 
                               CompSize   &size,
427
 
                               void       *data);
428
 
 
429
 
        unsigned int getWindowProp (Window       id,
430
 
                                    Atom         property,
431
 
                                    unsigned int defaultValue);
432
 
 
433
 
 
434
 
        void setWindowProp (Window       id,
435
 
                            Atom         property,
436
 
                            unsigned int value);
437
 
 
438
 
 
439
 
        unsigned short getWindowProp32 (Window         id,
440
 
                                        Atom           property,
441
 
                                        unsigned short defaultValue);
442
 
 
443
 
 
444
 
        void setWindowProp32 (Window         id,
445
 
                              Atom           property,
446
 
                              unsigned short value);
447
 
 
448
 
        Window root ();
449
 
 
450
 
        int xkbEvent ();
451
 
 
452
 
        XWindowAttributes attrib ();
453
 
 
454
 
        int screenNum ();
455
 
 
456
 
        CompWindowList & windows ();
457
 
        CompWindowList & serverWindows ();
458
 
        CompWindowList & destroyedWindows ();
459
 
 
460
 
        void warpPointer (int dx, int dy);
461
 
 
462
 
        Time getCurrentTime ();
463
 
 
464
 
        Window selectionWindow ();
465
 
 
466
 
        void forEachWindow (CompWindow::ForEach);
467
 
 
468
 
        void focusDefaultWindow ();
469
 
 
470
 
        void insertWindow (CompWindow *w, Window aboveId);
471
 
        void unhookWindow (CompWindow *w);
472
 
 
473
 
        void insertServerWindow (CompWindow *w, Window aboveId);
474
 
        void unhookServerWindow (CompWindow *w);
475
 
 
476
 
        Cursor normalCursor ();
477
 
 
478
 
        Cursor invisibleCursor ();
479
 
 
480
 
        /* Adds an X Pointer and Keyboard grab to the stack. Since
481
 
         * compiz as a client only need to grab once, multiple clients
482
 
         * can call this and all get events, but the pointer will
483
 
         * be grabbed once and the actual grab refcounted */
484
 
        GrabHandle pushGrab (Cursor cursor, const char *name);
485
 
 
486
 
        /* Allows you to change the pointer of your grab */
487
 
        void updateGrab (GrabHandle handle, Cursor cursor);
488
 
 
489
 
        /* Removes your grab from the stack. Once the internal refcount
490
 
         * reaches zero, the X Pointer and Keyboard are both ungrabbed
491
 
         */
492
 
        void removeGrab (GrabHandle handle, CompPoint *restorePointer);
493
 
 
494
 
        /* Returns true if a grab other than the grabs specified here
495
 
         * exists */
496
 
        bool otherGrabExist (const char *, ...);
497
 
 
498
 
        /* Returns true if the specified grab exists */
499
 
        bool grabExist (const char *);
500
 
 
501
 
        /* Returns true if the X Pointer and / or Keyboard is grabbed
502
 
         * by anything (another application, pluigins etc) */
503
 
        bool grabbed ();
504
 
 
505
 
        const CompWindowVector & clientList (bool stackingOrder = true);
506
 
 
507
 
        bool addAction (CompAction *action);
508
 
 
509
 
        void removeAction (CompAction *action);
510
 
 
511
 
        void updateWorkarea ();
512
 
 
513
 
        void toolkitAction (Atom   toolkitAction,
514
 
                            Time   eventTime,
515
 
                            Window window,
516
 
                            long   data0,
517
 
                            long   data1,
518
 
                            long   data2);
519
 
 
520
 
        void runCommand (CompString command);
521
 
 
522
 
        void moveViewport (int tx, int ty, bool sync);
523
 
 
524
 
        void sendWindowActivationRequest (Window id);
525
 
 
526
 
        int outputDeviceForPoint (int x, int y);
527
 
        int outputDeviceForPoint (const CompPoint &point);
528
 
 
529
 
        CompRect getCurrentOutputExtents ();
530
 
 
531
 
        const CompRect & getWorkareaForOutput (unsigned int outputNum) const;
532
 
 
533
 
        void viewportForGeometry (const CompWindow::Geometry &gm,
534
 
                                  CompPoint                   &viewport);
535
 
 
536
 
        int outputDeviceForGeometry (const CompWindow::Geometry& gm);
537
 
 
538
 
        const CompPoint & vp () const;
539
 
 
540
 
        const CompSize  & vpSize () const;
541
 
 
542
 
        int desktopWindowCount ();
543
 
        unsigned int activeNum () const;
544
 
 
545
 
        CompOutput::vector & outputDevs ();
546
 
        CompOutput & currentOutputDev () const;
547
 
 
548
 
        const CompRect & workArea () const;
549
 
 
550
 
        unsigned int currentDesktop ();
551
 
 
552
 
        unsigned int nDesktop ();
553
 
 
554
 
        CompActiveWindowHistory *currentHistory ();
555
 
 
556
 
        bool shouldSerializePlugins () ;
557
 
 
558
 
        const CompRegion & region () const;
559
 
 
560
 
        bool hasOverlappingOutputs ();
561
 
 
562
 
        CompOutput & fullscreenOutput ();
563
 
 
564
 
        std::vector<XineramaScreenInfo> & screenInfo ();
565
 
 
566
 
        CompIcon *defaultIcon () const;
567
 
 
568
 
        bool updateDefaultIcon ();
569
 
 
570
 
        void updateSupportedWmHints ();
571
 
 
572
 
        unsigned int showingDesktopMask() const;
573
 
        virtual bool grabsEmpty() const;
574
 
        virtual void sizePluginClasses(unsigned int size);
575
 
        virtual void setWindowState (unsigned int state, Window id);
576
 
        virtual void removeFromCreatedWindows(CoreWindow *cw);
577
 
        virtual void addToDestroyedWindows(CompWindow * cw);
578
 
        virtual void processEvents ();
579
 
        virtual void alwaysHandleEvent (XEvent *event);
580
 
 
581
 
    public :
582
 
 
583
 
        static bool showDesktop (CompAction         *action,
584
 
                                 CompAction::State  state,
585
 
                                 CompOption::Vector &options);
586
 
 
587
 
        static bool windowMenu (CompAction         *action,
588
 
                                CompAction::State  state,
589
 
                                CompOption::Vector &options);
590
 
 
591
 
        static bool closeWin (CompAction         *action,
592
 
                              CompAction::State  state,
593
 
                              CompOption::Vector &options);
594
 
 
595
 
        static bool unmaximizeWin (CompAction         *action,
596
 
                                   CompAction::State  state,
597
 
                                   CompOption::Vector &options);
598
 
 
599
 
        static bool minimizeWin (CompAction         *action,
600
 
                                 CompAction::State  state,
601
 
                                 CompOption::Vector &options);
602
 
 
603
 
        static bool maximizeWin (CompAction         *action,
604
 
                                 CompAction::State  state,
605
 
                                 CompOption::Vector &options);
606
 
 
607
 
        static bool maximizeWinHorizontally (CompAction         *action,
608
 
                                             CompAction::State  state,
609
 
                                             CompOption::Vector &options);
610
 
 
611
 
        static bool maximizeWinVertically (CompAction         *action,
612
 
                                           CompAction::State  state,
613
 
                                           CompOption::Vector &options);
614
 
 
615
 
        static bool raiseWin (CompAction         *action,
616
 
                              CompAction::State  state,
617
 
                              CompOption::Vector &options);
618
 
 
619
 
        static bool lowerWin (CompAction         *action,
620
 
                              CompAction::State  state,
621
 
                              CompOption::Vector &options);
622
 
 
623
 
        static bool toggleWinMaximized (CompAction         *action,
624
 
                                        CompAction::State  state,
625
 
                                        CompOption::Vector &options);
626
 
 
627
 
        static bool toggleWinMaximizedHorizontally (CompAction         *action,
628
 
                                                    CompAction::State  state,
629
 
                                                    CompOption::Vector &options);
630
 
 
631
 
        static bool toggleWinMaximizedVertically (CompAction         *action,
632
 
                                                  CompAction::State  state,
633
 
                                                  CompOption::Vector &options);
634
 
 
635
 
        static bool shadeWin (CompAction         *action,
636
 
                              CompAction::State  state,
637
 
                              CompOption::Vector &options);
638
 
 
639
 
    private:
640
 
        virtual bool _setOptionForPlugin(const char *, const char *, CompOption::Value &);
641
 
        virtual bool _initPluginForScreen(CompPlugin *);
642
 
        virtual void _finiPluginForScreen(CompPlugin *);
643
 
        virtual void _handleEvent(XEvent *event);
644
 
        virtual void _logMessage(const char *, CompLogLevel, const char*);
645
 
        virtual void _enterShowDesktopMode();
646
 
        virtual void _leaveShowDesktopMode(CompWindow *);
647
 
        virtual void _addSupportedAtoms(std::vector<Atom>& atoms);
648
 
 
649
 
        // These are stubs - but allow mocking of AbstractCompWindow
650
 
        virtual void _fileWatchAdded(CompFileWatch *);
651
 
        virtual void _fileWatchRemoved(CompFileWatch *);
652
 
        virtual void _sessionEvent(CompSession::Event, CompOption::Vector &);
653
 
        virtual void _handleCompizEvent(const char *, const char *, CompOption::Vector &);
654
 
        virtual bool _fileToImage(CompString &, CompSize &, int &, void *&);
655
 
        virtual bool _imageToFile(CompString &, CompString &, CompSize &, int, void *);
656
 
        virtual CompMatch::Expression * _matchInitExp(const CompString&);
657
 
        virtual void _matchExpHandlerChanged();
658
 
        virtual void _matchPropertyChanged(CompWindow *);
659
 
        virtual void _outputChangeNotify();
660
 
 
661
 
};
662
 
 
663
356
#endif