internals/src/EflSharp/EflSharp/efl/elm_general.eot.cs

   1 #pragma warning disable CS1591
   2 using System;
   3 using System.Runtime.InteropServices;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Threading;
   7 using System.ComponentModel;
   8 namespace Elm {
   9
  10 /// <summary>Policy identifiers.</summary>
  11 public enum Policy
  12 {
  13 /// <summary>under which circumstances the application should quit automatically. See also <see cref="Elm.Policy.Quit"/>.</summary>
  14 Quit = 0,
  15 /// <summary>defines elm_exit() behaviour. See also <see cref="Elm.Policy.Exit"/>.
  16 /// (Since EFL 1.8)</summary>
  17 Exit = 1,
  18 /// <summary>defines how throttling should work. See also <see cref="Elm.Policy.Throttle"/>
  19 /// (Since EFL 1.8)</summary>
  20 Throttle = 2,
  21 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
  22 Last = 3,
  23 }
  24
  25 }
  26
  27 namespace Elm {
  28
  29 /// <summary>Possible values for the <see cref="Elm.Policy.Quit"/> policy</summary>
  30 public enum PolicyQuit
  31 {
  32 /// <summary>never quit the application automatically</summary>
  33 None = 0,
  34 /// <summary>quit when the application&apos;s last window is closed</summary>
  35 LastWindowClosed = 1,
  36 /// <summary>quit when the application&apos;s last window is hidden
  37 /// (Since EFL 1.14)</summary>
  38 LastWindowHidden = 2,
  39 }
  40
  41 }
  42
  43 namespace Elm {
  44
  45 /// <summary>Possible values for the <see cref="Elm.Policy.Exit"/> policy.
  46 /// (Since EFL 1.8)</summary>
  47 public enum PolicyExit
  48 {
  49 /// <summary>just quit the main loop on elm_exit()</summary>
  50 None = 0,
  51 /// <summary>delete all the windows after quitting the main loop</summary>
  52 WindowsDel = 1,
  53 }
  54
  55 }
  56
  57 namespace Elm {
  58
  59 /// <summary>Possible values for the <see cref="Elm.Policy.Throttle"/> policy.
  60 /// (Since EFL 1.8)</summary>
  61 public enum PolicyThrottle
  62 {
  63 /// <summary>do whatever elementary config is configured to do</summary>
  64 Config = 0,
  65 /// <summary>always throttle when all windows are no longer visible</summary>
  66 HiddenAlways = 1,
  67 /// <summary>never throttle when windows are all hidden, regardless of config settings</summary>
  68 Never = 2,
  69 }
  70
  71 }
  72
  73 namespace Elm {
  74
  75 namespace Object {
  76
  77 /// <summary>Possible values for the #ELM_OBJECT_SELECT_MODE policy.
  78 /// (Since EFL 1.7)</summary>
  79 public enum SelectMode
  80 {
  81 /// <summary>default select mode. Once an item is selected, it would stay highlighted and not going to call selected callback again even it was clicked. Items can get focus.</summary>
  82 Default = 0,
  83 /// <summary>always select mode. Item selected callbacks will be called every time for click events, even after the item was already selected. Items can get focus.</summary>
  84 Always = 1,
  85 /// <summary>no select mode. Items will never be highlighted and selected but the size will be adjusted by the finger size configuration. Items can&apos;t get focus.</summary>
  86 None = 2,
  87 /// <summary>no select mode with no finger size rule. Items will never be highlighted and selected and ignore the finger size. So the item size can be reduced below than the finger size configuration. Items can&apos;t get focus.</summary>
  88 DisplayOnly = 3,
  89 /// <summary>canary value: any value greater or equal to ELM_OBJECT_SELECT_MODE_MAX is forbidden.</summary>
  90 Max = 4,
  91 }
  92
  93 }
  94
  95 }
  96
  97 namespace Elm {
  98
  99 namespace Object {
 100
 101 /// <summary>Possible values for the #ELM_OBJECT_MULTI_SELECT_MODE policy.
 102 /// (Since EFL 1.8)</summary>
 103 public enum MultiSelectMode
 104 {
 105 /// <summary>default multiple select mode</summary>
 106 Default = 0,
 107 /// <summary>disallow mutiple selection when clicked without control key pressed</summary>
 108 WithControl = 1,
 109 /// <summary>canary value: any value greater or equal to ELM_OBJECT_MULTI_SELECT_MODE_MAX is forbidden.</summary>
 110 Max = 2,
 111 }
 112
 113 }
 114
 115 }
 116
 117 namespace Elm {
 118
 119 namespace Wrap {
 120
 121 /// <summary>Line wrapping types. Type of word or character wrapping to use.
 122 /// See also @ref elm_entry_line_wrap_set, @ref elm_popup_content_text_wrap_type_set, @ref elm_label_line_wrap_set.</summary>
 123 public enum Type
 124 {
 125 /// <summary>No wrap - value is zero.</summary>
 126 None = 0,
 127 /// <summary>Char wrap - wrap between characters.</summary>
 128 Char = 1,
 129 /// <summary>Word wrap - wrap in allowed wrapping points (as defined in the unicode standard).</summary>
 130 Word = 2,
 131 /// <summary>Mixed wrap - Word wrap, and if that fails, char wrap.</summary>
 132 Mixed = 3,
 133 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
 134 Last = 4,
 135 }
 136
 137 }
 138
 139 }
 140
 141 namespace Elm {
 142
 143 namespace Icon {
 144
 145 /// <summary>Elementary icon types</summary>
 146 public enum Type
 147 {
 148 /// <summary>Icon has no type set</summary>
 149 None = 0,
 150 /// <summary>Icon is of type file</summary>
 151 File = 1,
 152 /// <summary>Icon is of type standard</summary>
 153 Standard = 2,
 154 }
 155
 156 }
 157
 158 }
 159
 160 namespace Elm {
 161
 162 /// <summary>Text Format types.</summary>
 163 public enum TextFormat
 164 {
 165 /// <summary>Plain UTF8 type</summary>
 166 PlainUtf8 = 0,
 167 /// <summary>Markup UTF8 type</summary>
 168 MarkupUtf8 = 1,
 169 }
 170
 171 }
 172
 173 namespace Elm {
 174
 175 namespace Input {
 176
 177 namespace Panel {
 178
 179 /// <summary>Input panel (virtual keyboard) layout types. Type of input panel (virtual keyboard) to use - this is a hint and may not provide exactly what is desired.</summary>
 180 public enum Layout
 181 {
 182 /// <summary>Default layout.</summary>
 183 Normal = 0,
 184 /// <summary>Number layout.</summary>
 185 Number = 1,
 186 /// <summary>Email layout.</summary>
 187 Email = 2,
 188 /// <summary>URL layout.</summary>
 189 Url = 3,
 190 /// <summary>Phone Number layout.</summary>
 191 Phonenumber = 4,
 192 /// <summary>IP layout.</summary>
 193 Ip = 5,
 194 /// <summary>Month layout.</summary>
 195 Month = 6,
 196 /// <summary>Number Only layout.</summary>
 197 Numberonly = 7,
 198 /// <summary>Never use this.</summary>
 199 Invalid = 8,
 200 /// <summary>Hexadecimal layout.</summary>
 201 Hex = 9,
 202 /// <summary>Command-line terminal layout including esc, alt, ctrl key, so on (no auto-correct, no auto-capitalization).</summary>
 203 Terminal = 10,
 204 /// <summary>Like normal, but no auto-correct, no auto-capitalization etc.</summary>
 205 Password = 11,
 206 /// <summary>Date and time layout
 207 /// (Since EFL 1.8)</summary>
 208 Datetime = 12,
 209 /// <summary>Emoticon layout
 210 /// (Since EFL 1.10)</summary>
 211 Emoticon = 13,
 212 /// <summary>Voice layout, but if the IME does not support voice layout, then normal layout will be shown.
 213 /// (Since EFL 1.19)</summary>
 214 Voice = 14,
 215 }
 216
 217 }
 218
 219 }
 220
 221 }
 222
 223 namespace Elm {
 224
 225 namespace Input {
 226
 227 namespace Panel {
 228
 229 /// <summary>Input panel (virtual keyboard) language modes.</summary>
 230 public enum Lang
 231 {
 232 /// <summary>Automatic</summary>
 233 Automatic = 0,
 234 /// <summary>Alphabet</summary>
 235 Alphabet = 1,
 236 }
 237
 238 }
 239
 240 }
 241
 242 }
 243
 244 namespace Elm {
 245
 246 namespace Autocapital {
 247
 248 /// <summary>Autocapitalization Types. Choose method of auto-capitalization.</summary>
 249 public enum Type
 250 {
 251 /// <summary>No auto-capitalization when typing.</summary>
 252 None = 0,
 253 /// <summary>Autocapitalize each word typed.</summary>
 254 Word = 1,
 255 /// <summary>Autocapitalize the start of each sentence.</summary>
 256 Sentence = 2,
 257 /// <summary>Autocapitalize all letters.</summary>
 258 Allcharacter = 3,
 259 }
 260
 261 }
 262
 263 }
 264
 265 namespace Elm {
 266
 267 namespace Input {
 268
 269 namespace Panel {
 270
 271 namespace ReturnKey {
 272
 273 /// <summary>&quot;Return&quot; Key types on the input panel (virtual keyboard).</summary>
 274 public enum Type
 275 {
 276 /// <summary>Default.</summary>
 277 Default = 0,
 278 /// <summary>Done.</summary>
 279 Done = 1,
 280 /// <summary>Go.</summary>
 281 Go = 2,
 282 /// <summary>Join.</summary>
 283 Join = 3,
 284 /// <summary>Login.</summary>
 285 Login = 4,
 286 /// <summary>Next.</summary>
 287 Next = 5,
 288 /// <summary>Search string or magnifier icon.</summary>
 289 Search = 6,
 290 /// <summary>Send.</summary>
 291 Send = 7,
 292 /// <summary>Sign-in
 293 /// (Since EFL 1.8)</summary>
 294 Signin = 8,
 295 }
 296
 297 }
 298
 299 }
 300
 301 }
 302
 303 }
 304
 305 namespace Elm {
 306
 307 namespace Input {
 308
 309 /// <summary>Enumeration that defines the types of Input Hints.
 310 /// (Since EFL 1.12)</summary>
 311 public enum Hints
 312 {
 313 /// <summary>No active hints
 314 /// (Since EFL 1.12)</summary>
 315 None = 0,
 316 /// <summary>Suggest word auto completion
 317 /// (Since EFL 1.12)</summary>
 318 AutoComplete = 1,
 319 /// <summary>Typed text should not be stored.
 320 /// (Since EFL 1.12)</summary>
 321 SensitiveData = 2,
 322 /// <summary>Autofill hint for a credit card expiration date
 323 /// (Since EFL 1.21)</summary>
 324 AutofillCreditCardExpirationDate = 256,
 325 /// <summary>Autofill hint for a credit card expiration day
 326 /// (Since EFL 1.21)</summary>
 327 AutofillCreditCardExpirationDay = 512,
 328 /// <summary>Autofill hint for a credit card expiration month
 329 /// (Since EFL 1.21)</summary>
 330 AutofillCreditCardExpirationMonth = 768,
 331 /// <summary>Autofill hint for a credit card expiration year
 332 /// (Since EFL 1.21)</summary>
 333 AutofillCreditCardExpirationYear = 1024,
 334 /// <summary>Autofill hint for a credit card number
 335 /// (Since EFL 1.21)</summary>
 336 AutofillCreditCardNumber = 1280,
 337 /// <summary>Autofill hint for an email address
 338 /// (Since EFL 1.21)</summary>
 339 AutofillEmailAddress = 1536,
 340 /// <summary>Autofill hint for a user&apos;s real name
 341 /// (Since EFL 1.21)</summary>
 342 AutofillName = 1792,
 343 /// <summary>Autofill hint for a phone number
 344 /// (Since EFL 1.21)</summary>
 345 AutofillPhone = 2048,
 346 /// <summary>Autofill hint for a postal address
 347 /// (Since EFL 1.21)</summary>
 348 AutofillPostalAddress = 2304,
 349 /// <summary>Autofill hint for a postal code
 350 /// (Since EFL 1.21)</summary>
 351 AutofillPostalCode = 2560,
 352 /// <summary>Autofill hint for a user&apos;s ID
 353 /// (Since EFL 1.21)</summary>
 354 AutofillId = 2816,
 355 }
 356
 357 }
 358
 359 }
 360
 361 namespace Elm {
 362
 363 /// <summary>Enum of entry&apos;s copy &amp; paste policy.</summary>
 364 public enum CnpMode
 365 {
 366 /// <summary>copy &amp; paste text with markup tag</summary>
 367 Markup = 0,
 368 /// <summary>copy &amp; paste text without item(image) tag</summary>
 369 NoImage = 1,
 370 /// <summary>copy &amp; paste text without markup tag</summary>
 371 Plaintext = 2,
 372 }
 373
 374 }
 375
 376 namespace Elm {
 377
 378 namespace Genlist {
 379
 380 namespace Item {
 381
 382 /// <summary>Defines if the item is of any special type (has subitems or it&apos;s the index of a group), or is just a simple item.</summary>
 383 public enum Type
 384 {
 385 /// <summary>Simple item.</summary>
 386 None = 0,
 387 /// <summary>This may be expanded and have child items.</summary>
 388 Tree = 1,
 389 /// <summary>An index item of a group of items. this item can have child items.</summary>
 390 Group = 2,
 391 /// <summary>Sentinel value to indicate last enum field during iteration</summary>
 392 Max = 4,
 393 }
 394
 395 }
 396
 397 }
 398
 399 }
 400
 401 namespace Elm {
 402
 403 namespace Genlist {
 404
 405 namespace Item {
 406
 407 /// <summary>Defines the type of the item part Used while updating item&apos;s parts It can be used at updating multi fields.</summary>
 408 public enum FieldType
 409 {
 410 /// <summary>Type all</summary>
 411 All = 0,
 412 /// <summary>Type text</summary>
 413 Text = 1,
 414 /// <summary>Type content</summary>
 415 Content = 2,
 416 /// <summary>Type state</summary>
 417 State = 4,
 418 }
 419
 420 }
 421
 422 }
 423
 424 }
 425
 426 namespace Elm {
 427
 428 namespace Genlist {
 429
 430 namespace Item {
 431
 432 /// <summary>Defines where to position the item in the genlist.</summary>
 433 public enum ScrolltoType
 434 {
 435 /// <summary>Nothing will happen, Don&apos;t use this value.</summary>
 436 None = 0,
 437 /// <summary>To the nearest viewport.</summary>
 438 In = 1,
 439 /// <summary>To the top of viewport.</summary>
 440 Top = 2,
 441 /// <summary>To the middle of viewport.</summary>
 442 Middle = 4,
 443 /// <summary>To the bottom of viewport.</summary>
 444 Bottom = 8,
 445 }
 446
 447 }
 448
 449 }
 450
 451 }
 452
 453 namespace Elm {
 454
 455 namespace Gengrid {
 456
 457 namespace Item {
 458
 459 /// <summary>Defines where to position the item in the genlist.</summary>
 460 public enum ScrolltoType
 461 {
 462 /// <summary>No scrollto.</summary>
 463 None = 0,
 464 /// <summary>To the nearest viewport.</summary>
 465 In = 1,
 466 /// <summary>To the top of viewport.</summary>
 467 Top = 2,
 468 /// <summary>To the middle of viewport.</summary>
 469 Middle = 4,
 470 /// <summary>To the bottom of viewport.</summary>
 471 Bottom = 8,
 472 }
 473
 474 }
 475
 476 }
 477
 478 }
 479
 480 namespace Elm {
 481
 482 namespace Gengrid {
 483
 484 namespace Item {
 485
 486 /// <summary>Defines the type of the item part Used while updating item&apos;s parts. It can be used at updating multi fields.</summary>
 487 public enum FieldType
 488 {
 489 /// <summary>Type all</summary>
 490 All = 0,
 491 /// <summary>Type text</summary>
 492 Text = 1,
 493 /// <summary>Type content</summary>
 494 Content = 2,
 495 /// <summary>Type state</summary>
 496 State = 4,
 497 }
 498
 499 }
 500
 501 }
 502
 503 }
 504
 505 namespace Elm {
 506
 507 namespace List {
 508
 509 /// <summary>Set list&apos;s resizing behavior, transverse axis scrolling and items cropping. See each mode&apos;s description for more details.
 510 /// Note: Default value is <see cref="Elm.List.Mode.Scroll"/>.
 511 ///
 512 /// Values here don&apos;t work as bitmasks -- only one can be chosen at a time.</summary>
 513 public enum Mode
 514 {
 515 /// <summary>The list won&apos;t set any of its size hints to inform how a possible container should resize it. Then, if it&apos;s not created as a &quot;resize object&quot;, it might end with zeroed dimensions. The list will respect the container&apos;s geometry and, if any of its items won&apos;t fit into its transverse axis, one won&apos;t be able to scroll it in that direction.</summary>
 516 Compress = 0,
 517 /// <summary>Default value. This is the same as #ELM_LIST_COMPRESS, with the exception that if any of its items won&apos;t fit into its transverse axis, one will be able to scroll it in that direction.</summary>
 518 Scroll = 1,
 519 /// <summary>Sets a minimum size hint on the list object, so that containers may respect it (and resize itself to fit the child properly). More specifically, a minimum size hint will be set for its transverse axis, so that the largest item in that direction fits well. This is naturally bound by the list object&apos;s maximum size hints, set externally.</summary>
 520 Limit = 2,
 521 /// <summary>Besides setting a minimum size on the transverse axis, just like on <see cref="Elm.List.Mode.Limit"/>, the list will set a minimum size on the longitudinal axis, trying to reserve space to all its children to be visible at a time. . This is naturally bound by the list object&apos;s maximum size hints, set externally.</summary>
 522 Expand = 3,
 523 /// <summary>Indicates error if returned by elm_list_mode_get().</summary>
 524 Last = 4,
 525 }
 526
 527 }
 528
 529 }
 530
 531 namespace Elm {
 532
 533 namespace Event {
 534
 535 /// <summary>Data on the event when an Elementary policy has changed</summary>
 536 [StructLayout(LayoutKind.Sequential)]
 537 public struct PolicyChanged
 538 {
 539     /// <summary>the policy identifier</summary>
 540     public uint Policy;
 541     /// <summary>value the policy had before the change</summary>
 542     public int New_value;
 543     /// <summary>new value the policy got</summary>
 544     public int Old_value;
 545     ///<summary>Constructor for PolicyChanged.</summary>
 546     public PolicyChanged(
 547         uint Policy = default(uint),
 548         int New_value = default(int),
 549         int Old_value = default(int)    )
 550     {
 551         this.Policy = Policy;
 552         this.New_value = New_value;
 553         this.Old_value = Old_value;
 554     }
 555
 556     public static implicit operator PolicyChanged(IntPtr ptr)
 557     {
 558         var tmp = (PolicyChanged.NativeStruct)Marshal.PtrToStructure(ptr, typeof(PolicyChanged.NativeStruct));
 559         return tmp;
 560     }
 561
 562     ///<summary>Internal wrapper for struct PolicyChanged.</summary>
 563     [StructLayout(LayoutKind.Sequential)]
 564     public struct NativeStruct
 565     {
 566
 567         public uint Policy;
 568
 569         public int New_value;
 570
 571         public int Old_value;
 572         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 573         public static implicit operator PolicyChanged.NativeStruct(PolicyChanged _external_struct)
 574         {
 575             var _internal_struct = new PolicyChanged.NativeStruct();
 576             _internal_struct.Policy = _external_struct.Policy;
 577             _internal_struct.New_value = _external_struct.New_value;
 578             _internal_struct.Old_value = _external_struct.Old_value;
 579             return _internal_struct;
 580         }
 581
 582         ///<summary>Implicit conversion to the managed representation.</summary>
 583         public static implicit operator PolicyChanged(PolicyChanged.NativeStruct _internal_struct)
 584         {
 585             var _external_struct = new PolicyChanged();
 586             _external_struct.Policy = _internal_struct.Policy;
 587             _external_struct.New_value = _internal_struct.New_value;
 588             _external_struct.Old_value = _internal_struct.Old_value;
 589             return _external_struct;
 590         }
 591
 592     }
 593
 594 }
 595
 596 }
 597
 598 }
 599
 600 /// <summary>Elementary gen item</summary>
 601 [StructLayout(LayoutKind.Sequential)]
 602 public struct ElmGenItem
 603 {
 604     ///<summary>Placeholder field</summary>
 605     public IntPtr field;
 606     public static implicit operator ElmGenItem(IntPtr ptr)
 607     {
 608         var tmp = (ElmGenItem.NativeStruct)Marshal.PtrToStructure(ptr, typeof(ElmGenItem.NativeStruct));
 609         return tmp;
 610     }
 611
 612     ///<summary>Internal wrapper for struct ElmGenItem.</summary>
 613     [StructLayout(LayoutKind.Sequential)]
 614     public struct NativeStruct
 615     {
 616         internal IntPtr field;
 617         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 618         public static implicit operator ElmGenItem.NativeStruct(ElmGenItem _external_struct)
 619         {
 620             var _internal_struct = new ElmGenItem.NativeStruct();
 621             return _internal_struct;
 622         }
 623
 624         ///<summary>Implicit conversion to the managed representation.</summary>
 625         public static implicit operator ElmGenItem(ElmGenItem.NativeStruct _internal_struct)
 626         {
 627             var _external_struct = new ElmGenItem();
 628             return _external_struct;
 629         }
 630
 631     }
 632
 633 }
 634
 635
 636
 637 /// <summary>Efl access action data</summary>
 638 [StructLayout(LayoutKind.Sequential)]
 639 public struct EflAccessActionData
 640 {
 641     ///<summary>Placeholder field</summary>
 642     public IntPtr field;
 643     public static implicit operator EflAccessActionData(IntPtr ptr)
 644     {
 645         var tmp = (EflAccessActionData.NativeStruct)Marshal.PtrToStructure(ptr, typeof(EflAccessActionData.NativeStruct));
 646         return tmp;
 647     }
 648
 649     ///<summary>Internal wrapper for struct EflAccessActionData.</summary>
 650     [StructLayout(LayoutKind.Sequential)]
 651     public struct NativeStruct
 652     {
 653         internal IntPtr field;
 654         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 655         public static implicit operator EflAccessActionData.NativeStruct(EflAccessActionData _external_struct)
 656         {
 657             var _internal_struct = new EflAccessActionData.NativeStruct();
 658             return _internal_struct;
 659         }
 660
 661         ///<summary>Implicit conversion to the managed representation.</summary>
 662         public static implicit operator EflAccessActionData(EflAccessActionData.NativeStruct _internal_struct)
 663         {
 664             var _external_struct = new EflAccessActionData();
 665             return _external_struct;
 666         }
 667
 668     }
 669
 670 }
 671
 672
 673
 674 namespace Elm {
 675
 676 /// <summary>Data for the elm_validator_regexp_helper()</summary>
 677 [StructLayout(LayoutKind.Sequential)]
 678 public struct ValidateContent
 679 {
 680     ///<summary>Placeholder field</summary>
 681     public IntPtr field;
 682     public static implicit operator ValidateContent(IntPtr ptr)
 683     {
 684         var tmp = (ValidateContent.NativeStruct)Marshal.PtrToStructure(ptr, typeof(ValidateContent.NativeStruct));
 685         return tmp;
 686     }
 687
 688     ///<summary>Internal wrapper for struct ValidateContent.</summary>
 689     [StructLayout(LayoutKind.Sequential)]
 690     public struct NativeStruct
 691     {
 692         internal IntPtr field;
 693         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 694         public static implicit operator ValidateContent.NativeStruct(ValidateContent _external_struct)
 695         {
 696             var _internal_struct = new ValidateContent.NativeStruct();
 697             return _internal_struct;
 698         }
 699
 700         ///<summary>Implicit conversion to the managed representation.</summary>
 701         public static implicit operator ValidateContent(ValidateContent.NativeStruct _internal_struct)
 702         {
 703             var _external_struct = new ValidateContent();
 704             return _external_struct;
 705         }
 706
 707     }
 708
 709 }
 710
 711 }
 712
 713 namespace Elm {
 714
 715 /// <summary>The info sent in the callback for the &quot;anchor,clicked&quot; signals emitted by entries.</summary>
 716 [StructLayout(LayoutKind.Sequential)]
 717 public struct EntryAnchorInfo
 718 {
 719     ///<summary>Placeholder field</summary>
 720     public IntPtr field;
 721     public static implicit operator EntryAnchorInfo(IntPtr ptr)
 722     {
 723         var tmp = (EntryAnchorInfo.NativeStruct)Marshal.PtrToStructure(ptr, typeof(EntryAnchorInfo.NativeStruct));
 724         return tmp;
 725     }
 726
 727     ///<summary>Internal wrapper for struct EntryAnchorInfo.</summary>
 728     [StructLayout(LayoutKind.Sequential)]
 729     public struct NativeStruct
 730     {
 731         internal IntPtr field;
 732         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 733         public static implicit operator EntryAnchorInfo.NativeStruct(EntryAnchorInfo _external_struct)
 734         {
 735             var _internal_struct = new EntryAnchorInfo.NativeStruct();
 736             return _internal_struct;
 737         }
 738
 739         ///<summary>Implicit conversion to the managed representation.</summary>
 740         public static implicit operator EntryAnchorInfo(EntryAnchorInfo.NativeStruct _internal_struct)
 741         {
 742             var _external_struct = new EntryAnchorInfo();
 743             return _external_struct;
 744         }
 745
 746     }
 747
 748 }
 749
 750 }
 751
 752 namespace Elm {
 753
 754 /// <summary>The info sent in the callback for &quot;anchor,hover&quot; signals emitted by the Anchor_Hover widget</summary>
 755 [StructLayout(LayoutKind.Sequential)]
 756 public struct EntryAnchorHoverInfo
 757 {
 758     ///<summary>Placeholder field</summary>
 759     public IntPtr field;
 760     public static implicit operator EntryAnchorHoverInfo(IntPtr ptr)
 761     {
 762         var tmp = (EntryAnchorHoverInfo.NativeStruct)Marshal.PtrToStructure(ptr, typeof(EntryAnchorHoverInfo.NativeStruct));
 763         return tmp;
 764     }
 765
 766     ///<summary>Internal wrapper for struct EntryAnchorHoverInfo.</summary>
 767     [StructLayout(LayoutKind.Sequential)]
 768     public struct NativeStruct
 769     {
 770         internal IntPtr field;
 771         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 772         public static implicit operator EntryAnchorHoverInfo.NativeStruct(EntryAnchorHoverInfo _external_struct)
 773         {
 774             var _internal_struct = new EntryAnchorHoverInfo.NativeStruct();
 775             return _internal_struct;
 776         }
 777
 778         ///<summary>Implicit conversion to the managed representation.</summary>
 779         public static implicit operator EntryAnchorHoverInfo(EntryAnchorHoverInfo.NativeStruct _internal_struct)
 780         {
 781             var _external_struct = new EntryAnchorHoverInfo();
 782             return _external_struct;
 783         }
 784
 785     }
 786
 787 }
 788
 789 }
 790
 791 namespace Elm {
 792
 793 /// <summary>This corresponds to Edje_Entry_Change_Info. Includes information about a change in the entry</summary>
 794 [StructLayout(LayoutKind.Sequential)]
 795 public struct EntryChangeInfo
 796 {
 797     ///<summary>Placeholder field</summary>
 798     public IntPtr field;
 799     public static implicit operator EntryChangeInfo(IntPtr ptr)
 800     {
 801         var tmp = (EntryChangeInfo.NativeStruct)Marshal.PtrToStructure(ptr, typeof(EntryChangeInfo.NativeStruct));
 802         return tmp;
 803     }
 804
 805     ///<summary>Internal wrapper for struct EntryChangeInfo.</summary>
 806     [StructLayout(LayoutKind.Sequential)]
 807     public struct NativeStruct
 808     {
 809         internal IntPtr field;
 810         ///<summary>Implicit conversion to the internal/marshalling representation.</summary>
 811         public static implicit operator EntryChangeInfo.NativeStruct(EntryChangeInfo _external_struct)
 812         {
 813             var _internal_struct = new EntryChangeInfo.NativeStruct();
 814             return _internal_struct;
 815         }
 816
 817         ///<summary>Implicit conversion to the managed representation.</summary>
 818         public static implicit operator EntryChangeInfo(EntryChangeInfo.NativeStruct _internal_struct)
 819         {
 820             var _external_struct = new EntryChangeInfo();
 821             return _external_struct;
 822         }
 823
 824     }
 825
 826 }
 827
 828 }
 829