1 /** All available cursor states 2 * 3 * @ingroup Edje 4 */ 5 typedef enum 6 { 7 EDJE_CURSOR_MAIN = 0, /**< Main cursor state */ 8 EDJE_CURSOR_SELECTION_BEGIN, /**< Selection begin cursor state */ 9 EDJE_CURSOR_SELECTION_END, /**< Selection end cursor state */ 10 EDJE_CURSOR_PREEDIT_START, /**< Pre-edit start cursor state */ 11 EDJE_CURSOR_PREEDIT_END, /**< Pre-edit end cursor state */ 12 EDJE_CURSOR_USER, /**< User cursor state */ 13 EDJE_CURSOR_USER_EXTRA /**< User extra cursor state */ 14 } Edje_Cursor; 15 16 /** All Text auto capital mode type values 17 * 18 * @ingroup Edje_Text 19 */ 20 typedef enum 21 { 22 EDJE_TEXT_AUTOCAPITAL_TYPE_NONE = 0, /**< None mode value */ 23 EDJE_TEXT_AUTOCAPITAL_TYPE_WORD, /**< Word mode value */ 24 EDJE_TEXT_AUTOCAPITAL_TYPE_SENTENCE, /**< Sentence mode value */ 25 EDJE_TEXT_AUTOCAPITAL_TYPE_ALLCHARACTER /**< All characters mode value */ 26 } Edje_Text_Autocapital_Type; 27 28 /** Input hints 29 * 30 * @ingroup Edje 31 */ 32 typedef enum 33 { 34 EDJE_INPUT_HINT_NONE = 0, /**< No active hints 35 * 36 * @since 1.12 */ 37 EDJE_INPUT_HINT_AUTO_COMPLETE = 1 /* 1 >> 0 */, /**< Suggest word auto 38 * completion 39 * 40 * @since 1.12 */ 41 EDJE_INPUT_HINT_SENSITIVE_DATA = 2 /* 1 >> 1 */ /**< Typed text should not be 42 * stored. 43 * 44 * @since 1.12 */ 45 } Edje_Input_Hints; 46 47 /** Input panel language 48 * 49 * @ingroup Edje_Input_Panel 50 */ 51 typedef enum 52 { 53 EDJE_INPUT_PANEL_LANG_AUTOMATIC = 0, /**< Automatic 54 * 55 * @since 1.2 */ 56 EDJE_INPUT_PANEL_LANG_ALPHABET /**< Alphabet 57 * 58 * @since 1.2 */ 59 } Edje_Input_Panel_Lang; 60 61 /** Input panel return key types 62 * 63 * @ingroup Edje_Input_Panel 64 */ 65 typedef enum 66 { 67 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT = 0, /**< Default 68 * 69 * @since 1.2 */ 70 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DONE, /**< Done 71 * 72 * @since 1.2 */ 73 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_GO, /**< Go 74 * 75 * @since 1.2 */ 76 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_JOIN, /**< Join 77 * 78 * @since 1.2 */ 79 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_LOGIN, /**< Login 80 * 81 * @since 1.2 */ 82 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_NEXT, /**< Next 83 * 84 * @since 1.2 */ 85 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_SEARCH, /**< Search or magnifier icon 86 * 87 * @since 1.2 */ 88 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_SEND, /**< Send 89 * 90 * @since 1.2 */ 91 EDJE_INPUT_PANEL_RETURN_KEY_TYPE_SIGNIN /**< Sign-in 92 * 93 * @since 1.8 */ 94 } Edje_Input_Panel_Return_Key_Type; 95 96 /** Input panel layout 97 * 98 * @ingroup Edje_Input_Panel 99 */ 100 typedef enum 101 { 102 EDJE_INPUT_PANEL_LAYOUT_NORMAL = 0, /**< Default layout */ 103 EDJE_INPUT_PANEL_LAYOUT_NUMBER, /**< Number layout */ 104 EDJE_INPUT_PANEL_LAYOUT_EMAIL, /**< Email layout */ 105 EDJE_INPUT_PANEL_LAYOUT_URL, /**< URL layout */ 106 EDJE_INPUT_PANEL_LAYOUT_PHONENUMBER, /**< Phone Number layout */ 107 EDJE_INPUT_PANEL_LAYOUT_IP, /**< IP layout */ 108 EDJE_INPUT_PANEL_LAYOUT_MONTH, /**< Month layout */ 109 EDJE_INPUT_PANEL_LAYOUT_NUMBERONLY, /**< Number Only layout */ 110 EDJE_INPUT_PANEL_LAYOUT_INVALID, /**< Never use this */ 111 EDJE_INPUT_PANEL_LAYOUT_HEX, /**< Hexadecimal layout 112 * 113 * @since 1.2 */ 114 EDJE_INPUT_PANEL_LAYOUT_TERMINAL, /**< Command-line terminal layout including 115 * esc, alt, ctrl key, so on (no 116 * auto-correct, no auto-capitalization) 117 * 118 * @since 1.2 */ 119 EDJE_INPUT_PANEL_LAYOUT_PASSWORD, /**< Like normal, but no auto-correct, no 120 * auto-capitalization etc. 121 * 122 * @since 1.2 */ 123 EDJE_INPUT_PANEL_LAYOUT_DATETIME, /**< Date and time layout 124 * 125 * @since 1.8 */ 126 EDJE_INPUT_PANEL_LAYOUT_EMOTICON, /**< Emoticon layout 127 * 128 * @since 1.10 */ 129 EDJE_INPUT_PANEL_LAYOUT_VOICE /**< Voice layout, but if the IME does not 130 * support voice layout, then normal layout 131 * will be shown. 132 * 133 * @since 1.19 */ 134 } Edje_Input_Panel_Layout; 135 136 /** Perspective info for maps inside edje objects 137 * 138 * @ingroup Edje 139 */ 140 typedef struct _Edje_Perspective Edje_Perspective; 141 142 /** 143 * @internal 144 * @ingroup Edje_General_Group 145 * 146 * @typedef Edje_Version 147 * Type for edje version 148 * 149 */ 150 typedef struct _Edje_Version 151 { 152 int major; /**< The major number of Edje version. */ 153 int minor; /**< The minor number of Edje version. */ 154 int micro; /**< The micro number of Edje version. */ 155 int revision; /**< The revision of Edje version. */ 156 } Edje_Version; 157 158 /** 159 * @internal 160 * @ingroup Edje_General_Group 161 * 162 * Current Edje Version info 163 * 164 */ 165 EAPI extern Edje_Version *edje_version; 166 167 #ifndef _EDJE_OBJECT_EO_CLASS_TYPE 168 #define _EDJE_OBJECT_EO_CLASS_TYPE 169 170 typedef Eo Edje_Object; 171 172 #endif 173 174 /** 175 * @typedef Edje_Color_Class 176 * Type for edje color class 177 */ 178 typedef struct _Edje_Color_Class Edje_Color_Class; 179 180 struct _Edje_Color_Class 181 { 182 const char *name; 183 184 unsigned char r, g, b, a; 185 unsigned char r2, g2, b2, a2; 186 unsigned char r3, g3, b3, a3; 187 Eina_Stringshare *desc; 188 }; 189 190 /** 191 * @typedef Edje_Text_Class 192 * Type for edje text class 193 * 194 * @since 1.17 195 */ 196 typedef struct _Edje_Text_Class Edje_Text_Class; 197 198 struct _Edje_Text_Class 199 { 200 const char *name; 201 const char *font; 202 Evas_Font_Size size; 203 }; 204 205 /** 206 * @typedef Edje_Size_Class 207 * Type for edje size class 208 * 209 * @since 1.17 210 */ 211 typedef struct _Edje_Size_Class Edje_Size_Class; 212 213 struct _Edje_Size_Class 214 { 215 Eina_Stringshare *name; 216 Evas_Coord minw; 217 Evas_Coord minh; 218 Evas_Coord maxw; 219 Evas_Coord maxh; 220 }; 221 222 /** 223 * @defgroup Edje_Object_Communication_Interface_Message Edje Communication Interface: Message 224 * @ingroup Edje_Object_Group 225 * 226 * @brief Functions that deal with messages. 227 * 228 * Edje has two communication interfaces between @b code and @b theme. 229 * Signals and messages. 230 * 231 * Edje messages are one of the communication interfaces between 232 * @b code and a given Edje object's @b theme. With messages, one can 233 * communicate values like strings, float numbers and integer 234 * numbers. Moreover, messages can be identified by integer 235 * numbers. See #Edje_Message_Type for the full list of message types. 236 * 237 * @note Messages must be handled by scripts. 238 * 239 * @{ 240 */ 241 242 /** 243 * @brief Processes all queued up edje messages. 244 * 245 * This function triggers the processing of messages addressed to any 246 * (alive) edje objects. 247 * 248 */ 249 EAPI void edje_message_signal_process (void); 250 251 /** 252 * @} 253 */ 254 255 /** 256 * @defgroup Edje_Object_Communication_Interface_Signal Edje Communication Interface: Signal 257 * @ingroup Edje_Object_Group 258 * 259 * @brief Functions that deal with signals. 260 * 261 * Edje has two communication interfaces between @b code and @b theme. 262 * Signals and messages. 263 * 264 * This group has functions that deal with signals. One can either 265 * emit a signal from @b code to a @b theme or create handles for 266 * the ones emitted from @b themes. Signals are identified by strings. 267 * 268 * @{ 269 */ 270 271 typedef void (*Efl_Signal_Cb) (void *data, Evas_Object *obj, const char *emission, const char *source); /**< Edje signal callback functions's prototype definition. @c data will have the auxiliary data pointer set at the time the callback registration. @c obj will be a pointer the Edje object where the signal comes from. @c emission will identify the exact signal's emission string and @c source the exact signal's source one. */ 272 typedef Efl_Signal_Cb Edje_Signal_Cb; 273 274 /** 275 * @brief Gets extra data passed to callbacks. 276 * 277 * @return The extra data for that callback. 278 * 279 * Some callbacks pass extra information. This function gives access to that 280 * extra information. It's somehow like event_info in smart callbacks. 281 * 282 * @see edje_object_signal_callback_add() for more on Edje signals. 283 * @since 1.1.0 284 */ 285 EAPI void * edje_object_signal_callback_extra_data_get(void); 286 287 288 #ifdef EFL_BETA_API_SUPPORT 289 /** 290 * @brief Gets seat data passed to callbacks. 291 * 292 * @return The seat data for that callback. 293 * 294 * When a callback is initiated by an input event from a seat, we try to 295 * provide seat information with it. 296 * 297 * Signals fired as programmed responses to these signals will also try 298 * to carry the seat data along. 299 * 300 * This returns an opaque pointer to the seat data. 301 * 302 * @see edje_object_signal_callback_add() for more on Edje signals. 303 * @since 1.21 304 */ 305 EAPI void *edje_object_signal_callback_seat_data_get(void); 306 #endif 307 308 309 310 /** 311 * @} 312 */ 313 314 /** 315 * @defgroup Edje_Audio Edje Audio 316 * @ingroup Edje 317 * 318 * @brief Functions to manipulate audio abilities in edje. 319 * 320 * @{ 321 */ 322 323 /** 324 * Identifiers of Edje message types, which can be sent back and forth 325 * code and a given Edje object's theme file/group. 326 * 327 * @see edje_audio_channel_mute_set() 328 * @see edje_audio_channel_mute_get() 329 * 330 * @since 1.9 331 */ 332 typedef enum _Edje_Channel 333 { 334 EDJE_CHANNEL_EFFECT = 0, /**< Standard audio effects */ 335 EDJE_CHANNEL_BACKGROUND = 1, /**< Background audio sounds */ 336 EDJE_CHANNEL_MUSIC = 2, /**< Music audio */ 337 EDJE_CHANNEL_FOREGROUND = 3, /**< Foreground audio sounds */ 338 EDJE_CHANNEL_INTERFACE = 4, /**< Sounds related to the interface */ 339 EDJE_CHANNEL_INPUT = 5, /**< Sounds related to regular input */ 340 EDJE_CHANNEL_ALERT = 6, /**< Sounds for major alerts */ 341 EDJE_CHANNEL_ALL = 7 /**< All audio channels (convenience) */ 342 } Edje_Channel; 343 344 /** 345 * @brief Sets the mute state of audio for the process as a whole. 346 * 347 * @param channel The channel to set the mute state of 348 * @param mute The mute state 349 * 350 * This sets the mute (no output) state of audio for the given channel. 351 * 352 * @see edje_audio_channel_mute_get() 353 * 354 * @since 1.9 355 */ 356 EAPI void edje_audio_channel_mute_set(Edje_Channel channel, Eina_Bool mute); 357 358 /** 359 * @brief Gets the mute state of the given channel. 360 * 361 * @param channel The channel to get the mute state of 362 * @return The mute state of the channel 363 * 364 * @see edje_audio_channel_mute_set() 365 * 366 * @since 1.9 367 */ 368 EAPI Eina_Bool edje_audio_channel_mute_get(Edje_Channel channel); 369 370 /** 371 * @} 372 */ 373 374 /** 375 * @defgroup Edje_General_Group Edje General 376 * @ingroup Edje 377 * 378 * @brief This group discusses functions that have general purposes or affect Edje as a whole. 379 * 380 * Besides containing the initialize and shutdown functions of the library, which should 381 * always be called when we are using Edje, this module contains some other utilities that 382 * could be used in many contexts or should do their jobs independent of the context inside Edje. 383 * 384 * @{ 385 */ 386 387 /** 388 * @brief Initializes the Edje library. 389 * 390 * @return The new init count. The initial value is zero. 391 * 392 * This function initializes the Edje library, making the proper calls 393 * to internal initialization functions. It will also initialize its 394 * @b dependencies, making calls to @c eina_init(), @c ecore_init(), 395 * @c embryo_init() and @c eet_init(). So, there is no need to call 396 * those functions again, in your code. To shutdown Edje there is the 397 * function edje_shutdown(). 398 * 399 * @see edje_shutdown() 400 * @see eina_init() 401 * @see ecore_init() 402 * @see embryo_init() 403 * @see eet_init() 404 * 405 */ 406 EAPI int edje_init (void); 407 408 /** 409 * @brief Shuts down the Edje library. 410 * 411 * @return The number of times the library has been initialized 412 * without being shutdown. 413 * 414 * This function shuts down the Edje library. It will also call the 415 * shutdown functions of its @b dependencies, which are @c 416 * eina_shutdown(), @c ecore_shutdown(), @c embryo_shutdown() and @c 417 * eet_shutdown(), so there is no need to call these functions again, 418 * in your code. 419 * 420 * @see edje_init() 421 * @see eina_shutdown() 422 * @see ecore_shutdown() 423 * @see embryo_shutdown() 424 * @see eet_shutdown() 425 * 426 */ 427 EAPI int edje_shutdown (void); 428 429 /** 430 * @brief Sets the edje append fontset. 431 * 432 * @param fonts The fontset to append. 433 * 434 * This function sets the edje append fontset. 435 * 436 */ 437 EAPI void edje_fontset_append_set (const char *fonts); 438 439 /** 440 * @brief Gets data from the file level data block of an edje mapped file. 441 * @param f The mapped edje file 442 * @param key The data key 443 * @return The string value of the data, or @c NULL if no key is found. 444 * Must be freed by the user when no longer needed. 445 * 446 * If an edje file test.edj is built from the following edc: 447 * 448 * data { 449 * item: "key1" "value1"; 450 * item: "key2" "value2"; 451 * } 452 * collections { ... } 453 * 454 * Then, edje_file_data_get("test.edj", "key1") will return "value1" 455 */ 456 EAPI char *edje_mmap_data_get(const Eina_File *f, const char *key); 457 458 /** 459 * @brief Gets data from the file level data block of an edje file. 460 * @param file The path to the .edj file 461 * @param key The data key 462 * @return The string value of the data, or @c NULL if no key is found. 463 * Must be freed by the user when no longer needed. 464 * 465 * If an edje file test.edj is built from the following edc: 466 * 467 * data { 468 * item: "key1" "value1"; 469 * item: "key2" "value2"; 470 * } 471 * collections { ... } 472 * 473 * Then, edje_file_data_get("test.edj", "key1") will return "value1" 474 * 475 * @see edje_mmap_data_get() 476 */ 477 EAPI char *edje_file_data_get (const char *file, const char *key); 478 479 /** 480 * @brief Loads a new module in Edje. 481 * @param module The name of the module that will be added to Edje. 482 * @return @c EINA_TRUE if the module was successfully loaded. Otherwise, @c EINA_FALSE. 483 * 484 * Modules are used to add functionality to Edje. 485 * So, when a module is loaded, its functionality should be available for use. 486 * 487 */ 488 EAPI Eina_Bool edje_module_load (const char *module); 489 490 /** 491 * @brief Retrieves all modules that can be loaded. 492 * @return A list of all loadable modules. 493 * 494 * This function retrieves all modules that can be loaded by edje_module_load(). 495 * 496 * @see edje_module_load(). 497 * 498 */ 499 EAPI const Eina_List *edje_available_modules_get (void); 500 501 /** 502 * @brief Gets the edje append fontset. 503 * 504 * @return The edje append fontset. 505 * 506 * This function returns the edje append fontset set by 507 * edje_fontset_append_set() function. 508 * 509 * @see edje_fontset_append_set(). 510 * 511 */ 512 EAPI const char *edje_fontset_append_get (void); 513 514 /** 515 * @brief Sets the file cache size. 516 * 517 * @param count The file cache size in edje file units. Default is 16. 518 * 519 * This function sets the file cache size. Edje keeps this cache in 520 * order to prevent duplicates of edje file entries in memory. The 521 * file cache size can be retrieved with edje_file_cache_get(). 522 * 523 * @see edje_file_cache_get() 524 * @see edje_file_cache_flush() 525 * 526 */ 527 EAPI void edje_file_cache_set (int count); 528 529 /** 530 * @brief Returns the file cache size. 531 * 532 * @return The file cache size in edje file units. Default is 16. 533 * 534 * This function returns the file cache size set by 535 * edje_file_cache_set(). 536 * 537 * @see edje_file_cache_set() 538 * @see edje_file_cache_flush() 539 * 540 */ 541 EAPI int edje_file_cache_get (void); 542 543 /** 544 * @brief Cleans the file cache. 545 * 546 * This function cleans the file cache entries, but keeps this cache's 547 * size to the last value set. 548 * 549 * @see edje_file_cache_set() 550 * @see edje_file_cache_get() 551 * 552 */ 553 EAPI void edje_file_cache_flush (void); 554 555 /** 556 * @brief Sets the collection cache size. 557 * 558 * @param count The collection cache size, in edje object units. Default is 16. 559 * 560 * This function sets the collection cache size. Edje keeps this cache 561 * in order to prevent duplicates of edje {collection,group,part} 562 * entries in memory. The collection cache size can be retrieved with 563 * edje_collection_cache_get(). 564 * 565 * @see edje_collection_cache_get() 566 * @see edje_collection_cache_flush() 567 * 568 */ 569 EAPI void edje_collection_cache_set (int count); 570 571 /** 572 * @brief Returns the collection cache size. 573 * 574 * @return The collection cache size, in edje object units. Default is 16. 575 * 576 * This function returns the collection cache size set by 577 * edje_collection_cache_set(). 578 * 579 * @see edje_collection_cache_set() 580 * @see edje_collection_cache_flush() 581 * 582 */ 583 EAPI int edje_collection_cache_get (void); 584 585 /** 586 * @brief Cleans the collection cache. 587 * 588 * This function cleans the collection cache, but keeps this cache's 589 * size to the last value set. 590 * 591 * @see edje_collection_cache_set() 592 * @see edje_collection_cache_get() 593 * 594 */ 595 EAPI void edje_collection_cache_flush (void); 596 597 /** 598 * @} 599 */ 600 601 /** 602 * @defgroup Edje_External_Group Edje External 603 * @ingroup Edje 604 * 605 * @brief This group discusses functions of the external section of Edje. 606 * 607 * The programmer can create new types for parts, that will be called generically 608 * EXTERNALS as they are not native of Edje. The developer must also create 609 * plugins that will define the meaning of each extra properties carried by 610 * these parts of type EXTERNAL. 611 * 612 * As long as there are new types properly registered with the plugins created, 613 * the user can use the parts of type EXTERNAL as all the parts of native types. 614 * 615 * @{ 616 */ 617 618 /** The possible types the parameters of an EXTERNAL part can be. 619 * 620 * @ingroup Edje_External 621 */ 622 typedef enum 623 { 624 EDJE_EXTERNAL_PARAM_TYPE_INT = 0, /**< Parameter value is an integer. */ 625 EDJE_EXTERNAL_PARAM_TYPE_DOUBLE, /**< Parameter value is a double. */ 626 EDJE_EXTERNAL_PARAM_TYPE_STRING, /**< Parameter value is a string. */ 627 EDJE_EXTERNAL_PARAM_TYPE_BOOL, /**< Parameter value is boolean. */ 628 EDJE_EXTERNAL_PARAM_TYPE_CHOICE, /**< Parameter value is one of a set of predefined string choices. */ 629 EDJE_EXTERNAL_PARAM_TYPE_MAX /**< Sentinel value to indicate last enum field during iteration */ 630 } Edje_External_Param_Type; 631 632 /** 633 * Flags that determine how a parameter may be accessed in different 634 * circumstances. 635 */ 636 typedef enum _Edje_External_Param_Flags 637 { 638 EDJE_EXTERNAL_PARAM_FLAGS_NONE = 0, /**< Property is incapable of operations, this is used to catch bogus flags. */ 639 EDJE_EXTERNAL_PARAM_FLAGS_GET = (1 << 0), /**< Property can be read/get. */ 640 EDJE_EXTERNAL_PARAM_FLAGS_SET = (1 << 1), /**< Property can be written/set. This only enables edje_object_part_external_param_set() and Embryo scripts. To enable the parameter being set from state description whenever it changes state, use #EDJE_EXTERNAL_PARAM_FLAGS_STATE. */ 641 EDJE_EXTERNAL_PARAM_FLAGS_STATE = (1 << 2), /**< Property can be set from state description. */ 642 EDJE_EXTERNAL_PARAM_FLAGS_CONSTRUCTOR = (1 << 3), /**< This property is only set once when the object is constructed using its value from "default" 0.0 state description. Setting this overrides #EDJE_EXTERNAL_PARAM_FLAGS_STATE. */ 643 EDJE_EXTERNAL_PARAM_FLAGS_REGULAR = (EDJE_EXTERNAL_PARAM_FLAGS_GET | 644 EDJE_EXTERNAL_PARAM_FLAGS_SET | 645 EDJE_EXTERNAL_PARAM_FLAGS_STATE) /**< Convenience flag that sets property as GET, SET and STATE. */ 646 } Edje_External_Param_Flags; 647 648 /** Struct that holds parameters for parts of type EXTERNAL. 649 */ 650 typedef struct _Edje_External_Param 651 { 652 const char *name; /**< The name of the parameter. */ 653 Edje_External_Param_Type type; /**< The type of the parameter. This defines 654 * which of the next three variables holds the 655 * value for it. */ 656 int i; /**< Used by both integer and boolean */ 657 double d; /**< Used by double */ 658 const char *s; /**< Used by both string and choice */ 659 } Edje_External_Param; 660 661 /** 662 * @brief Converts type identifier to string nicer representation. 663 * 664 * This may be used to debug or other informational purposes. 665 * 666 * @param type the identifier to convert. 667 * @return the string with the string representation, or @c "(unknown)". 668 */ 669 EAPI const char *edje_external_param_type_str(Edje_External_Param_Type type) EINA_PURE; 670 671 /** 672 * Helper macro to indicate an EXTERNAL's integer parameter is undefined. 673 */ 674 #define EDJE_EXTERNAL_INT_UNSET INT_MAX 675 /** 676 * Helper macro to indicate an EXTERNAL's double parameter is undefined. 677 */ 678 #define EDJE_EXTERNAL_DOUBLE_UNSET DBL_MAX 679 680 /** 681 * Struct holding information about an EXTERNAL part's parameters. 682 * 683 * When creating types to use with EXTERNAL parts, an array of this type is 684 * used to describe the different parameters the object uses. 685 * 686 * This struct holds the name, type and flags that define how and when the 687 * parameter is used, as well as information specific to each type, like the 688 * maximum or minimum value, that can be used by editors to restrict the 689 * range of values to set for each parameter. 690 */ 691 typedef struct _Edje_External_Param_Info Edje_External_Param_Info; 692 693 /** 694 * Struct holding information about an EXTERNAL part's parameters. 695 * 696 * When creating types to use with EXTERNAL parts, an array of this type is 697 * used to describe the different parameters the object uses. 698 * 699 * This struct holds the name, type and flags that define how and when the 700 * parameter is used, as well as information specific to each type, like the 701 * maximum or minimum value, that can be used by editors to restrict the 702 * range of values to set for each parameter. 703 */ 704 struct _Edje_External_Param_Info 705 { 706 const char *name; /**< Name of the parameter. */ 707 Edje_External_Param_Type type; /**< Type of the parameter. */ 708 Edje_External_Param_Flags flags; /**< Flags indicating how this parameter is 709 used. */ 710 union { 711 struct { 712 int def, /**< Default value for the parameter. */ 713 min, /**< Minimum value it can have. */ 714 max, /**< Maximum value it can have. */ 715 step; /**< Values will be a multiple of this. */ 716 } i; /**< Info about integer type parameters. Use #EDJE_EXTERNAL_INT_UNSET 717 on any of them to indicate they are not defined.*/ 718 struct { 719 double def, /**< Default value for the parameter. */ 720 min, /**< Minimum value it can have. */ 721 max, /**< Maximum value it can have. */ 722 step; /**< Values will be a multiple of this. */ 723 } d; /**< Info about double type parameters. Use 724 #EDJE_EXTERNAL_DOUBLE_UNSET on any of them to indicate they are not defined.*/ 725 struct { 726 const char *def; /**< Default value. */ 727 const char *accept_fmt; /**< Not implemented. */ 728 const char *deny_fmt; /**< Not implemented */ 729 } s; /**< Info about string type parameters. NULL indicates undefined. */ 730 struct { 731 int def; /**< Default value. */ 732 const char *false_str; /**< String shown by editors to indicate the false state. */ 733 const char *true_str; /**< String shown by editors to indicate the true state. */ 734 } b; /**< Info about boolean type parameters.*/ 735 struct { 736 const char *def; /**< Default value. */ 737 const char **choices; /* Array of strings, each represents a 738 valid value for this parameter. The 739 last element of the array must be 740 NULL. */ 741 char *(*def_get)(void *data, const Edje_External_Param_Info *info); /** return malloc() memory with the default choice, should be used if def is NULL. First parameter is Edje_External_Type::data */ 742 char **(*query)(void *data, const Edje_External_Param_Info *info); /** NULL terminated array of strings, memory is dynamically allocated and should be freed with free() for array and each element. First parameter is Edje_External_Type::data */ 743 } c; /**< Info about choice type parameters. */ 744 } info; 745 }; 746 747 #define EDJE_EXTERNAL_PARAM_INFO_INT_FULL_FLAGS(name, def, min, max, step, flags) \ 748 {name, EDJE_EXTERNAL_PARAM_TYPE_INT, flags, {.i = {def, min, max, step}}} 749 #define EDJE_EXTERNAL_PARAM_INFO_DOUBLE_FULL_FLAGS(name, def, min, max, step, flags) \ 750 {name, EDJE_EXTERNAL_PARAM_TYPE_DOUBLE, flags, {.d = {def, min, max, step}}} 751 #define EDJE_EXTERNAL_PARAM_INFO_STRING_FULL_FLAGS(name, def, accept, deny, flags) \ 752 {name, EDJE_EXTERNAL_PARAM_TYPE_STRING, flags, {.s = {def, accept, deny}}} 753 #define EDJE_EXTERNAL_PARAM_INFO_BOOL_FULL_FLAGS(name, def, false_str, true_str, flags) \ 754 {name, EDJE_EXTERNAL_PARAM_TYPE_BOOL, flags, {.b = {def, false_str, true_str}}} 755 #define EDJE_EXTERNAL_PARAM_INFO_CHOICE_FULL_FLAGS(name, def, choices, flags) \ 756 {name, EDJE_EXTERNAL_PARAM_TYPE_CHOICE, flags, {.c = {def, choices, NULL, NULL}}} 757 #define EDJE_EXTERNAL_PARAM_INFO_CHOICE_DYNAMIC_FULL_FLAGS(name, def_get, query, flags) \ 758 {name, EDJE_EXTERNAL_PARAM_TYPE_CHOICE, flags, {.c = {NULL, NULL, def_get, query}}} 759 760 #define EDJE_EXTERNAL_PARAM_INFO_INT_FULL(name, def, min, max, step) \ 761 EDJE_EXTERNAL_PARAM_INFO_INT_FULL_FLAGS(name, def, min, max, step, EDJE_EXTERNAL_PARAM_FLAGS_REGULAR) 762 #define EDJE_EXTERNAL_PARAM_INFO_DOUBLE_FULL(name, def, min, max, step) \ 763 EDJE_EXTERNAL_PARAM_INFO_DOUBLE_FULL_FLAGS(name, def, min, max, step, EDJE_EXTERNAL_PARAM_FLAGS_REGULAR) 764 #define EDJE_EXTERNAL_PARAM_INFO_STRING_FULL(name, def, accept, deny) \ 765 EDJE_EXTERNAL_PARAM_INFO_STRING_FULL_FLAGS(name, def, accept, deny, EDJE_EXTERNAL_PARAM_FLAGS_REGULAR) 766 #define EDJE_EXTERNAL_PARAM_INFO_BOOL_FULL(name, def, false_str, true_str) \ 767 EDJE_EXTERNAL_PARAM_INFO_BOOL_FULL_FLAGS(name, def, false_str, true_str, EDJE_EXTERNAL_PARAM_FLAGS_REGULAR) 768 #define EDJE_EXTERNAL_PARAM_INFO_CHOICE_FULL(name, def, choices) \ 769 EDJE_EXTERNAL_PARAM_INFO_CHOICE_FULL_FLAGS(name, def, choices, EDJE_EXTERNAL_PARAM_FLAGS_REGULAR) 770 #define EDJE_EXTERNAL_PARAM_INFO_CHOICE_DYNAMIC_FULL(name, def_get, query) \ 771 EDJE_EXTERNAL_PARAM_INFO_CHOICE_DYNAMIC_FULL_FLAGS(name, def_get, query, EDJE_EXTERNAL_PARAM_FLAGS_REGULAR) 772 773 #define EDJE_EXTERNAL_PARAM_INFO_INT_DEFAULT(name, def) \ 774 EDJE_EXTERNAL_PARAM_INFO_INT_FULL(name, def, EDJE_EXTERNAL_INT_UNSET, EDJE_EXTERNAL_INT_UNSET, EDJE_EXTERNAL_INT_UNSET) 775 #define EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT(name, def) \ 776 EDJE_EXTERNAL_PARAM_INFO_DOUBLE_FULL(name, def, EDJE_EXTERNAL_DOUBLE_UNSET, EDJE_EXTERNAL_DOUBLE_UNSET, EDJE_EXTERNAL_DOUBLE_UNSET) 777 #define EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT(name, def) \ 778 EDJE_EXTERNAL_PARAM_INFO_STRING_FULL(name, def, NULL, NULL) 779 #define EDJE_EXTERNAL_PARAM_INFO_BOOL_DEFAULT(name, def) \ 780 EDJE_EXTERNAL_PARAM_INFO_BOOL_FULL(name, def, "false", "true") 781 782 #define EDJE_EXTERNAL_PARAM_INFO_INT_DEFAULT_FLAGS(name, def, flags) \ 783 EDJE_EXTERNAL_PARAM_INFO_INT_FULL_FLAGS(name, def, EDJE_EXTERNAL_INT_UNSET, EDJE_EXTERNAL_INT_UNSET, EDJE_EXTERNAL_INT_UNSET, flags) 784 #define EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT_FLAGS(name, def, flags) \ 785 EDJE_EXTERNAL_PARAM_INFO_DOUBLE_FULL_FLAGS(name, def, EDJE_EXTERNAL_DOUBLE_UNSET, EDJE_EXTERNAL_DOUBLE_UNSET, EDJE_EXTERNAL_DOUBLE_UNSET, flags) 786 #define EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT_FLAGS(name, def, flags) \ 787 EDJE_EXTERNAL_PARAM_INFO_STRING_FULL_FLAGS(name, def, NULL, NULL, flags) 788 #define EDJE_EXTERNAL_PARAM_INFO_BOOL_DEFAULT_FLAGS(name, def, flags) \ 789 EDJE_EXTERNAL_PARAM_INFO_BOOL_FULL_FLAGS(name, def, "false", "true", flags) 790 791 #define EDJE_EXTERNAL_PARAM_INFO_INT(name) \ 792 EDJE_EXTERNAL_PARAM_INFO_INT_DEFAULT(name, 0) 793 #define EDJE_EXTERNAL_PARAM_INFO_DOUBLE(name) \ 794 EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT(name, 0.0) 795 #define EDJE_EXTERNAL_PARAM_INFO_STRING(name) \ 796 EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT(name, NULL) 797 #define EDJE_EXTERNAL_PARAM_INFO_BOOL(name) \ 798 EDJE_EXTERNAL_PARAM_INFO_BOOL_DEFAULT(name, 0) 799 800 #define EDJE_EXTERNAL_PARAM_INFO_INT_FLAGS(name, flags) \ 801 EDJE_EXTERNAL_PARAM_INFO_INT_DEFAULT_FLAGS(name, 0, flags) 802 #define EDJE_EXTERNAL_PARAM_INFO_DOUBLE_FLAGS(name, flags) \ 803 EDJE_EXTERNAL_PARAM_INFO_DOUBLE_DEFAULT_FLAGS(name, 0.0, flags) 804 #define EDJE_EXTERNAL_PARAM_INFO_STRING_FLAGS(name, flags) \ 805 EDJE_EXTERNAL_PARAM_INFO_STRING_DEFAULT_FLAGS(name, NULL, flags) 806 #define EDJE_EXTERNAL_PARAM_INFO_BOOL_FLAGS(name, flags) \ 807 EDJE_EXTERNAL_PARAM_INFO_BOOL_DEFAULT_FLAGS(name, 0, flags) 808 809 #define EDJE_EXTERNAL_PARAM_INFO_SENTINEL {NULL, 0, 0, {.s = {NULL, NULL, NULL}}} 810 811 /** Version of the EDJE External ABI used by this library .*/ 812 #define EDJE_EXTERNAL_TYPE_ABI_VERSION (3) 813 814 /** 815 * @struct _Edje_External_Type 816 * 817 * @brief Information about an external type to be used. 818 * 819 * This structure provides information on how to display and modify a 820 * third party Evas_Object in Edje. 821 * 822 * Some function pointers are not really used by Edje, but provide 823 * means for Edje users to better interact with such objects. For 824 * instance, an editor may use label_get() and icon_get() to list all 825 * registered external types. 826 * 827 * @note The function pointers provided in this structure must check 828 * for errors and invalid or out-of-range values as for 829 * performance reasons Edje will not enforce hints provided as 830 * #Edje_External_Param_Info in the member parameters_info. 831 */ 832 struct _Edje_External_Type 833 { 834 unsigned int abi_version; /**< always use: 835 * - #EDJE_EXTERNAL_TYPE_ABI_VERSION to declare. 836 * - edje_external_type_abi_version_get() to check. 837 */ 838 const char *module; /**< Name of the module that holds these definitions, 839 as used in the externals {} block of a theme 840 definition. */ 841 const char *module_name; /**< Canonical name of the module, for displaying 842 in edition programs, for example. */ 843 Evas_Object *(*add) (void *data, Evas *evas, Evas_Object *parent, const Eina_List *params, const char *part_name); /**< Creates the object to be used by Edje as the part. @p part_name is the name of the part that holds the object and can be used to forward callbacks from the object as signals from Edje. @p params is the list of #Edje_External_Param, not parsed, from the default state of the part. Parameters of type #EDJE_EXTERNAL_PARAM_FLAGS_CONSTRUCTOR should be set on 844 the object here. */ 845 void (*state_set) (void *data, Evas_Object *obj, const void *from_params, const void *to_params, float pos); /**< Called upon state changes, including the initial "default" 0.0 state. Parameters are the value returned by params_parse(). The @p pos parameter is a value between 0.0 and 1.0 indicating the position in time within the state transition. */ 846 void (*signal_emit) (void *data, Evas_Object *obj, const char *emission, const char *source); /**< Feed a signal emitted with emission originally set as part_name:signal to this object (without the "part_name:" prefix) */ 847 Eina_Bool (*param_set) (void *data, Evas_Object *obj, const Edje_External_Param *param); /**< Dynamically change a parameter of this external, called by scripts and user code. Returns @c EINA_TRUE on success */ 848 Eina_Bool (*param_get) (void *data, const Evas_Object *obj, Edje_External_Param *param); /**< Dynamically fetch a parameter of this external, called by scripts and user code. Returns @c EINA_TRUE on success. (Must check parameter name and type!) */ 849 Evas_Object *(*content_get) (void *data, const Evas_Object *obj, const char *content); /**< Dynamically fetch a sub object of this external, called by scripts and user code. Returns @c Evas_Object * on success. (Must check parameter name and type!) */ 850 void *(*params_parse) (void *data, Evas_Object *obj, const Eina_List *params); /**< Parses the list of parameters, converting into a friendly representation. Used with state_set() */ 851 void (*params_free) (void *params); /**< Free parameters parsed with params_parse() */ 852 853 /* The following callbacks aren't used by Edje itself, but by UI design 854 tools instead */ 855 const char *(*label_get) (void *data); /**< Get a label to use to identify this EXTERNAL. (For editors) */ 856 const char *(*description_get) (void *data); /**< Get a user friendly description of this EXTERNAL. (For editors) */ 857 Evas_Object *(*icon_add) (void *data, Evas *e); /**< Get an icon to use to identify this EXTERNAL. (For editors) */ 858 Evas_Object *(*preview_add) (void *data, Evas *e); /**< Get a preview of the EXTERNAL object in use. (For editors) */ 859 const char *(*translate) (void *data, const char *orig); /**< called to translate parameters_info name properties for use in user interfaces that support internationalization (i18n) (For editors) */ 860 861 Edje_External_Param_Info *parameters_info; /**< An array of #Edje_External_Param_Info describing the different parameters this EXTERNAL may have. The last element in the array must be #EDJE_EXTERNAL_PARAM_INFO_SENTINEL. */ 862 void *data; /**< Private user data that will be passed to all of the class functions. */ 863 }; 864 /** Alias for _Edje_External_Type */ 865 typedef struct _Edje_External_Type Edje_External_Type; 866 867 /** 868 * Convenience struct used to mass-register types of EXTERNAL objects. 869 * 870 * Used with edje_external_type_array_register(). 871 */ 872 struct _Edje_External_Type_Info 873 { 874 const char *name; /**< The name of the type to register. */ 875 const Edje_External_Type *info; /**< The type definition. */ 876 }; 877 878 /** Alias for _Edje_External_Type_Info */ 879 typedef struct _Edje_External_Type_Info Edje_External_Type_Info; 880 881 /** 882 * @} 883 */ 884 885 /** 886 * @defgroup Edje_External_Plugin_Development_Group Edje Development of External Plugins 887 * @ingroup Edje_External_Group 888 * 889 * @brief Functions to register, unregister EXTERNAL types and develop the plugins. 890 * 891 * This group discusses functions useful for the development of new plugins. 892 * These functions deal with the newly EXTERNAL types by registering, unregistering and manipulating them. 893 * 894 * 895 * @{ 896 */ 897 898 /** 899 * @brief Registers a type to be used by EXTERNAL parts. 900 * 901 * Parts of type EXTERNAL will call user defined functions 902 * to create and manipulate the object that's allocated in that part. This is 903 * done by expecifying in the @c source property of the part the name of the 904 * external to use, which must be one registered with this function. 905 * 906 * @param type_name Name to register and be known by edje's "source:" 907 * parameter of "type: EXTERNAL" parts. 908 * @param type_info Meta-information describing how to interact with it. 909 * 910 * @return @c EINA_TRUE on success, @c EINA_FALSE on failure (like 911 * type already registered). 912 * 913 * @see edje_external_type_array_register() 914 */ 915 EAPI Eina_Bool edje_external_type_register (const char *type_name, const Edje_External_Type *type_info); 916 917 /** 918 * @brief Unregisters a previously registered EXTERNAL type. 919 * 920 * @param type_name name to unregister. It should have been registered with 921 * edje_external_type_register() before. 922 * 923 * @return @c EINA_TRUE on success, @c EINA_FALSE on failure (like 924 * type_name did not exist). 925 * 926 * @see edje_external_type_array_unregister() 927 */ 928 EAPI Eina_Bool edje_external_type_unregister (const char *type_name); 929 930 /** 931 * @brief Registers a batch of types and their information. 932 * 933 * When several types will be registered it is recommended to use this 934 * function instead of several calls to edje_external_type_register(), as it 935 * is faster. 936 * 937 * @note The contents of the array will be referenced directly for as long as 938 * the type remains registered, so both the @c name and @c info in the 939 * @p array must be kept alive during all this period (usually, the entire 940 * program lifetime). The most common case would be to keep the array as a 941 * @c static @c const type anyway. 942 * 943 * @param array @c NULL terminated array with type name and 944 * information. Note that type name or information are 945 * referenced directly, so they must be kept alive after 946 * this function returns! 947 * 948 * @return @c EINA_TRUE on success, @c EINA_FALSE on failure (like 949 * type already registered). 950 * 951 * @see edje_external_type_register() 952 */ 953 EAPI void edje_external_type_array_register (const Edje_External_Type_Info *array); 954 955 /** 956 * @brief Unregisters a batch of given external type previously registered. 957 * 958 * @param array @c NULL terminated array, should be the same as the 959 * one used to register with edje_external_type_array_register() 960 * 961 * @see edje_external_type_unregister() 962 */ 963 EAPI void edje_external_type_array_unregister (const Edje_External_Type_Info *array); 964 965 /** 966 * @brief Returns the current ABI version for Edje_External_Type structure. 967 * 968 * Always check this number before accessing Edje_External_Type in 969 * your own software. If the number is not the same, your software may 970 * access invalid memory and crash, or just get garbage values. 971 * 972 * @warning @b NEVER, EVER define your own Edje_External_Type using the 973 * return of this function as it will change as Edje library 974 * (libedje.so) changes, but your type definition will 975 * not. Instead, use #EDJE_EXTERNAL_TYPE_ABI_VERSION. 976 * 977 * Summary: 978 * - use edje_external_type_abi_version_get() to check. 979 * - use #EDJE_EXTERNAL_TYPE_ABI_VERSION to define/declare. 980 * 981 * @return The external ABI version the Edje library was compiled with. That 982 * is, the value #EDJE_EXTERNAL_TYPE_ABI_VERSION had at that moment. 983 */ 984 EAPI unsigned int edje_external_type_abi_version_get (void) EINA_CONST; 985 986 /** 987 * 988 * @return An iterator of all the registered EXTERNAL types. 989 * 990 * Each item in the iterator is an @c Eina_Hash_Tuple which has the type 991 * of the external in the @c key and #Edje_External_Type as @c data. 992 * 993 * @code 994 * const Eina_Hash_Tuple *tuple; 995 * Eina_Iterator *itr; 996 * const Eina_List *l, *modules; 997 * const char *s; 998 * 999 * modules = edje_available_modules_get(); 1000 * EINA_LIST_FOREACH(modules, l, s) 1001 * { 1002 * if (!edje_module_load(s)) 1003 * printf("Error loading edje module: %s\n", s); 1004 * } 1005 * 1006 * itr = edje_external_iterator_get(); 1007 * EINA_ITERATOR_FOREACH(itr, tuple) 1008 * { 1009 * const char *name = tuple->key; 1010 * const Edje_External_Type *type = tuple->data; 1011 * 1012 * if ((!type) || 1013 * (type->abi_version != edje_external_type_abi_version_get())) 1014 * { 1015 * printf("Error: invalid type %p (abi: %d, expected: %d)\n", 1016 * type, type ? type->abi_version : 0, 1017 * edje_external_type_abi_version_get()); 1018 * continue; 1019 * } 1020 * 1021 * printf("%s: %s (%s) label='%s' desc='%s'\n", 1022 * name, type->module, type->module_name, 1023 * type->label_get ? type->label_get(type->data) : "", 1024 * type->description_get ? type->description_get(type->data) : ""); 1025 * } 1026 * 1027 * @endcode 1028 */ 1029 EAPI Eina_Iterator *edje_external_iterator_get (void); 1030 1031 /** 1032 * @brief Convenience function to find a specific parameter in a list of them. 1033 * 1034 * @param params The list of parameters for the external 1035 * @param key The parameter to look for 1036 * 1037 * @return The matching #Edje_External_Param or NULL if it's not found. 1038 */ 1039 EAPI Edje_External_Param *edje_external_param_find (const Eina_List *params, const char *key); 1040 1041 /** 1042 * @brief Gets the value of the given parameter of integer type. 1043 * 1044 * Look for the @p key parameter in the @p params list and return its value in 1045 * @p ret. If the parameter is found and is of type 1046 * #EDJE_EXTERNAL_PARAM_TYPE_INT, its value will be stored in the int pointed 1047 * by @p ret, returning EINA_TRUE. In any other case, the function returns 1048 * EINA_FALSE. 1049 * 1050 * @param params List of parameters where to look 1051 * @param key Name of the parameter to fetch 1052 * @param ret Int pointer where to store the value, must not be NULL. 1053 * 1054 * @return @c EINA_TRUE if the parameter was found and is of integer type, 1055 * @c EINA_FALSE otherwise. 1056 */ 1057 EAPI Eina_Bool edje_external_param_int_get (const Eina_List *params, const char *key, int *ret); 1058 1059 /** 1060 * @brief Gets the value of the given parameter of double type. 1061 * 1062 * Look for the @p key parameter in the @p params list and return its value in 1063 * @p ret. If the parameter is found and is of type 1064 * #EDJE_EXTERNAL_PARAM_TYPE_DOUBLE, its value will be stored in the double 1065 * pointed by @p ret, returning EINA_TRUE. In any other case, the function 1066 * returns EINA_FALSE. 1067 * 1068 * @param params List of parameters where to look 1069 * @param key Name of the parameter to fetch 1070 * @param ret Double pointer where to store the value, must not be NULL. 1071 * 1072 * @return @c EINA_TRUE if the parameter was found and is of double type, 1073 * @c EINA_FALSE otherwise. 1074 */ 1075 EAPI Eina_Bool edje_external_param_double_get (const Eina_List *params, const char *key, double *ret); 1076 1077 /** 1078 * @brief Gets the value of the given parameter of string type. 1079 * 1080 * Look for the @p key parameter in the @p params list and return its value in 1081 * @p ret. If the parameter is found and is of type 1082 * #EDJE_EXTERNAL_PARAM_TYPE_STRING, its value will be stored in the pointer 1083 * pointed by @p ret, returning EINA_TRUE. In any other case, the function 1084 * returns EINA_FALSE. 1085 * 1086 * The string stored in @p ret must not be freed or modified. 1087 * 1088 * @param params List of parameters where to look 1089 * @param key Name of the parameter to fetch 1090 * @param ret String pointer where to store the value, must not be NULL. 1091 * 1092 * @return @c EINA_TRUE if the parameter was found and is of string type, 1093 * @c EINA_FALSE otherwise. 1094 */ 1095 EAPI Eina_Bool edje_external_param_string_get (const Eina_List *params, const char *key, const char **ret); 1096 1097 /** 1098 * @brief Gets the value of the given parameter of boolean type. 1099 * 1100 * Look for the @p key parameter in the @p params list and return its value in 1101 * @p ret. If the parameter is found and is of type 1102 * #EDJE_EXTERNAL_PARAM_TYPE_BOOL, its value will be stored in the Eina_Bool 1103 * pointed by @p ret, returning EINA_TRUE. In any other case, the function 1104 * returns EINA_FALSE. 1105 * 1106 * @param params List of parameters where to look 1107 * @param key Name of the parameter to fetch 1108 * @param ret Eina_Bool pointer where to store the value, must not be NULL. 1109 * 1110 * @return @c EINA_TRUE if the parameter was found and is of boolean type, 1111 * @c EINA_FALSE otherwise. 1112 */ 1113 EAPI Eina_Bool edje_external_param_bool_get (const Eina_List *params, const char *key, Eina_Bool *ret); 1114 1115 /** 1116 * @brief Gets the value of the given parameter of choice type. 1117 * 1118 * Look for the @p key parameter in the @p params list and return its value in 1119 * @p ret. If the parameter is found and is of type 1120 * #EDJE_EXTERNAL_PARAM_TYPE_CHOICE, its value will be stored in the string 1121 * pointed by @p ret, returning EINA_TRUE. In any other case, the function 1122 * returns EINA_FALSE. 1123 * 1124 * The string stored in @p ret must not be freed or modified. 1125 * 1126 * @param params List of parameters where to look 1127 * @param key Name of the parameter to fetch 1128 * @param ret String pointer where to store the value, must not be NULL. 1129 * 1130 * @return EINA_TRUE if the parameter was found and is of integer type, 1131 * EINA_FALSE otherwise. 1132 */ 1133 EAPI Eina_Bool edje_external_param_choice_get (const Eina_List *params, const char *key, const char **ret); 1134 1135 /** 1136 * @brief Gets the array of parameters information about a type given its name. 1137 * 1138 * @note the type names and other strings are static, that means they are 1139 * @b NOT translated. One must use 1140 * Edje_External_Type::translate() to translate those. 1141 * 1142 * @param type_name Edje external type name 1143 * 1144 * @return the NULL terminated array, or @c NULL if type is unknown or 1145 * it does not have any parameter information. 1146 * 1147 * @see edje_external_type_get() 1148 */ 1149 EAPI const Edje_External_Param_Info *edje_external_param_info_get (const char *type_name); 1150 1151 /** 1152 * @brief Gets the #Edje_External_Type that defines an EXTERNAL type registered with 1153 * the name @p type_name. 1154 */ 1155 EAPI const Edje_External_Type *edje_external_type_get (const char *type_name); 1156 1157 /** 1158 * @} 1159 */ 1160 1161 /** 1162 * @defgroup Edje_Object_Group Edje Object 1163 * @ingroup Edje 1164 * 1165 * @brief This group discusses functions that deal with Edje layouts and its components 1166 * 1167 * An important thing to know about this group is that there is no 1168 * Edje_Object in @b code. What we refer here as object are layouts (or themes) 1169 * defined by groups, and parts, both declared in EDC files. They are of 1170 * type Evas_Object as the other native objects of Evas, but they only exist 1171 * in Edje, so that is why we are calling them "edje objects". 1172 * 1173 * With the Edje Object Group functions we can deal with layouts by managing 1174 * its aspect, content, message and signal exchange and animation, among others. 1175 * 1176 * @{ 1177 */ 1178 1179 /** 1180 * @typedef Edje_Aspect_Control 1181 * 1182 * All Edje aspect control values. 1183 * 1184 */ 1185 typedef enum _Edje_Aspect_Control 1186 { 1187 EDJE_ASPECT_CONTROL_NONE = 0, /*< None aspect control value */ 1188 EDJE_ASPECT_CONTROL_NEITHER = 1, /*< Neither aspect control value */ 1189 EDJE_ASPECT_CONTROL_HORIZONTAL = 2, /*< Horizontal aspect control value */ 1190 EDJE_ASPECT_CONTROL_VERTICAL = 3, /*< Vertical aspect control value */ 1191 EDJE_ASPECT_CONTROL_BOTH = 4 /*< Both aspect control value */ 1192 } Edje_Aspect_Control; 1193 1194 /** 1195 * @brief Gets the part name of an edje part object. 1196 * @param obj An edje part object 1197 * @return The name of the part, if the object is an edje part, or @c NULL 1198 * @note If this function returns @c NULL, @p obj was not an Edje part object 1199 * @see edje_object_part_object_get() 1200 * @since 1.10 1201 */ 1202 EAPI const char *edje_object_part_object_name_get(const Evas_Object *obj); 1203 1204 /** 1205 * @} 1206 */ 1207 1208 /** 1209 * @defgroup Edje_Object_Scale Edje Scale 1210 * @ingroup Edje_Object_Group 1211 * 1212 * @brief Functions that deal with scaling objects 1213 * 1214 * Edje allows one to build scalable interfaces. Scaling factors, 1215 * which are set to neutral (@c 1.0) values by default (no scaling, 1216 * actual sizes), are of two types: @b global and @b individual. 1217 * 1218 * Scaling affects the values of minimum/maximum @b part sizes, which 1219 * are @b multiplied by it. Font sizes are scaled, too. 1220 * 1221 * 1222 * @{ 1223 */ 1224 1225 /** 1226 * @brief Sets Edje's global scaling factor. 1227 * 1228 * @param scale The global scaling factor (the default value is @c 1.0) 1229 * 1230 * Edje's global scaling factor will affect all its objects which 1231 * hadn't their individual scaling factors altered from the default 1232 * value (which is zero). If they had it set differently, by 1233 * edje_object_scale_set(), that factor will @b override the global 1234 * one. 1235 * 1236 * @warning Only parts which, at EDC level, had the @c "scale" 1237 * property set to @c 1, will be affected by this function. Check the 1238 * complete @ref edcref "syntax reference" for EDC files. 1239 * 1240 * @see edje_scale_get(). 1241 */ 1242 EAPI void edje_scale_set (double scale); 1243 1244 /** 1245 * @brief Retrieves Edje's global scaling factor. 1246 * 1247 * @return The global scaling factor. 1248 * 1249 * This function returns Edje's global scaling factor. 1250 * 1251 * @see edje_scale_set() for more details 1252 * 1253 */ 1254 EAPI double edje_scale_get (void); 1255 1256 /** 1257 * @} 1258 */ 1259 1260 /** 1261 * @defgroup Edje_Text_Entry Edje Text Entry 1262 * @ingroup Edje_Part_Text 1263 * 1264 * @brief Functions that deal with text entries 1265 * 1266 * In Edje it's possible to use a text part as a entry so the user is 1267 * able to make inputs of text. To do so, the text part must be set 1268 * with a input panel that will work as a virtual keyboard. 1269 * 1270 * Some of effects can be applied to the entered text and also plenty 1271 * actions can be performed after any input. 1272 * 1273 * Use the functions of this section to handle the user input of text. 1274 * 1275 * 1276 * @{ 1277 */ 1278 1279 struct _Edje_Entry_Change_Info 1280 { 1281 union { 1282 struct { 1283 const char *content; 1284 size_t pos; 1285 size_t plain_length; /* Number of cursor positions represented 1286 in content. */ 1287 } insert; 1288 struct { 1289 const char *content; 1290 size_t start, end; 1291 } del; 1292 } change; 1293 Eina_Bool insert : 1; /**< True if the "change" union's "insert" is valid */ 1294 Eina_Bool merge : 1; /**< True if can be merged with the previous one. Used for example with insertion when something is already selected. */ 1295 }; 1296 1297 /** 1298 * @since 1.1.0 1299 */ 1300 typedef struct _Edje_Entry_Change_Info Edje_Entry_Change_Info; 1301 1302 /** 1303 * @typedef Edje_Text_Filter_Type 1304 * 1305 * All Edje text filters type values. 1306 */ 1307 typedef enum _Edje_Text_Filter_Type 1308 { 1309 EDJE_TEXT_FILTER_TEXT = 0, /**< Text type filter */ 1310 EDJE_TEXT_FILTER_FORMAT = 1, /**< Format type filter */ 1311 EDJE_TEXT_FILTER_MARKUP = 2 /**< Markup type filter */ 1312 } Edje_Text_Filter_Type; 1313 1314 enum 1315 { 1316 EDJE_INPUT_PANEL_LAYOUT_NORMAL_VARIATION_NORMAL, /**< The plain normal layout @since 1.12 */ 1317 EDJE_INPUT_PANEL_LAYOUT_NORMAL_VARIATION_FILENAME, /**< Filename layout. Symbols such as '/' should be disabled. @since 1.12 */ 1318 EDJE_INPUT_PANEL_LAYOUT_NORMAL_VARIATION_PERSON_NAME /**< The name of a person. @since 1.12 */ 1319 }; 1320 1321 enum 1322 { 1323 EDJE_INPUT_PANEL_LAYOUT_NUMBERONLY_VARIATION_NORMAL, /**< The plain normal number layout @since 1.8 */ 1324 EDJE_INPUT_PANEL_LAYOUT_NUMBERONLY_VARIATION_SIGNED, /**< The number layout to allow a positive or negative sign at the start @since 1.8 */ 1325 EDJE_INPUT_PANEL_LAYOUT_NUMBERONLY_VARIATION_DECIMAL, /**< The number layout to allow decimal point to provide fractional value @since 1.8 */ 1326 EDJE_INPUT_PANEL_LAYOUT_NUMBERONLY_VARIATION_SIGNED_AND_DECIMAL /**< The number layout to allow decimal point and negative sign @since 1.8 */ 1327 }; 1328 1329 enum 1330 { 1331 EDJE_INPUT_PANEL_LAYOUT_PASSWORD_VARIATION_NORMAL, /**< The normal password layout @since 1.12 */ 1332 EDJE_INPUT_PANEL_LAYOUT_PASSWORD_VARIATION_NUMBERONLY /**< The password layout to allow only number @since 1.12 */ 1333 }; 1334 1335 /** 1336 * @typedef (*Edje_Text_Filter_Cb) 1337 * @brief Callback prototype for Edje_Text_Filter 1338 * @param obj The Evas_Object to filter. 1339 * @param type The filter type. 1340 * @param text The text of the filter. 1341 */ 1342 typedef void (*Edje_Text_Filter_Cb) (void *data, Evas_Object *obj, const char *part, Edje_Text_Filter_Type type, char **text); 1343 1344 /** 1345 * @typedef (*Edje_Markup_Filter_Cb) 1346 * @brief Callback prototype for Edje_Text_Filter 1347 * @param obj The Evas_Object to filter. 1348 * @param part Edje part name. 1349 * @param text The text of the filter. 1350 */ 1351 typedef void (*Edje_Markup_Filter_Cb) (void *data, Evas_Object *obj, const char *part, char **text); 1352 1353 /** 1354 * @typedef (*Edje_Item_Provider_Cb) 1355 * @brief Callback prototype for Edje_Item_Provider 1356 * @param data some data provided by user 1357 * @param obj The Evas_Object to filter. 1358 * @param part Edje part name 1359 * @param item Item of container 1360 * @return Must be an Evas_Object. 1361 */ 1362 typedef Evas_Object *(*Edje_Item_Provider_Cb) (void *data, Evas_Object *obj, const char *part, const char *item); 1363 1364 /** 1365 * @brief Shows last character in password mode. 1366 * 1367 * @param password_show_last If TRUE enable last character show in password mode. 1368 * 1369 * This function enables last input to be visible when in password mode for few seconds 1370 * or until the next input is entered. 1371 * 1372 * The time out value is obtained by edje_password_show_last_timeout_set function. 1373 * 1374 * @see edje_password_show_last_timeout_set(). 1375 */ 1376 EAPI void edje_password_show_last_set(Eina_Bool password_show_last); 1377 1378 /** 1379 * @brief Sets the timeout value in last show password mode. 1380 * 1381 * @param password_show_last_timeout The timeout value. 1382 * 1383 * This functions sets the time out value for which the last input entered in password 1384 * mode will be visible. If the time out value is less than zero, the last input entered in password mode will be always visible. 1385 * 1386 * This value can be used only when last show mode is set in password mode. 1387 * 1388 * @see edje_password_show_last_set(). 1389 * 1390 */ 1391 EAPI void edje_password_show_last_timeout_set(double password_show_last_timeout); 1392 1393 /** 1394 * @} 1395 */ 1396 1397 /** 1398 * @defgroup Edje_Object_Color_Class Edje Class: Color 1399 * @ingroup Edje_Object_Group 1400 * 1401 * @brief Functions that deal with Color Classes 1402 * 1403 * Sometimes we want to change the color of two or more parts equally and 1404 * that's when we use color classes. 1405 * 1406 * If one or more parts are assigned with a color class, when we set color 1407 * values to this class it will cause all these parts to have their colors 1408 * multiplied by the values. Setting values to a color class at a process level 1409 * will affect all parts with that color class, while at a object level will 1410 * affect only the parts inside an specified object. 1411 * 1412 * @{ 1413 */ 1414 1415 /** 1416 * @brief Sets Edje color class. 1417 * 1418 * @param color_class 1419 * @param r Object Red value 1420 * @param g Object Green value 1421 * @param b Object Blue value 1422 * @param a Object Alpha value 1423 * @param r2 Outline Red value 1424 * @param g2 Outline Green value 1425 * @param b2 Outline Blue value 1426 * @param a2 Outline Alpha value 1427 * @param r3 Shadow Red value 1428 * @param g3 Shadow Green value 1429 * @param b3 Shadow Blue value 1430 * @param a3 Shadow Alpha value 1431 * 1432 * This function sets the color values for a process level color 1433 * class. This will cause all edje parts in the current process that 1434 * have the specified color class to have their colors multiplied by 1435 * these values. (Object level color classes set by 1436 * edje_object_color_class_set() will override the values set by this 1437 * function). 1438 * 1439 * The first color is the object, the second is the text outline, and 1440 * the third is the text shadow. (Note that the second two only apply 1441 * to text parts). 1442 * 1443 * Setting color emits a signal "color_class,set" with source being 1444 * the given color class in all objects. 1445 * 1446 * @see edje_color_class_set(). 1447 * 1448 * @note Unlike Evas, Edje colors are @b not pre-multiplied. That is, 1449 * half-transparent white is 255 255 255 128. 1450 * 1451 * @return Eina_Bool, @c EINA_TRUE on success and @c EINA_FALSE on failure. 1452 */ 1453 EAPI Eina_Bool edje_color_class_set (const char *color_class, int r, int g, int b, int a, int r2, int g2, int b2, int a2, int r3, int g3, int b3, int a3); 1454 1455 /** 1456 * @brief Gets Edje color class. 1457 * 1458 * @param color_class 1459 * @param r Object Red value 1460 * @param g Object Green value 1461 * @param b Object Blue value 1462 * @param a Object Alpha value 1463 * @param r2 Outline Red value 1464 * @param g2 Outline Green value 1465 * @param b2 Outline Blue value 1466 * @param a2 Outline Alpha value 1467 * @param r3 Shadow Red value 1468 * @param g3 Shadow Green value 1469 * @param b3 Shadow Blue value 1470 * @param a3 Shadow Alpha value 1471 * 1472 * @return @c EINA_TRUE if found or @c EINA_FALSE if not found and all 1473 * values are zeroed. 1474 * 1475 * This function gets the color values for a process level color 1476 * class. This value is the globally set and not per-object, that is, 1477 * the value that would be used by objects if they did not override with 1478 * edje_object_color_class_set(). 1479 * 1480 * The first color is the object, the second is the text outline, and 1481 * the third is the text shadow. (Note that the second two only apply 1482 * to text parts). 1483 * 1484 * @see edje_color_class_set(). 1485 * 1486 * @note Unlike Evas, Edje colors are @b not pre-multiplied. That is, 1487 * half-transparent white is 255 255 255 128. 1488 */ 1489 EAPI Eina_Bool edje_color_class_get (const char *color_class, int *r, int *g, int *b, int *a, int *r2, int *g2, int *b2, int *a2, int *r3, int *g3, int *b3, int *a3); 1490 1491 /** 1492 * @brief Deletes edje color class. 1493 * 1494 * @param color_class 1495 * 1496 * This function deletes any values at the process level for the 1497 * specified color class. 1498 * @note Deleting the color class will revert it to the 1499 * values defined in the theme file. 1500 * 1501 * Deleting the color class will emit the signal "color_class,del" 1502 * to all the Edje objects in the running program. 1503 */ 1504 EAPI void edje_color_class_del (const char *color_class); 1505 1506 /** 1507 * @brief Lists color classes. 1508 * 1509 * @return A list of color class names (strings). These strings and 1510 * the list must be free()'d by the caller. 1511 * 1512 * This function lists all color classes known about by the current 1513 * process. 1514 * 1515 */ 1516 EAPI Eina_List *edje_color_class_list (void); 1517 1518 /** 1519 * @brief Iterates over all the active class of an application. 1520 * 1521 * @return an iterator of Edje_Color_Class of the currently active color class 1522 * 1523 * This function only iterate over the Edje_Color_Class in use by 1524 * an application. 1525 * 1526 * @since 1.14 1527 */ 1528 EAPI Eina_Iterator *edje_color_class_active_iterator_new(void); 1529 1530 /** 1531 * @brief Iterates over all the color class provided by an Edje file. 1532 * 1533 * @param f The mapped edje file. 1534 * 1535 * @return an iterator of Edje_Color_Class provided by the Edje file. 1536 * 1537 * @since 1.14 1538 */ 1539 EAPI Eina_Iterator *edje_mmap_color_class_iterator_new(Eina_File *f); 1540 1541 /** 1542 * @} 1543 */ 1544 1545 /** 1546 * @defgroup Edje_Object_Size_Class Edje Class: Size 1547 * @ingroup Edje_Object_Group 1548 * 1549 * @brief Functions that deal with Size Classes 1550 * 1551 * Sometimes we want to change the size of two or more parts equally and 1552 * that's when we use size classes. 1553 * 1554 * If one or more parts are assigned with a size class, when we set attributes 1555 * (minw etc.) to this class will update all these parts with the new attributes. 1556 * Setting values to a size class at a process level will affect 1557 * all parts with that size class, while at object level will affect only 1558 * the parts inside an specified object. 1559 * 1560 * @{ 1561 */ 1562 1563 /** 1564 * @brief Sets the Edje size class. 1565 * 1566 * @param size_class The size class name 1567 * @param minw The min width 1568 * @param minh The min height 1569 * @param maxw The max width 1570 * @param maxh The max height 1571 * 1572 * @return @c EINA_TRUE on success, or @c EINA_FALSE on error 1573 * 1574 * This function updates all Edje members at the process level which 1575 * belong to this size class with the new min and max attributes. 1576 * 1577 * @see edje_size_class_get(). 1578 * 1579 * @since 1.17 1580 */ 1581 EAPI Eina_Bool edje_size_class_set (const char *size_class, Evas_Coord minw, Evas_Coord minh, Evas_Coord maxw, Evas_Coord maxh); 1582 1583 /** 1584 * @brief Gets the Edje size class. 1585 * 1586 * @param size_class The size class name 1587 * @param minw The min width 1588 * @param minh The min height 1589 * @param maxw The max width 1590 * @param maxh The max height 1591 * 1592 * @return @c EINA_TRUE on success, or @c EINA_FALSE on error 1593 * 1594 * This function gets the min and max size from the specified Edje 1595 * size class. 1596 * 1597 * @since 1.17 1598 */ 1599 EAPI Eina_Bool edje_size_class_get (const char *size_class, Evas_Coord *minw, Evas_Coord *minh, Evas_Coord *maxw, Evas_Coord *maxh); 1600 1601 /** 1602 * @brief Deletes the size class. 1603 * 1604 * @param size_class The size class name 1605 * 1606 * This function deletes any values at the process level for the 1607 * specified size class. 1608 * 1609 * @since 1.17 1610 */ 1611 EAPI void edje_size_class_del (const char *size_class); 1612 1613 /** 1614 * @brief Lists size classes. 1615 * 1616 * @return A list of size class names (strings). These strings are 1617 * stringshares and the list must be eina_stringshare_del()'ed by the caller. 1618 * 1619 * This function lists all size classes known about by the current 1620 * process. 1621 * 1622 * @since 1.17 1623 */ 1624 EAPI Eina_List *edje_size_class_list (void); 1625 1626 /** 1627 * @brief Iterates over all active classes of an application. 1628 * 1629 * @return An iterator of Edje_Size_Class of the currently active size class 1630 * 1631 * This function only iterates over the Edje_Size_Class in use by 1632 * an application. 1633 * 1634 * @since 1.17 1635 */ 1636 EAPI Eina_Iterator *edje_size_class_active_iterator_new(void); 1637 1638 /** 1639 * @brief Iterates over all size classes provided by an Edje file. 1640 * 1641 * @param f The mapped edje file. 1642 * 1643 * @return an iterator of Edje_Size_Class provided by the Edje file. 1644 * 1645 * @since 1.17 1646 */ 1647 EAPI Eina_Iterator *edje_mmap_size_class_iterator_new(Eina_File *f); 1648 1649 /** 1650 * @} 1651 */ 1652 1653 /** 1654 * @defgroup Edje_Object_Text_Class Edje Class: Text 1655 * @ingroup Edje_Object_Group 1656 * @brief Functions that deal with Text Classes. 1657 * 1658 * Sometimes we want to change the text of two or more parts equally and 1659 * that's when we use text classes. 1660 * 1661 * If one or more parts are assigned with a text class, when we set font 1662 * attributes to this class will update all these parts with the new font 1663 * attributes. Setting values to a text class at a process level will affect 1664 * all parts with that text class, while at object level will affect only 1665 * the parts inside an specified object. 1666 * 1667 * @{ 1668 */ 1669 1670 /** 1671 * @brief Sets the Edje text class. 1672 * 1673 * @param text_class The text class name 1674 * @param font The font name 1675 * @param size The font size 1676 * 1677 * @return @c EINA_TRUE on success, or @c EINA_FALSE on error 1678 * 1679 * This function updates all Edje members at the process level which 1680 * belong to this text class with the new font attributes. 1681 * If the @p size is 0 then the font size will be kept with the previous size. 1682 * If the @p size is less then 0 then the font size will be calculated in the 1683 * percentage. For example, if the @p size is -50, then the font size will be 1684 * scaled to half of the original size and if the @p size is -10 then the font 1685 * size will be scaled as much as 0.1x. 1686 * 1687 * @see edje_text_class_get(). 1688 * 1689 */ 1690 EAPI Eina_Bool edje_text_class_set (const char *text_class, const char *font, Evas_Font_Size size); 1691 1692 /** 1693 * @brief Gets the font and the font size from Edje text class. 1694 * 1695 * @param text_class The text class name 1696 * @param font The font name 1697 * @param size The font size 1698 * 1699 * @return @c EINA_TRUE on success, or @c EINA_FALSE on error 1700 * 1701 * This function gets the font and the font name from the specified Edje 1702 * text class. The font string will only be valid until the text class is 1703 * changed or edje is shut down. 1704 * @see edje_text_class_set(). 1705 * 1706 * @since 1.14 1707 */ 1708 EAPI Eina_Bool edje_text_class_get (const char *text_class, const char **font, Evas_Font_Size *size); 1709 1710 /** 1711 * @brief Deletes the text class. 1712 * 1713 * @param text_class The text class name string 1714 * 1715 * This function deletes any values at the process level for the 1716 * specified text class. 1717 * 1718 */ 1719 EAPI void edje_text_class_del (const char *text_class); 1720 1721 /** 1722 * @brief Lists text classes. 1723 * 1724 * @return A list of text class names (strings). These strings are 1725 * stringshares and the list must be free()'d by the caller. 1726 * 1727 * This function lists all text classes known about by the current 1728 * process. 1729 * 1730 */ 1731 EAPI Eina_List *edje_text_class_list (void); 1732 1733 /** 1734 * @brief Iterate over all active classes of an application. 1735 * 1736 * @return an iterator of Edje_Text_Class of the currently active text class 1737 * 1738 * This function only iterates over the Edje_Text_Class in use by 1739 * an application. 1740 * 1741 * @since 1.17 1742 * 1743 */ 1744 EAPI Eina_Iterator *edje_text_class_active_iterator_new(void); 1745 1746 /** 1747 * @brief Iterate over all text classes provided by an Edje file. 1748 * 1749 * @param f The mapped edje file. 1750 * 1751 * @return an iterator of Edje_Text_Class provided by the Edje file. 1752 * 1753 * @since 1.17 1754 * 1755 */ 1756 EAPI Eina_Iterator *edje_mmap_text_class_iterator_new(Eina_File *f); 1757 1758 /** 1759 * @} 1760 */ 1761 1762 /** 1763 * @defgroup Edje_Object_File Edje Object File 1764 * @ingroup Edje_Object_Group 1765 * 1766 * @brief Functions to deals with EDJ files. 1767 * 1768 * Layouts in Edje are usually called themes and they are 1769 * created using the EDC language. The EDC language is declarative 1770 * and must be compiled before being used. The output of this 1771 * compilation is an EDJ file, this file can be loaded by Edje, 1772 * and the result is a edje object. 1773 * 1774 * This groups of functions interact with these EDJ files, 1775 * either by loading them or retrieving information of the EDC 1776 * file about objects. 1777 * 1778 * @{ 1779 */ 1780 1781 /** 1782 * @brief Gets a list of groups in an edje mapped file. 1783 * @param f The mapped file 1784 * 1785 * @return The Eina_List of group names (char *) 1786 * 1787 * Note: the list must be freed using edje_mmap_collection_list_free() 1788 * when you are done with it. 1789 */ 1790 EAPI Eina_List *edje_mmap_collection_list(Eina_File *f); 1791 1792 /** 1793 * @brief Frees file collection list. 1794 * @param lst The Eina_List of groups 1795 * 1796 * Frees the list returned by edje_mmap_collection_list(). 1797 */ 1798 EAPI void edje_mmap_collection_list_free(Eina_List *lst); 1799 1800 /** 1801 * @brief Determines whether a group matching glob exists in an edje mapped file. 1802 * @param f The mapped file 1803 * @param glob A glob to match on 1804 * 1805 * @return @c 1 if a match is found, @c 0 otherwise 1806 */ 1807 EAPI Eina_Bool edje_mmap_group_exists(Eina_File *f, const char *glob); 1808 1809 /** 1810 * @brief Determines whether a group have 3D Scene. 1811 * @param f The mapped file 1812 * @param group The group name 1813 * 1814 * @return @c 1 if a Scene is found is found, @c 0 otherwise 1815 * 1816 * @deprecated 1817 * @since 1.18 1818 */ 1819 EINA_DEPRECATED EAPI Eina_Bool edje_mmap_3d_has(Eina_File *f, const char *group); 1820 1821 /** 1822 * @brief Iterates over all the opened Edje files. 1823 * 1824 * @return an iterator of Eina_File for all currently open Edje files. 1825 * 1826 * @since 1.14 1827 */ 1828 EAPI Eina_Iterator *edje_file_iterator_new(void); 1829 1830 /** 1831 * @brief Gets a list of groups in an edje file. 1832 * @param file The path to the edje file 1833 * 1834 * @return The Eina_List of group names (char *) 1835 * @see edje_mmap_collection_list() 1836 * 1837 * Note: the list must be freed using edje_file_collection_list_free() 1838 * when you are done with it. 1839 * 1840 * @see edje_mmap_group_exists() 1841 */ 1842 EAPI Eina_List *edje_file_collection_list (const char *file); 1843 1844 /** 1845 * @brief Frees file collection list. 1846 * @param lst The Eina_List of groups 1847 * 1848 * Frees the list returned by edje_file_collection_list(). 1849 */ 1850 EAPI void edje_file_collection_list_free (Eina_List *lst); 1851 1852 /** 1853 * @brief Determines whether a group matching glob exists in an edje file. 1854 * @param file The file path 1855 * @param glob A glob to match on 1856 * 1857 * @return @c 1 if a match is found, @c 0 otherwise 1858 */ 1859 EAPI Eina_Bool edje_file_group_exists (const char *file, const char *glob); 1860 1861 /** 1862 * @} 1863 */ 1864 1865 /** 1866 * @defgroup Edje_Object_Animation Edje Object Animation 1867 * @ingroup Edje_Object_Group 1868 * @brief Functions that deal with animations. 1869 * 1870 * Edje has the ability to animate objects. One can start, stop, play, 1871 * pause, freeze, and thaw edje animations using the functions of this section. 1872 * 1873 * @{ 1874 */ 1875 1876 /** 1877 * @typedef Edje_Tween_Mode 1878 * 1879 * Available tween mode for edje animations. 1880 */ 1881 typedef enum _Edje_Tween_Mode 1882 { 1883 EDJE_TWEEN_MODE_NONE = 0, /**< None tween mode value */ 1884 EDJE_TWEEN_MODE_LINEAR = 1, /**< Linear tween mode value */ 1885 EDJE_TWEEN_MODE_SINUSOIDAL = 2, /**< Sinusoidal tween mode value */ 1886 EDJE_TWEEN_MODE_ACCELERATE = 3, /**< Accelerate tween mode value */ 1887 EDJE_TWEEN_MODE_DECELERATE = 4, /**< Decelerate tween mode value */ 1888 EDJE_TWEEN_MODE_ACCELERATE_FACTOR = 5, /**< Accelerate factor tween mode value */ 1889 EDJE_TWEEN_MODE_DECELERATE_FACTOR = 6, /**< Decelerate factor tween mode value */ 1890 EDJE_TWEEN_MODE_SINUSOIDAL_FACTOR = 7, /**< Sinusoidal factor tween mode value */ 1891 EDJE_TWEEN_MODE_DIVISOR_INTERP = 8, /**< Divisor iterp tween mode value */ 1892 EDJE_TWEEN_MODE_BOUNCE = 9, /**< Bounce tween mode value */ 1893 EDJE_TWEEN_MODE_SPRING = 10, /**< Spring tween mode value */ 1894 EDJE_TWEEN_MODE_CUBIC_BEZIER = 11, /**< Cubic Bezier tween mode value */ 1895 EDJE_TWEEN_MODE_LAST = 12, /**< Last tween mode value */ 1896 EDJE_TWEEN_MODE_MASK = 0xff, /**< Mask tween mode value */ 1897 EDJE_TWEEN_MODE_OPT_FROM_CURRENT = (1 << 31) /**< Options from current tween mode value */ 1898 } Edje_Tween_Mode; 1899 1900 /** 1901 * @typedef Edje_Action_Type 1902 * 1903 * All actions available in Edje programs. 1904 * 1905 */ 1906 typedef enum _Edje_Action_Type 1907 { 1908 EDJE_ACTION_TYPE_NONE = 0, /**< None action value */ 1909 EDJE_ACTION_TYPE_STATE_SET = 1, /**< State set action value */ 1910 EDJE_ACTION_TYPE_ACTION_STOP = 2, /**< Action stop action value */ 1911 EDJE_ACTION_TYPE_SIGNAL_EMIT = 3, /**< Signal emit action value */ 1912 EDJE_ACTION_TYPE_DRAG_VAL_SET = 4, /**< Drag val set action value */ 1913 EDJE_ACTION_TYPE_DRAG_VAL_STEP = 5, /**< Drag val step action value */ 1914 EDJE_ACTION_TYPE_DRAG_VAL_PAGE = 6, /**< Drag val page action value */ 1915 EDJE_ACTION_TYPE_SCRIPT = 7, /**< Script action value */ 1916 EDJE_ACTION_TYPE_FOCUS_SET = 8, /**< Focus set action value */ 1917 EDJE_ACTION_TYPE_RESERVED00 = 9, /**< Reversed do action value */ 1918 EDJE_ACTION_TYPE_FOCUS_OBJECT = 10, /**< Focus object action value */ 1919 EDJE_ACTION_TYPE_PARAM_COPY = 11, /**< Param copy action value */ 1920 EDJE_ACTION_TYPE_PARAM_SET = 12, /**< Param set action value */ 1921 EDJE_ACTION_TYPE_SOUND_SAMPLE = 13, /**< @since 1.1 @brief Sound sample action value */ 1922 EDJE_ACTION_TYPE_SOUND_TONE = 14, /**< @since 1.1 @brief Sound tone action value */ 1923 EDJE_ACTION_TYPE_PHYSICS_IMPULSE = 15, /**< @since 1.8 @brief Physics impulse action value */ 1924 EDJE_ACTION_TYPE_PHYSICS_TORQUE_IMPULSE = 16, /**< @since 1.8 @brief Physics torque impulse action value */ 1925 EDJE_ACTION_TYPE_PHYSICS_FORCE = 17, /**< @since 1.8 @brief Physics force action value */ 1926 EDJE_ACTION_TYPE_PHYSICS_TORQUE = 18, /**< @since 1.8 @brief Physics torque action value */ 1927 EDJE_ACTION_TYPE_PHYSICS_FORCES_CLEAR = 19, /**< @since 1.8 @brief Physics forces clear action value */ 1928 EDJE_ACTION_TYPE_PHYSICS_VEL_SET = 20, /**< @since 1.8 @brief Physics velocity set action value */ 1929 EDJE_ACTION_TYPE_PHYSICS_ANG_VEL_SET = 21, /**< @since 1.8 @brief Physics angle velocity set action value */ 1930 EDJE_ACTION_TYPE_PHYSICS_STOP = 22, /**< @since 1.8 @brief Physics stop action value */ 1931 EDJE_ACTION_TYPE_PHYSICS_ROT_SET = 23, /**< @since 1.8 @brief Physics rotation set action value */ 1932 EDJE_ACTION_TYPE_VIBRATION_SAMPLE = 24, /**< @since 1.10 @brief vibration sample action value */ 1933 EDJE_ACTION_TYPE_MO = 25, /**< @since 1.15 @brief Mo action value */ 1934 EDJE_ACTION_TYPE_VG_ANIM_STOP = 26, /** @since 1.24 @brief Vector animation stop action value */ 1935 EDJE_ACTION_TYPE_VG_ANIM_PAUSE = 27, /** @since 1.24 @brief Vector animation pause action value */ 1936 EDJE_ACTION_TYPE_VG_ANIM_RESUME = 28, /** @since 1.24 @brief Vector animation resume action value */ 1937 EDJE_ACTION_TYPE_VG_ANIM_PLAY = 29, /** @since 1.24 @brief Vector animation play action value */ 1938 EDJE_ACTION_TYPE_VG_ANIM_REWIND = 30, /** @since 1.24 @brief Vector animation rewind action value */ 1939 EDJE_ACTION_TYPE_VG_ANIM_LOOP = 31, /** @since 1.24 @brief Vector animation loop value */ 1940 EDJE_ACTION_TYPE_LAST = 32 /**< Last action value */ 1941 } Edje_Action_Type; 1942 1943 /** 1944 * @brief Sets edje transitions' frame time. 1945 * 1946 * @param t The frame time, in seconds. Default value is 1/30. 1947 * 1948 * This function sets the edje built-in animations' frame time (thus, 1949 * affecting their resolution) by calling 1950 * ecore_animator_frametime_set(). This frame time can be retrieved 1951 * with edje_frametime_get(). 1952 * 1953 * @see edje_frametime_get() 1954 * 1955 */ 1956 EAPI void edje_frametime_set (double t); 1957 1958 /** 1959 * @brief Gets edje transitions' frame time. 1960 * 1961 * @return The frame time, in seconds. 1962 * 1963 * This function returns the edje frame time set by 1964 * edje_frametime_set() or the default value 1/30. 1965 * 1966 * @see edje_frametime_set() 1967 * 1968 */ 1969 EAPI double edje_frametime_get (void); 1970 1971 /** 1972 * @brief Freezes Edje objects. 1973 * 1974 * This function freezes all Edje animations in the current process. 1975 * 1976 * @note: for freeze a specific object @see edje_object_freeze(). 1977 * 1978 * @see edje_thaw() 1979 * 1980 */ 1981 EAPI void edje_freeze (void); 1982 1983 /** 1984 * @brief Thaws Edje objects. 1985 * 1986 * This function thaws all Edje animations in the current process. 1987 * 1988 * @note for thaw a specific object @see edje_object_thaw(). 1989 * 1990 * @see edje_freeze() 1991 * 1992 */ 1993 EAPI void edje_thaw (void); 1994 1995 /** 1996 * @brief Sets Edje language. 1997 * 1998 * @param locale The locale specifier. 1999 * 2000 * This function sets the given language. 2001 * 2002 * @note: emits signal edje,language,"locale". 2003 * 2004 * @since 1.15 2005 */ 2006 EAPI void edje_language_set (const char *locale); 2007 2008 /** 2009 * @brief Sets edje transition duration factor. 2010 * 2011 * @param scale The edje transition's duration factor (the default value is @c 1.0) 2012 * 2013 * This function sets the edje transition duration factor 2014 * It will affect the speed of transitions 2015 * which had the @c use_duration_factor property set to @1. 2016 * The default value of @c use_duration_factor property is @c zero, 2017 * but can be changed by @p "USE_DURATION_FACTOR 1" or @p "USE_DURATION_FACTOR 0" 2018 * as parameter of @c "TRANSITION" property at EDC level. 2019 * If the parameter is @p "USE_DURATION_FACTOR 0" or not mentioned about @p "USE_DURATION_FACTOR", 2020 * the duration of transition keeps original duration 2021 * 2022 * @warning The transition's duration factor cannot be set on each translation. 2023 * If you use this function, it will affect transitions globally 2024 * 2025 * @see edje_transition_duration_factor_get() 2026 * 2027 * @since 1.15 2028 */ 2029 EAPI void edje_transition_duration_factor_set (double scale); 2030 2031 /** 2032 * @brief Retrieves transitions duration factor. 2033 * 2034 * @return The edje transition duration factor 2035 * 2036 * This function returns the edje transition duration factor. 2037 * 2038 * @see edje_transition_duration_set() for more details 2039 * 2040 * @since 1.15 2041 * 2042 */ 2043 EAPI double edje_transition_duration_factor_get (void); 2044 2045 /** 2046 * @} 2047 */ 2048 2049 /** 2050 * @defgroup Edje_Object_Geometry_Group Edje Object Geometry 2051 * @ingroup Edje_Object_Group 2052 * 2053 * @brief Functions that deal with object's geometry. 2054 * 2055 * By geometry we mean size and position. So in this groups there are 2056 * functions to manipulate object's geometry or retrieve information 2057 * about it. 2058 * 2059 * Keep in mind that by changing an object's geometry, it may affect 2060 * the appearance in the screen of the parts inside. Most times 2061 * that is what you want. 2062 * 2063 * @{ 2064 */ 2065 /** 2066 * @} 2067 */ 2068 2069 /** 2070 * @defgroup Edje_Object_Part Edje Part 2071 * @ingroup Edje_Object_Group 2072 * 2073 * @brief Functions that deal with layout components 2074 * 2075 * Parts are layout components, but as a layout, they are objects too. 2076 * 2077 * There are several types of parts, these types can be divided into two 2078 * main categories, the first being containers. Containers are parts 2079 * that are in effect a group of elements. The second group is that of 2080 * the elements, these part types may not contain others. 2081 * 2082 * This section has some functions specific for some types and others that 2083 * could be applied to any type. 2084 * 2085 * @{ 2086 */ 2087 2088 /** 2089 * @defgroup Edje_Part_Text Edje Text Part 2090 * @ingroup Edje_Object_Part 2091 * 2092 * @brief Functions that deal with parts of type text 2093 * 2094 * Text is an element type for parts. It's basic functionality is to 2095 * display a string on the layout, but a lot more things can be done 2096 * with texts, like string selection, setting the cursor and include 2097 * a input panel, where one can set a virtual keyboard to handle 2098 * keyboard entry easily. 2099 * 2100 * @{ 2101 */ 2102 2103 #define EDJE_TEXT_EFFECT_MASK_BASIC 0xf 2104 #define EDJE_TEXT_EFFECT_BASIC_SET(x, s) \ 2105 do { x = ((x) & ~EDJE_TEXT_EFFECT_MASK_BASIC) | (s); } while (0) 2106 2107 #define EDJE_TEXT_EFFECT_MASK_SHADOW_DIRECTION (0x7 << 4) 2108 #define EDJE_TEXT_EFFECT_SHADOW_DIRECTION_SET(x, s) \ 2109 do { x = ((x) & ~EDJE_TEXT_EFFECT_MASK_SHADOW_DIRECTION) | (s); } while (0) 2110 2111 /** 2112 * @typedef Edje_Text_Effect 2113 * 2114 * All possible text effects in Edje. 2115 */ 2116 typedef enum _Edje_Text_Effect 2117 { 2118 EDJE_TEXT_EFFECT_NONE = 0, /**< None text effect value */ 2119 EDJE_TEXT_EFFECT_PLAIN = 1, /**< Plain text effect value */ 2120 EDJE_TEXT_EFFECT_OUTLINE = 2, /**< Outline text effect value */ 2121 EDJE_TEXT_EFFECT_SOFT_OUTLINE = 3, /**< Soft outline text effect value */ 2122 EDJE_TEXT_EFFECT_SHADOW = 4, /**< Shadown text effect value */ 2123 EDJE_TEXT_EFFECT_SOFT_SHADOW = 5, /**< Soft shadow text effect value */ 2124 EDJE_TEXT_EFFECT_OUTLINE_SHADOW = 6, /**< Outline shadow text effect value */ 2125 EDJE_TEXT_EFFECT_OUTLINE_SOFT_SHADOW = 7, /**< Outline soft shadow text effect value */ 2126 EDJE_TEXT_EFFECT_FAR_SHADOW = 8, /**< Far shadow text effect value */ 2127 EDJE_TEXT_EFFECT_FAR_SOFT_SHADOW = 9, /**< Far soft shadow text effect value */ 2128 EDJE_TEXT_EFFECT_GLOW = 10, /**< Glow text effect value */ 2129 2130 EDJE_TEXT_EFFECT_LAST = 11, /**< Last text effect value */ 2131 2132 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_BOTTOM_RIGHT = (0x0 << 4), /**< Bottom right shadow direction value */ 2133 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_BOTTOM = (0x1 << 4), /**< Bottom shadow direction value */ 2134 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_BOTTOM_LEFT = (0x2 << 4), /**< Bottom left shadow direction value */ 2135 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_LEFT = (0x3 << 4), /**< Left shadow direction value */ 2136 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_TOP_LEFT = (0x4 << 4), /**< Top left shadow direction value */ 2137 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_TOP = (0x5 << 4), /**< Top shadow direction value */ 2138 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_TOP_RIGHT = (0x6 << 4), /**< Top right shadow direction value */ 2139 EDJE_TEXT_EFFECT_SHADOW_DIRECTION_RIGHT = (0x7 << 4) /**< right shadow direction value */ 2140 } Edje_Text_Effect; 2141 2142 /** 2143 * @defgroup Edje_Text_Selection Edje Text Selection 2144 * @ingroup Edje_Part_Text 2145 * 2146 * @brief Functions that deal with selection in text parts. 2147 * 2148 * Selection is a known functionality for texts in the whole computational 2149 * world. It is a block of text marked for further manipulation. 2150 * 2151 * Edje is responsible for handling this functionality through the 2152 * following functions. 2153 * 2154 * @{ 2155 */ 2156 /** 2157 * @} 2158 */ 2159 2160 /** 2161 * @defgroup Edje_Text_Cursor Edje Text Cursor 2162 * @ingroup Edje_Part_Text 2163 * 2164 * @brief Functions that deal with cursor in text parts. 2165 * 2166 * Cursor is a known functionality for texts in the whole computational 2167 * world. It marks a position in the text from where one may want 2168 * to make a insertion, deletion or selection. 2169 * 2170 * Edje is responsible for handling this functionality through the 2171 * following functions. 2172 * 2173 * @{ 2174 */ 2175 2176 /** 2177 * @} 2178 */ 2179 2180 /** 2181 * @} 2182 */ 2183 2184 /** 2185 * @defgroup Edje_Part_Swallow Edje Swallow Part 2186 * @ingroup Edje_Object_Part 2187 * 2188 * @brief Functions that deal with parts of type swallow and swallowed objects. 2189 * 2190 * A important feature of Edje is to be able to create Evas_Objects 2191 * in code and place them in a layout. And that is what swallowing 2192 * is all about. 2193 * 2194 * Swallow parts are place holders defined in the EDC file for 2195 * objects that one may want to include in the layout later, or for 2196 * objects that are not native of Edje. In this last case, Edje will 2197 * only treat the Evas_Object properties of the swallowed objects. 2198 * 2199 * 2200 * @{ 2201 */ 2202 2203 /** 2204 * @} 2205 */ 2206 2207 /** 2208 * @defgroup Edje_Part_Box Edje Box Part 2209 * @ingroup Edje_Object_Part 2210 * 2211 * @brief Functions that deal with parts of type box. 2212 * 2213 * Box is a container type for parts, that means it can contain 2214 * other parts. 2215 * 2216 * @{ 2217 */ 2218 2219 /** 2220 * @brief Registers a custom layout to be used in edje boxes. 2221 * 2222 * @param name The name of the layout 2223 * @param func The function defining the layout 2224 * @param layout_data_get This function gets the custom data pointer 2225 * for func 2226 * @param layout_data_free Passed to func to free its private data 2227 * when needed 2228 * @param free_data Frees data 2229 * @param data Private pointer passed to layout_data_get 2230 * 2231 * This function registers custom layouts that can be referred from 2232 * themes by the registered name. The Evas_Object_Box_Layout 2233 * functions receive two pointers for internal use, one being private 2234 * data, and the other the function to free that data when it's not 2235 * longer needed. From Edje, this private data will be retrieved by 2236 * calling layout_data_get, and layout_data_free will be the free 2237 * function passed to func. layout_data_get will be called with data 2238 * as its parameter, and this one will be freed by free_data whenever 2239 * the layout is unregistered from Edje. 2240 */ 2241 EAPI void edje_box_layout_register (const char *name, Evas_Object_Box_Layout func, void *(*layout_data_get)(void *), void (*layout_data_free)(void *), void (*free_data)(void *), void *data); 2242 2243 /** 2244 * @} 2245 */ 2246 2247 /** 2248 * @defgroup Edje_Part_Table Edje Table Part 2249 * @ingroup Edje_Object_Part 2250 * 2251 * @brief Functions that deal with parts of type table. 2252 * 2253 * Table is a container type for parts, that means it can contain 2254 * other parts. 2255 * 2256 * @{ 2257 */ 2258 2259 /** 2260 * @typedef Edje_Object_Table_Homogeneous_Mode 2261 * 2262 * Table homogeneous modes. 2263 * 2264 */ 2265 typedef enum _Edje_Object_Table_Homogeneous_Mode 2266 { 2267 EDJE_OBJECT_TABLE_HOMOGENEOUS_NONE = 0, /*< None homogeneous mode */ 2268 EDJE_OBJECT_TABLE_HOMOGENEOUS_TABLE = 1, /*< Table homogeneous mode */ 2269 EDJE_OBJECT_TABLE_HOMOGENEOUS_ITEM = 2 /*< Item homogeneous mode */ 2270 } Edje_Object_Table_Homogeneous_Mode; 2271 2272 /** 2273 * @} 2274 */ 2275 2276 /** 2277 * @} 2278 */ 2279 2280