src/Tizen.NUI/src/internal/AccessibilityManagerEventArgs.cs

   1 /*
   2  * Copyright(c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 using System;
  19 using Tizen.NUI.BaseComponents;
  20
  21 namespace Tizen.NUI
  22 {
  23     internal partial class AccessibilityManager
  24     {
  25         /**
  26          * @brief Event arguments that passed via StatusChanged signal
  27          *
  28          */
  29         /// <since_tizen> 3 </since_tizen>
  30         public class StatusChangedEventArgs : EventArgs
  31         {
  32             private AccessibilityManager _accessibilityManager;
  33
  34             /// <since_tizen> 3 </since_tizen>
  35             public AccessibilityManager AccessibilityManager
  36             {
  37                 get
  38                 {
  39                     return _accessibilityManager;
  40                 }
  41                 set
  42                 {
  43                     _accessibilityManager = value;
  44                 }
  45             }
  46         }
  47
  48         /**
  49           * @brief Event arguments that passed via ActionNext signal
  50           *
  51           */
  52         /// <since_tizen> 3 </since_tizen>
  53         public class ActionNextEventArgs : EventArgs
  54         {
  55             private AccessibilityManager _accessibilityManager;
  56
  57             /// <since_tizen> 3 </since_tizen>
  58             public AccessibilityManager AccessibilityManager
  59             {
  60                 get
  61                 {
  62                     return _accessibilityManager;
  63                 }
  64                 set
  65                 {
  66                     _accessibilityManager = value;
  67                 }
  68             }
  69         }
  70
  71         /**
  72           * @brief Event arguments that passed via ActionPrevious signal
  73           *
  74           */
  75         /// <since_tizen> 3 </since_tizen>
  76         public class ActionPreviousEventArgs : EventArgs
  77         {
  78             private AccessibilityManager _accessibilityManager;
  79
  80             /// <since_tizen> 3 </since_tizen>
  81             public AccessibilityManager AccessibilityManager
  82             {
  83                 get
  84                 {
  85                     return _accessibilityManager;
  86                 }
  87                 set
  88                 {
  89                     _accessibilityManager = value;
  90                 }
  91             }
  92         }
  93
  94         /**
  95           * @brief Event arguments that passed via ActionActivate signal
  96           *
  97           */
  98         /// <since_tizen> 3 </since_tizen>
  99         public class ActionActivateEventArgs : EventArgs
 100         {
 101             private AccessibilityManager _accessibilityManager;
 102
 103             /// <since_tizen> 3 </since_tizen>
 104             public AccessibilityManager AccessibilityManager
 105             {
 106                 get
 107                 {
 108                     return _accessibilityManager;
 109                 }
 110                 set
 111                 {
 112                     _accessibilityManager = value;
 113                 }
 114             }
 115         }
 116
 117         /**
 118           * @brief Event arguments that passed via ActionRead signal
 119           *
 120           */
 121         /// <since_tizen> 3 </since_tizen>
 122         public class ActionReadEventArgs : EventArgs
 123         {
 124             private AccessibilityManager _accessibilityManager;
 125
 126             /// <since_tizen> 3 </since_tizen>
 127             public AccessibilityManager AccessibilityManager
 128             {
 129                 get
 130                 {
 131                     return _accessibilityManager;
 132                 }
 133                 set
 134                 {
 135                     _accessibilityManager = value;
 136                 }
 137             }
 138         }
 139
 140         /**
 141           * @brief Event arguments that passed via ActionOver signal
 142           *
 143           */
 144         /// <since_tizen> 3 </since_tizen>
 145         public class ActionOverEventArgs : EventArgs
 146         {
 147             private AccessibilityManager _accessibilityManager;
 148
 149             /// <since_tizen> 3 </since_tizen>
 150             public AccessibilityManager AccessibilityManager
 151             {
 152                 get
 153                 {
 154                     return _accessibilityManager;
 155                 }
 156                 set
 157                 {
 158                     _accessibilityManager = value;
 159                 }
 160             }
 161         }
 162
 163         /**
 164           * @brief Event arguments that passed via ActionReadNext signal
 165           *
 166           */
 167         /// <since_tizen> 3 </since_tizen>
 168         public class ActionReadNextEventArgs : EventArgs
 169         {
 170             private AccessibilityManager _accessibilityManager;
 171
 172             /// <since_tizen> 3 </since_tizen>
 173             public AccessibilityManager AccessibilityManager
 174             {
 175                 get
 176                 {
 177                     return _accessibilityManager;
 178                 }
 179                 set
 180                 {
 181                     _accessibilityManager = value;
 182                 }
 183             }
 184         }
 185
 186         /**
 187           * @brief Event arguments that passed via ActionReadPrevious signal
 188           *
 189           */
 190         /// <since_tizen> 3 </since_tizen>
 191         public class ActionReadPreviousEventArgs : EventArgs
 192         {
 193             private AccessibilityManager _accessibilityManager;
 194
 195             /// <since_tizen> 3 </since_tizen>
 196             public AccessibilityManager AccessibilityManager
 197             {
 198                 get
 199                 {
 200                     return _accessibilityManager;
 201                 }
 202                 set
 203                 {
 204                     _accessibilityManager = value;
 205                 }
 206             }
 207         }
 208
 209         /**
 210           * @brief Event arguments that passed via ActionUp signal
 211           *
 212           */
 213         /// <since_tizen> 3 </since_tizen>
 214         public class ActionUpEventArgs : EventArgs
 215         {
 216             private AccessibilityManager _accessibilityManager;
 217
 218             /// <since_tizen> 3 </since_tizen>
 219             public AccessibilityManager AccessibilityManager
 220             {
 221                 get
 222                 {
 223                     return _accessibilityManager;
 224                 }
 225                 set
 226                 {
 227                     _accessibilityManager = value;
 228                 }
 229             }
 230         }
 231
 232         /**
 233           * @brief Event arguments that passed via ActionDown signal
 234           *
 235           */
 236         /// <since_tizen> 3 </since_tizen>
 237         public class ActionDownEventArgs : EventArgs
 238         {
 239             private AccessibilityManager _accessibilityManager;
 240
 241             /// <since_tizen> 3 </since_tizen>
 242             public AccessibilityManager AccessibilityManager
 243             {
 244                 get
 245                 {
 246                     return _accessibilityManager;
 247                 }
 248                 set
 249                 {
 250                     _accessibilityManager = value;
 251                 }
 252             }
 253         }
 254
 255         /**
 256           * @brief Event arguments that passed via ActionClearFocus signal
 257           *
 258           */
 259         /// <since_tizen> 3 </since_tizen>
 260         public class ActionClearFocusEventArgs : EventArgs
 261         {
 262             private AccessibilityManager _accessibilityManager;
 263
 264             /// <since_tizen> 3 </since_tizen>
 265             public AccessibilityManager AccessibilityManager
 266             {
 267                 get
 268                 {
 269                     return _accessibilityManager;
 270                 }
 271                 set
 272                 {
 273                     _accessibilityManager = value;
 274                 }
 275             }
 276         }
 277
 278         /**
 279           * @brief Event arguments that passed via ActionBack signal
 280           *
 281           */
 282         /// <since_tizen> 3 </since_tizen>
 283         public class ActionBackEventArgs : EventArgs
 284         {
 285             private AccessibilityManager _accessibilityManager;
 286
 287             /// <since_tizen> 3 </since_tizen>
 288             public AccessibilityManager AccessibilityManager
 289             {
 290                 get
 291                 {
 292                     return _accessibilityManager;
 293                 }
 294                 set
 295                 {
 296                     _accessibilityManager = value;
 297                 }
 298             }
 299         }
 300
 301         /**
 302           * @brief Event arguments that passed via ActionScrollUp signal
 303           *
 304           */
 305         /// <since_tizen> 3 </since_tizen>
 306         public class ActionScrollUpEventArgs : EventArgs
 307         {
 308             private AccessibilityManager _accessibilityManager;
 309
 310             /// <since_tizen> 3 </since_tizen>
 311             public AccessibilityManager AccessibilityManager
 312             {
 313                 get
 314                 {
 315                     return _accessibilityManager;
 316                 }
 317                 set
 318                 {
 319                     _accessibilityManager = value;
 320                 }
 321             }
 322         }
 323
 324         /**
 325           * @brief Event arguments that passed via ActionScrollDown signal
 326           *
 327           */
 328         /// <since_tizen> 3 </since_tizen>
 329         public class ActionScrollDownEventArgs : EventArgs
 330         {
 331             private AccessibilityManager _accessibilityManager;
 332
 333             /// <since_tizen> 3 </since_tizen>
 334             public AccessibilityManager AccessibilityManager
 335             {
 336                 get
 337                 {
 338                     return _accessibilityManager;
 339                 }
 340                 set
 341                 {
 342                     _accessibilityManager = value;
 343                 }
 344             }
 345         }
 346
 347         /**
 348           * @brief Event arguments that passed via ActionPageLeft signal
 349           *
 350           */
 351         /// <since_tizen> 3 </since_tizen>
 352         public class ActionPageLeftEventArgs : EventArgs
 353         {
 354             private AccessibilityManager _accessibilityManager;
 355
 356             /// <since_tizen> 3 </since_tizen>
 357             public AccessibilityManager AccessibilityManager
 358             {
 359                 get
 360                 {
 361                     return _accessibilityManager;
 362                 }
 363                 set
 364                 {
 365                     _accessibilityManager = value;
 366                 }
 367             }
 368         }
 369
 370         /**
 371           * @brief Event arguments that passed via ActionPageRight signal
 372           *
 373           */
 374         /// <since_tizen> 3 </since_tizen>
 375         public class ActionPageRightEventArgs : EventArgs
 376         {
 377             private AccessibilityManager _accessibilityManager;
 378
 379             /// <since_tizen> 3 </since_tizen>
 380             public AccessibilityManager AccessibilityManager
 381             {
 382                 get
 383                 {
 384                     return _accessibilityManager;
 385                 }
 386                 set
 387                 {
 388                     _accessibilityManager = value;
 389                 }
 390             }
 391         }
 392
 393         /**
 394           * @brief Event arguments that passed via ActionPageUp signal
 395           *
 396           */
 397         /// <since_tizen> 3 </since_tizen>
 398         public class ActionPageUpEventArgs : EventArgs
 399         {
 400             private AccessibilityManager _accessibilityManager;
 401
 402             /// <since_tizen> 3 </since_tizen>
 403             public AccessibilityManager AccessibilityManager
 404             {
 405                 get
 406                 {
 407                     return _accessibilityManager;
 408                 }
 409                 set
 410                 {
 411                     _accessibilityManager = value;
 412                 }
 413             }
 414         }
 415
 416         /**
 417           * @brief Event arguments that passed via ActionPageDown signal
 418           *
 419           */
 420         /// <since_tizen> 3 </since_tizen>
 421         public class ActionPageDownEventArgs : EventArgs
 422         {
 423             private AccessibilityManager _accessibilityManager;
 424
 425             /// <since_tizen> 3 </since_tizen>
 426             public AccessibilityManager AccessibilityManager
 427             {
 428                 get
 429                 {
 430                     return _accessibilityManager;
 431                 }
 432                 set
 433                 {
 434                     _accessibilityManager = value;
 435                 }
 436             }
 437         }
 438
 439         /**
 440           * @brief Event arguments that passed via ActionMoveToFirst signal
 441           *
 442           */
 443         /// <since_tizen> 3 </since_tizen>
 444         public class ActionMoveToFirstEventArgs : EventArgs
 445         {
 446             private AccessibilityManager _accessibilityManager;
 447
 448             /// <since_tizen> 3 </since_tizen>
 449             public AccessibilityManager AccessibilityManager
 450             {
 451                 get
 452                 {
 453                     return _accessibilityManager;
 454                 }
 455                 set
 456                 {
 457                     _accessibilityManager = value;
 458                 }
 459             }
 460         }
 461
 462         /**
 463           * @brief Event arguments that passed via ActionMoveToLast signal
 464           *
 465           */
 466         /// <since_tizen> 3 </since_tizen>
 467         public class ActionMoveToLastEventArgs : EventArgs
 468         {
 469             private AccessibilityManager _accessibilityManager;
 470
 471             /// <since_tizen> 3 </since_tizen>
 472             public AccessibilityManager AccessibilityManager
 473             {
 474                 get
 475                 {
 476                     return _accessibilityManager;
 477                 }
 478                 set
 479                 {
 480                     _accessibilityManager = value;
 481                 }
 482             }
 483         }
 484
 485         /**
 486           * @brief Event arguments that passed via ActionReadFromTop signal
 487           *
 488           */
 489         /// <since_tizen> 3 </since_tizen>
 490         public class ActionReadFromTopEventArgs : EventArgs
 491         {
 492             private AccessibilityManager _accessibilityManager;
 493
 494             /// <since_tizen> 3 </since_tizen>
 495             public AccessibilityManager AccessibilityManager
 496             {
 497                 get
 498                 {
 499                     return _accessibilityManager;
 500                 }
 501                 set
 502                 {
 503                     _accessibilityManager = value;
 504                 }
 505             }
 506         }
 507
 508         /**
 509           * @brief Event arguments that passed via ActionReadFromNext signal
 510           *
 511           */
 512         /// <since_tizen> 3 </since_tizen>
 513         public class ActionReadFromNextEventArgs : EventArgs
 514         {
 515             private AccessibilityManager _accessibilityManager;
 516
 517             /// <since_tizen> 3 </since_tizen>
 518             public AccessibilityManager AccessibilityManager
 519             {
 520                 get
 521                 {
 522                     return _accessibilityManager;
 523                 }
 524                 set
 525                 {
 526                     _accessibilityManager = value;
 527                 }
 528             }
 529         }
 530
 531         /**
 532           * @brief Event arguments that passed via ActionZoom signal
 533           *
 534           */
 535         /// <since_tizen> 3 </since_tizen>
 536         public class ActionZoomEventArgs : EventArgs
 537         {
 538             private AccessibilityManager _accessibilityManager;
 539
 540             /// <since_tizen> 3 </since_tizen>
 541             public AccessibilityManager AccessibilityManager
 542             {
 543                 get
 544                 {
 545                     return _accessibilityManager;
 546                 }
 547                 set
 548                 {
 549                     _accessibilityManager = value;
 550                 }
 551             }
 552         }
 553
 554         /**
 555           * @brief Event arguments that passed via ActionReadIndicatorInformation signal
 556           *
 557           */
 558         /// <since_tizen> 3 </since_tizen>
 559         public class ActionReadIndicatorInformationEventArgs : EventArgs
 560         {
 561             private AccessibilityManager _accessibilityManager;
 562
 563             /// <since_tizen> 3 </since_tizen>
 564             public AccessibilityManager AccessibilityManager
 565             {
 566                 get
 567                 {
 568                     return _accessibilityManager;
 569                 }
 570                 set
 571                 {
 572                     _accessibilityManager = value;
 573                 }
 574             }
 575         }
 576
 577         /**
 578           * @brief Event arguments that passed via ActionReadPauseResume signal
 579           *
 580           */
 581         /// <since_tizen> 3 </since_tizen>
 582         public class ActionReadPauseResumeEventArgs : EventArgs
 583         {
 584             private AccessibilityManager _accessibilityManager;
 585
 586             /// <since_tizen> 3 </since_tizen>
 587             public AccessibilityManager AccessibilityManager
 588             {
 589                 get
 590                 {
 591                     return _accessibilityManager;
 592                 }
 593                 set
 594                 {
 595                     _accessibilityManager = value;
 596                 }
 597             }
 598         }
 599
 600         /**
 601           * @brief Event arguments that passed via ActionStartStop signal
 602           *
 603           */
 604         /// <since_tizen> 3 </since_tizen>
 605         public class ActionStartStopEventArgs : EventArgs
 606         {
 607             private AccessibilityManager _accessibilityManager;
 608
 609             /// <since_tizen> 3 </since_tizen>
 610             public AccessibilityManager AccessibilityManager
 611             {
 612                 get
 613                 {
 614                     return _accessibilityManager;
 615                 }
 616                 set
 617                 {
 618                     _accessibilityManager = value;
 619                 }
 620             }
 621         }
 622
 623         /*
 624             // To be replaced by a new event that takes Touch
 625             public class ActionScrollEventArgs : EventArgs
 626             {
 627               private AccessibilityManager _accessibilityManager;
 628               private TouchEvent _touchEvent;
 629
 630               public AccessibilityManager AccessibilityManager
 631               {
 632                 get
 633                 {
 634                   return _accessibilityManager;
 635                 }
 636                 set
 637                 {
 638                   _accessibilityManager = value;
 639                 }
 640               }
 641
 642               public TouchEvent TouchEvent
 643               {
 644                 get
 645                 {
 646                   return _touchEvent;
 647                 }
 648                 set
 649                 {
 650                   _touchEvent = value;
 651                 }
 652               }
 653             }
 654         */
 655
 656         /**
 657           * @brief Event arguments that passed via ActionPageUp signal
 658           *
 659           */
 660         /// <since_tizen> 3 </since_tizen>
 661         public class FocusChangedEventArgs : EventArgs
 662         {
 663             private View _viewCurrent;
 664             private View _viewNext;
 665
 666             /// <since_tizen> 3 </since_tizen>
 667             public View ViewCurrent
 668             {
 669                 get
 670                 {
 671                     return _viewCurrent;
 672                 }
 673                 set
 674                 {
 675                     _viewCurrent = value;
 676                 }
 677             }
 678
 679             /// <since_tizen> 3 </since_tizen>
 680             public View ViewNext
 681             {
 682                 get
 683                 {
 684                     return _viewNext;
 685                 }
 686                 set
 687                 {
 688                     _viewNext = value;
 689                 }
 690             }
 691         }
 692
 693         /**
 694           * @brief Event arguments that passed via FocusedViewActivated signal
 695           *
 696           */
 697         /// <since_tizen> 3 </since_tizen>
 698         public class FocusedViewActivatedEventArgs : EventArgs
 699         {
 700             private View _view;
 701
 702
 703             /// <since_tizen> 3 </since_tizen>
 704             public View View
 705             {
 706                 get
 707                 {
 708                     return _view;
 709                 }
 710                 set
 711                 {
 712                     _view = value;
 713                 }
 714             }
 715         }
 716
 717         /**
 718           * @brief Event arguments that passed via FocusOvershot signal
 719           *
 720           */
 721         /// <since_tizen> 3 </since_tizen>
 722         public class FocusOvershotEventArgs : EventArgs
 723         {
 724             private View _currentFocusedView;
 725             private AccessibilityManager.FocusOvershotDirection _focusOvershotDirection;
 726
 727             /// <since_tizen> 3 </since_tizen>
 728             public View CurrentFocusedView
 729             {
 730                 get
 731                 {
 732                     return _currentFocusedView;
 733                 }
 734                 set
 735                 {
 736                     _currentFocusedView = value;
 737                 }
 738             }
 739
 740             /// <since_tizen> 3 </since_tizen>
 741             public AccessibilityManager.FocusOvershotDirection FocusOvershotDirection
 742             {
 743                 get
 744                 {
 745                     return _focusOvershotDirection;
 746                 }
 747                 set
 748                 {
 749                     _focusOvershotDirection = value;
 750                 }
 751             }
 752         }
 753     }
 754 }