1 /** 2 * @brief Instantiates a new Edje object. 3 * 4 * @param evas A valid Evas handle, the canvas to place the new object 5 * in 6 * @return A handle to the new object created, or @c NULL on errors. 7 * 8 * This function creates a new Edje smart object, returning its @c 9 * Evas_Object handle. An Edje object is useless without a (source) 10 * file set to it, so you'd most probably call edje_object_file_set() 11 * afterwards, like in: 12 * @code 13 * Evas_Object *edje; 14 * 15 * edje = edje_object_add(canvas); 16 * if (!edje) 17 * { 18 * fprintf(stderr, "could not create edje object!\n"); 19 * return NULL; 20 * } 21 * 22 * if (!edje_object_file_set(edje, "theme.edj", "group_name")) 23 * { 24 * int err = edje_object_load_error_get(edje); 25 * const char *errmsg = edje_load_error_str(err); 26 * fprintf(stderr, "could not load 'group_name' from theme.edj: %s", 27 * errmsg); 28 * 29 * evas_object_del(edje); 30 * return NULL; 31 * } 32 * 33 * @endcode 34 * 35 * @note You can get a callback every time edje re-calculates the object 36 * (either due to animation or some kind of signal or input). This is called 37 * in-line just after the recalculation has occurred. It is a good idea not 38 * to go and delete or alter the object inside this callbacks, simply make 39 * a note that the recalculation has taken place and then do something about 40 * it outside the callback. To register a callback use code like: 41 * 42 * @code 43 * evas_object_smart_callback_add(edje_obj, "recalc", my_cb, my_cb_data); 44 * @endcode 45 * 46 * @see evas_object_smart_callback_add() 47 * 48 * @note Before creating the first Edje object in your code, remember 49 * to initialize the library, with edje_init(), or unexpected behavior 50 * might occur. 51 * 52 * @ingroup Edje_Object_Group 53 * 54 */ 55 EAPI Evas_Object *edje_object_add (Evas *evas); 56 57 /** 58 * @brief Preloads the images on the Edje Object in the background. 59 * 60 * This function requests the preload of all data images (on the given object) 61 * in the background. The work is queued before being processed (because there 62 * might be other pending requests of this type). It emits a signal 63 * "preload,done" when finished. 64 * 65 * @note Use @c true on scenarios where you don't need the image data preloaded 66 * anymore. 67 * 68 * @param[in] obj The object. 69 * @param[in] cancel @c false will add it the preloading work queue, @c true 70 * will remove it (if it was issued before). 71 * 72 * @return @c false if obj was not a valid Edje object otherwise @c true 73 * 74 * @ingroup Edje_Object_Group 75 * 76 */ 77 EAPI Eina_Bool edje_object_preload(Evas_Object *obj, Eina_Bool cancel); 78 79 /** 80 * @brief Adds a callback for an arriving Edje signal, emitted by a given Edje 81 * object. 82 * 83 * Edje signals are one of the communication interfaces between code and a 84 * given Edje object's theme. With signals, one can communicate two string 85 * values at a time, which are: - "emission" value: the name of the signal, in 86 * general - "source" value: a name for the signal's context, in general 87 * 88 * Though there are those common uses for the two strings, one is free to use 89 * them however they like. 90 * 91 * Signal callback registration is powerful, in the way that blobs may be used 92 * to match multiple signals at once. All the "*?[\" set of @c fnmatch() 93 * operators can be used, both for emission and source. 94 * 95 * Edje has internal signals it will emit, automatically, on various actions 96 * taking place on group parts. For example, the mouse cursor being moved, 97 * pressed, released, etc., over a given part's area, all generate individual 98 * signals. 99 * 100 * By using something like edje_object_signal_callback_add(obj, "mouse,down,*", 101 * "button.*", signal_cb, NULL); being @ref "button.*" the pattern for the 102 * names of parts implementing buttons on an interface, you'd be registering 103 * for notifications on events of mouse buttons being pressed down on either of 104 * those parts (those events all have the @"mouse,down," common prefix on their 105 * names, with a suffix giving the button number). The actual emission and 106 * source strings of an event will be passed in as the emission and source 107 * parameters of the callback function (e.g. "mouse,down,2" and 108 * @"button.close"), for each of those events. 109 * 110 * @note See @ref edcref "the syntax" for EDC files See also 111 * @ref edje_object_signal_emit() on how to emits Edje signals from code to a 112 * an object @ref edje_object_signal_callback_del_full() 113 * 114 * @param[in] emission The signal's "emission" string 115 * @param[in] source The signal's "source" string 116 * @param[in] func The callback function to be executed when the signal is 117 * emitted. 118 * @param[in] data A pointer to data to pass in to func. 119 * 120 * @ingroup Edje_Object_Group 121 * 122 */ 123 EAPI void edje_object_signal_callback_add(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data); 124 125 /** 126 * @brief Sends/emits an Edje signal to a given Edje object 127 * 128 * This function sends a signal to the object obj. An Edje program, at obj's 129 * EDC specification level, can respond to a signal by having declared matching 130 * @'signal' and @'source' fields on its block (see @ref edcref "the syntax" 131 * for EDC files). 132 * 133 * See also @ref edje_object_signal_callback_add() for more on Edje signals. 134 * 135 * @param[in] emission The signal's "emission" string 136 * @param[in] source The signal's "source" string 137 * 138 * @ingroup Edje_Object_Group 139 * 140 */ 141 EAPI void edje_object_signal_emit(Evas_Object *obj, const char *emission, const char *source); 142 143 /** 144 * @brief Removes a signal-triggered callback from an object. 145 * 146 * @param obj A valid Evas_Object handle. 147 * @param emission The emission string. 148 * @param source The source string. 149 * @param func The callback function. 150 * @return The data pointer 151 * 152 * This function removes a callback, previously attached to the 153 * emission of a signal, from the object @a obj. The parameters @a 154 * emission, @a source and @a func must match exactly those passed to 155 * a previous call to edje_object_signal_callback_add(). The data 156 * pointer that was passed to this call will be returned. 157 * 158 * @see edje_object_signal_callback_add(). 159 * @see edje_object_signal_callback_del_full(). 160 * 161 * @ingroup Edje_Object_Group 162 * 163 */ 164 EAPI void *edje_object_signal_callback_del (Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func); 165 166 /** 167 * @brief Unregisters/deletes a callback set for an arriving Edje 168 * signal, emitted by a given Edje object. 169 * 170 * @param obj A handle to an Edje object 171 * @param emission The signal's "emission" string 172 * @param source The signal's "source" string 173 * @param func The callback function passed on the callback's 174 * registration 175 * @param data The pointer given to be passed as data to @p func 176 * @return @p data on success, or @c NULL on errors (or if @p data 177 * had this value) 178 * 179 * This function removes a callback, previously attached to the 180 * emission of a signal, from the object @a obj. The parameters 181 * @a emission, @a source, @a func and @a data must match exactly those 182 * passed to a previous call to edje_object_signal_callback_add(). The 183 * data pointer that was passed to this call will be returned. 184 * 185 * @see edje_object_signal_callback_add(). 186 * @see edje_object_signal_callback_del(). 187 * 188 * @ingroup Edje_Object_Group 189 * 190 */ 191 EAPI void *edje_object_signal_callback_del_full(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func, void *data); 192 193 /** Edje file loading error codes one can get - see edje_load_error_str() too. */ 194 typedef enum 195 { 196 EDJE_LOAD_ERROR_NONE = 0, /**< No error happened, the loading was successful */ 197 EDJE_LOAD_ERROR_GENERIC = 1, /**< A generic error happened during the loading */ 198 EDJE_LOAD_ERROR_DOES_NOT_EXIST = 2, /**< The file pointed to did not exist */ 199 EDJE_LOAD_ERROR_PERMISSION_DENIED = 3, /**< Permission to read the given file was denied */ 200 EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED = 4, /**< Resource allocation failed during the loading */ 201 EDJE_LOAD_ERROR_CORRUPT_FILE = 5, /**< The file pointed to was corrupt */ 202 EDJE_LOAD_ERROR_UNKNOWN_FORMAT = 6, /**< The file pointed to had an unknown format */ 203 EDJE_LOAD_ERROR_INCOMPATIBLE_FILE = 7, /**< The file pointed to is incompatible, i.e., it doesn't 204 * match the library's current version's format */ 205 EDJE_LOAD_ERROR_UNKNOWN_COLLECTION = 8, /**< The group/collection set to load 206 * from was not found in the file */ 207 EDJE_LOAD_ERROR_RECURSIVE_REFERENCE = 9 /**< The group/collection set to load from had 208 * <b>recursive references</b> on its components */ 209 } Edje_Load_Error; 210 211 /** 212 * @brief Gets the (last) file loading error for a given Edje object 213 * 214 * This function is meant to be used after an Edje EDJ file loading, what takes 215 * place with the edje_object_file_set() function. If that function does not 216 * return @c true, one should check for the reason of failure with this one. 217 * 218 * @ref edje_load_error_str() 219 * 220 * @return The Edje loading error, one of: - #EDJE_LOAD_ERROR_NONE - 221 * #EDJE_LOAD_ERROR_GENERIC - #EDJE_LOAD_ERROR_DOES_NOT_EXIST - 222 * #EDJE_LOAD_ERROR_PERMISSION_DENIED - 223 * #EDJE_LOAD_ERROR_RESOURCE_ALLOCATION_FAILED - #EDJE_LOAD_ERROR_CORRUPT_FILE 224 * - #EDJE_LOAD_ERROR_UNKNOWN_FORMAT - #EDJE_LOAD_ERROR_INCOMPATIBLE_FILE - 225 * #EDJE_LOAD_ERROR_UNKNOWN_COLLECTION - #EDJE_LOAD_ERROR_RECURSIVE_REFERENCE 226 * 227 * @ingroup Edje_Object_Group 228 * 229 */ 230 EAPI Edje_Load_Error edje_object_load_error_get(const Evas_Object *obj); 231 232 /** 233 * @brief Converts the given Edje file load error code into a string 234 * describing it in English. 235 * 236 * @param error the error code, a value in ::Edje_Load_Error. 237 * @return Always returns a valid string. If the given @p error is not 238 * supported, <code>"Unknown error"</code> is returned. 239 * 240 * edje_object_file_set() is a function which sets an error value, 241 * afterwards, which can be fetched with 242 * edje_object_load_error_get(). The function in question is meant 243 * to be used in conjunction with the latter, for pretty-printing any 244 * possible error cause. 245 * 246 * @ingroup Edje_Object_Group 247 * 248 */ 249 EAPI const char *edje_load_error_str (Edje_Load_Error error); 250 251 /** 252 * @brief Retrieves the geometry of a given Edje part, in a given Edje object's 253 * group definition, relative to the object's area. 254 * 255 * This function gets the geometry of an Edje part within its group. The x and 256 * y coordinates are relative to the top left corner of the whole obj object's 257 * area. 258 * 259 * @note Use @c null pointers on the geometry components you're not interested 260 * in: they'll be ignored by the function. 261 * 262 * @note On failure, this function will make all non-$null geometry pointers' 263 * pointed variables be set to zero. 264 * 265 * @param[in] part The Edje part's name 266 * @param[out] x A pointer to a variable where to store the part's x coordinate 267 * @param[out] y A pointer to a variable where to store the part's y coordinate 268 * @param[out] w A pointer to a variable where to store the part's width 269 * @param[out] h A pointer to a variable where to store the part's height 270 * 271 * @return @c true on success, @c false otherwise 272 * 273 * @ingroup Edje_Object_Group 274 */ 275 EAPI Eina_Bool edje_object_part_geometry_get(const Evas_Object *obj, const char * part, int *x, int *y, int *w, int *h); 276 277 /** 278 * @brief Returns the state of the Edje part. 279 * 280 * @param[in] part The part name 281 * @param[out] val_ret Part state value 282 * 283 * @return The part state: "default" for the default state "" for other states 284 * 285 * @ingroup Edje_Object_Group 286 */ 287 EAPI const char *edje_object_part_state_get(const Evas_Object *obj, const char * part, double *val_ret); 288 289 /** 290 * @brief Gets a handle to the Evas object implementing a given Edje part, in 291 * an Edje object. 292 * 293 * This function gets a pointer of the Evas object corresponding to a given 294 * part in the obj object's group. 295 * 296 * You should never modify the state of the returned object (with @ref 297 * evas_object_move() or @ref evas_object_hide() for example), because it's 298 * meant to be managed by Edje, solely. You are safe to query information about 299 * its current state (with evas_object_visible_get() or @ref 300 * evas_object_color_get() for example), though. 301 * 302 * @note If the type of Edje part is GROUP, SWALLOW or EXTERNAL, returned 303 * handle by this function will indicate nothing or transparent rectangle for 304 * events. Use $.part_swallow_get() in that case. 305 * 306 * @param[in] part The Edje part's name 307 * 308 * @return A pointer to the Evas object implementing the given part, @c null on 309 * failure (e.g. the given part doesn't exist) 310 * 311 * @ingroup Edje_Object_Group 312 */ 313 EAPI const Efl_Canvas_Object *edje_object_part_object_get(const Evas_Object *obj, const char * part); 314 315 /** 316 * @brief Whether this object updates its size hints automatically. 317 * 318 * By default edje doesn't set size hints on itself. If this property is set to 319 * @c true, size hints will be updated after recalculation. Be careful, as 320 * recalculation may happen often, enabling this property may have a 321 * considerable performance impact as other widgets will be notified of the 322 * size hints changes. 323 * 324 * A layout recalculation can be triggered by @ref edje_object_size_min_calc(), 325 * @ref edje_object_size_min_restricted_calc(), 326 * @ref edje_object_parts_extends_calc() or even any other internal event. 327 * 328 * Enable or disable auto-update of size hints. 329 * 330 * @param[in] update Whether or not update the size hints. 331 * 332 * @ingroup Edje_Object_Group 333 */ 334 EAPI void edje_object_update_hints_set(Evas_Object *obj, Eina_Bool update); 335 336 /** 337 * @brief Whether this object updates its size hints automatically. 338 * 339 * By default edje doesn't set size hints on itself. If this property is set to 340 * @c true, size hints will be updated after recalculation. Be careful, as 341 * recalculation may happen often, enabling this property may have a 342 * considerable performance impact as other widgets will be notified of the 343 * size hints changes. 344 * 345 * A layout recalculation can be triggered by @ref edje_object_size_min_calc(), 346 * @ref edje_object_size_min_restricted_calc(), 347 * @ref edje_object_parts_extends_calc() or even any other internal event. 348 * 349 * Whether this object updates its size hints automatically. 350 * 351 * @return Whether or not update the size hints. 352 * 353 * @ingroup Edje_Object_Group 354 */ 355 EAPI Eina_Bool edje_object_update_hints_get(const Evas_Object *obj); 356 357 /** 358 * @brief Calculates the minimum required size for a given Edje object. 359 * 360 * This call works exactly as edje_object_size_min_restricted_calc(), with the 361 * last two arguments set to 0. Please refer to its documentation, then. 362 * 363 * @param[out] minw The minimum required width (return value) 364 * @param[out] minh The minimum required height (return value) 365 * 366 * @ingroup Edje_Object_Group 367 */ 368 EAPI void edje_object_size_min_calc(Evas_Object *obj, int *minw, int *minh); 369 370 /** 371 * @brief Calculates the minimum required size for a given Edje object. 372 * 373 * This call will trigger an internal recalculation of all parts of the object, 374 * in order to return its minimum required dimensions for width and height. The 375 * user might choose to impose those minimum sizes, making the resulting 376 * calculation to get to values equal or larger than @c restrictedw and 377 * @c restrictedh, for width and height, respectively. 378 * 379 * @note At the end of this call, the object won't be automatically resized to 380 * the new dimensions, but just return the calculated sizes. The caller is the 381 * one up to change its geometry or not. 382 * 383 * @warning Be advised that invisible parts in the object will be taken into 384 * account in this calculation. 385 * 386 * @param[out] minw The minimum required width (return value) 387 * @param[out] minh The minimum required height (return value) 388 * @param[in] restrictedw The minimum width constraint as input, @c minw can 389 * not be lower than this 390 * @param[in] restrictedh The minimum height constraint as input, @c minh can 391 * not be lower than this 392 * 393 * @ingroup Edje_Object_Group 394 */ 395 EAPI void edje_object_size_min_restricted_calc(Evas_Object *obj, int *minw, int *minh, int restrictedw, int restrictedh); 396 397 /** 398 * @brief Calculates the geometry of the region, relative to a given Edje 399 * object's area, occupied by all parts in the object. 400 * 401 * This function gets the geometry of the rectangle equal to the area required 402 * to group all parts in obj's group/collection. The x and y coordinates are 403 * relative to the top left corner of the whole obj object's area. Parts placed 404 * out of the group's boundaries will also be taken in account, so that x and y 405 * may be negative. 406 * 407 * @note On failure, this function will make all non-$null geometry pointers' 408 * pointed variables be set to zero. 409 * 410 * @param[out] x The parts region's X coordinate 411 * @param[out] y The parts region's Y coordinate 412 * @param[out] w The parts region's width 413 * @param[out] h The parts region's height 414 * 415 * @return @c true on success, @c false otherwise 416 * 417 * @ingroup Edje_Object_Group 418 */ 419 EAPI Eina_Bool edje_object_parts_extends_calc(Evas_Object *obj, int *x, int *y, int *w, int *h); 420 421 /** 422 * @brief Forces a Size/Geometry calculation. 423 * 424 * Forces the object to recalculate its layout regardless of freeze/thaw. 425 * 426 * See also @ref edje_object_freeze and @ref edje_object_thaw. 427 * 428 * @ingroup Edje_Object_Group 429 */ 430 EAPI void edje_object_calc_force(Evas_Object *obj); 431 432 /** 433 * @brief Freezes the Edje object. 434 * 435 * This function puts all changes on hold. Successive freezes will nest, 436 * requiring an equal number of thaws. 437 * 438 * See also @ref edje_object_thaw() 439 * 440 * @return The frozen state or 0 on error 441 * 442 * @ingroup Edje_Object_Group 443 */ 444 EAPI int edje_object_freeze(Evas_Object *obj); 445 446 /** 447 * @brief Thaws the Edje object. 448 * 449 * This function thaws the given Edje object. 450 * 451 * @note If successive freezes were done, an equal number of thaws will be 452 * required. 453 * 454 * See also @ref edje_object_freeze() 455 * 456 * @return The frozen state or 0 if the object is not frozen or on error. 457 * 458 * @ingroup Edje_Object_Group 459 */ 460 EAPI int edje_object_thaw(Evas_Object *obj); 461 462 /** 463 * @typedef (*Edje_Text_Change_Cb) 464 * 465 * Callback prototype for Edje_Text_Change. 466 * @param data User provided data to pass to the callback 467 * @param obj The Evas_Object 468 * @param part The edje part 469 */ 470 typedef void (*Edje_Text_Change_Cb) (void *data, Evas_Object *obj, const char *part); 471 /** 472 * @} 473 */ 474 475 /** 476 * @brief Sets the object text callback. 477 * 478 * This function sets the callback to be called when the text changes. 479 * 480 * @param[in] obj The object. 481 * @param[in] func The callback function to handle the text change 482 * @param[in] data The data associated to the callback function. 483 */ 484 EAPI void edje_object_text_change_cb_set(Evas_Object *obj, Edje_Text_Change_Cb func, void *data); 485 486 487 488 /** 489 * @addtogroup Edje_Object_Communication_Interface_Message 490 * 491 * @{ 492 */ 493 494 typedef struct _Edje_Message_String Edje_Message_String; /**< Alias for _Edje_Message_String. */ 495 typedef struct _Edje_Message_Int Edje_Message_Int; /**< Alias for _Edje_Message_Int */ 496 typedef struct _Edje_Message_Float Edje_Message_Float; /**< Alias for _Edje_Message_Float */ 497 typedef struct _Edje_Message_String_Set Edje_Message_String_Set; /**< Alias for _Edje_Message_String_Set */ 498 typedef struct _Edje_Message_Int_Set Edje_Message_Int_Set; /**< Alias for _Edje_Message_Int_Set */ 499 typedef struct _Edje_Message_Float_Set Edje_Message_Float_Set; /**< Alias for _Edje_Message_Float_Set */ 500 typedef struct _Edje_Message_String_Int Edje_Message_String_Int; /**< Alias for _Edje_Message_String_Int */ 501 typedef struct _Edje_Message_String_Float Edje_Message_String_Float; /**< Alias for _Edje_Message_String_Float */ 502 typedef struct _Edje_Message_String_Int_Set Edje_Message_String_Int_Set; /**< Alias for _Edje_Message_String_Int_Set */ 503 typedef struct _Edje_Message_String_Float_Set Edje_Message_String_Float_Set; /**< Alias for _Edje_Message_String_Float_Set */ 504 505 struct _Edje_Message_String 506 { 507 char *str; /**< The message's string pointer */ 508 }; /**< Structure passed as value on #EDJE_MESSAGE_STRING messages. The string in it is automatically freed Edje if passed to you by Edje */ 509 510 struct _Edje_Message_Int 511 { 512 int val; /**< The message's value */ 513 }; /**< Structure passed as value on #EDJE_MESSAGE_INT messages */ 514 515 struct _Edje_Message_Float 516 { 517 double val; /**< The message's value */ 518 }; /**< Structure passed as value on #EDJE_MESSAGE_FLOAT messages */ 519 520 struct _Edje_Message_String_Set 521 { 522 int count; /**< The size of the message's array (may be greater than 1) */ 523 char *str[1]; /**< The message's @b array of string pointers */ 524 }; /**< Structure passed as value on #EDJE_MESSAGE_STRING_SET messages. The array in it is automatically freed if passed to you by Edje */ 525 526 struct _Edje_Message_Int_Set 527 { 528 int count; /**< The size of the message's array (may be greater than 1) */ 529 int val[1]; /**< The message's @b array of integers */ 530 }; /**< Structure passed as value on #EDJE_MESSAGE_INT_SET messages. The array in it is automatically freed if passed to you by Edje */ 531 532 struct _Edje_Message_Float_Set 533 { 534 int count; /**< The size of the message's array (may be greater than 1) */ 535 double val[1]; /**< The message's @b array of floats */ 536 }; /**< Structure passed as value on #EDJE_MESSAGE_FLOAT_SET messages. The array in it is automatically freed if passed to you by Edje */ 537 538 struct _Edje_Message_String_Int 539 { 540 char *str; /**< The message's string value */ 541 int val; /**< The message's integer value */ 542 }; /**< Structure passed as value on #EDJE_MESSAGE_STRING_INT messages. The string in it is automatically freed if passed to you by Edje */ 543 544 struct _Edje_Message_String_Float 545 { 546 char *str; /**< The message's string value */ 547 double val; /**< The message's float value */ 548 }; /**< Structure passed as value on #EDJE_MESSAGE_STRING_FLOAT messages. The string in it is automatically freed if passed to you by Edje */ 549 550 struct _Edje_Message_String_Int_Set 551 { 552 char *str; /**< The message's string value */ 553 int count; /**< The size of the message's array (may be greater than 1) */ 554 int val[1]; /**< The message's @b array of integers */ 555 }; /**< Structure passed as value on #EDJE_MESSAGE_STRING_INT_SET messages. The array and string in it are automatically freed if passed to you by Edje */ 556 557 struct _Edje_Message_String_Float_Set 558 { 559 char *str; /**< The message's string value */ 560 int count; /**< The size of the message's array (may be greater than 1) */ 561 double val[1]; /**< The message's @b array of floats */ 562 }; /**< Structure passed as value on #EDJE_MESSAGE_STRING_FLOAT_SET messages. The array and string in it are automatically freed if passed to you by Edje */ 563 564 /** Identifiers of Edje message types, which can be sent back and forth code 565 * and a given Edje object's theme file/group. 566 * 567 * @ref edje_object_message_send 568 * @ref edje_object_message_handler_set 569 */ 570 typedef enum 571 { 572 EDJE_MESSAGE_NONE = 0, /**< No message type */ 573 EDJE_MESSAGE_SIGNAL = 1, /**< DO NOT USE THIS */ 574 EDJE_MESSAGE_STRING = 2, /**< A message with a string as value. Use 575 * #Edje_Message_String structs as message body, for 576 * this type. */ 577 EDJE_MESSAGE_INT = 3, /**< A message with an integer number as value. Use 578 * #Edje_Message_Int structs as message body, for this 579 * type. */ 580 EDJE_MESSAGE_FLOAT = 4, /**< A message with a floating pointer number as 581 * value. Use #Edje_Message_Float structs as message 582 * body, for this type. */ 583 EDJE_MESSAGE_STRING_SET = 5, /**< A message with a list of strings as value. 584 * Use #Edje_Message_String_Set structs as 585 * message body, for this type. */ 586 EDJE_MESSAGE_INT_SET = 6, /**< A message with a list of integer numbers as 587 * value. Use #Edje_Message_Int_Set structs as 588 * message body, for this type. */ 589 EDJE_MESSAGE_FLOAT_SET = 7, /**< A message with a list of floating point 590 * numbers as value. Use #Edje_Message_Float_Set 591 * structs as message body, for this type. */ 592 EDJE_MESSAGE_STRING_INT = 8, /**< A message with a struct containing a string 593 * and an integer number as value. Use 594 * #Edje_Message_String_Int structs as message 595 * body, for this type. */ 596 EDJE_MESSAGE_STRING_FLOAT = 9, /**< A message with a struct containing a 597 * string and a floating point number as 598 * value. Use #Edje_Message_String_Float 599 * structs as message body, for this type. */ 600 EDJE_MESSAGE_STRING_INT_SET = 10, /**< A message with a struct containing a 601 * string and list of integer numbers as 602 * value. Use #Edje_Message_String_Int_Set 603 * structs as message body, for this type. 604 */ 605 EDJE_MESSAGE_STRING_FLOAT_SET = 11 /**< A message with a struct containing a 606 * string and list of floating point 607 * numbers as value. Use 608 * #Edje_Message_String_Float_Set structs 609 * as message body, for this type. */ 610 } Edje_Message_Type; 611 612 typedef void (*Edje_Message_Handler_Cb) (void *data, Evas_Object *obj, Edje_Message_Type type, int id, void *msg); /**< Edje message handler 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 message comes from. @c type will identify the type of the given message and @c msg will be a pointer the message's contents, de facto, which depend on @c type. */ 613 614 /** 615 * @brief Sets an Edje message handler function for a given Edje object. 616 * 617 * For scriptable programs on an Edje object's defining EDC file which send 618 * messages with the send_message() primitive, one can attach handler 619 * functions, to be called in the code which creates that object (see @ref 620 * edcref "the syntax" for EDC files). 621 * 622 * This function associates a message handler function and the attached data 623 * pointer to the object obj. 624 * 625 * See also @ref edje_object_message_send() 626 * 627 * @param[in] func The function to handle messages coming from obj 628 * @param[in] data Auxiliary data to be passed to func 629 */ 630 EAPI void edje_object_message_handler_set(Evas_Object *obj, Edje_Message_Handler_Cb func, void *data); 631 632 /** 633 * @brief Sends an (Edje) message to a given Edje object 634 * 635 * This function sends an Edje message to obj and to all of its child objects, 636 * if it has any (swallowed objects are one kind of child object). type and msg 637 * must be matched accordingly, as documented in #Edje_Message_Type. 638 * 639 * The id argument as a form of code and theme defining a common interface on 640 * message communication. One should define the same IDs on both code and EDC 641 * declaration (see @ref edcref "the syntax" for EDC files), to individualize 642 * messages (binding them to a given context). 643 * 644 * The function to handle messages arriving from obj is set with 645 * edje_object_message_handler_set(). 646 * 647 * @param[in] type The type of message to send to obj 648 * @param[in] id A identification number for the message to be sent 649 * @param[in] msg The message's body, a struct depending on type 650 */ 651 EAPI void edje_object_message_send(Evas_Object *obj, Edje_Message_Type type, int id, void *msg); 652 653 /** 654 * @brief Processes an object's message queue. 655 * 656 * This function goes through the object message queue processing the pending 657 * messages for this specific Edje object. Normally they'd be processed only 658 * at idle time. Child objects will not be affected. 659 * 660 * @see edje_object_message_signal_recursive_process 661 */ 662 EAPI void edje_object_message_signal_process(Evas_Object *obj); 663 664 /** 665 * @brief Processes an object's message queue recursively. 666 * 667 * This function goes through the object message queue processing the pending 668 * messages for this specific Edje object. Normally they'd be processed only 669 * at idle time. This will also propagate the processing to all child objects. 670 * 671 * @see edje_object_message_signal_process 672 * 673 * @since 1.20 674 */ 675 EAPI void edje_object_message_signal_recursive_process(Evas_Object *obj); 676 677 /** 678 * @} 679 */ 680 681 /** 682 * @addgroup Edje_Object_Group 683 * 684 * @{ 685 */ 686 687 /** 688 * @brief Facility to query the type of the given parameter of the given part. 689 * 690 * @param[in] part The part name 691 * @param[in] param The parameter name to use 692 * 693 * @return @ref EDJE_EXTERNAL_PARAM_TYPE_MAX on errors, or another value from 694 * @ref Edje_External_Param_Type on success. 695 * 696 * @ingroup Edje_Object_Part 697 */ 698 EAPI Edje_External_Param_Type edje_object_part_external_param_type_get(const Evas_Object *obj, const char *part, const char * param); 699 700 /** 701 * @brief Sets the parameter for the external part. 702 * 703 * Parts of type external may carry extra properties that have meanings defined 704 * by the external plugin. For instance, it may be a string that defines a 705 * button label and setting this property will change that label on the fly. 706 * 707 * @note external parts have parameters set when they change states. Those 708 * parameters will never be changed by this function. The interpretation of how 709 * state_set parameters and param_set will interact is up to the external 710 * plugin. 711 * 712 * @note this function will not check if parameter value is valid using 713 * #Edje_External_Param_Info minimum, maximum, valid choices and others. 714 * However these should be checked by the underlying implementation provided by 715 * the external plugin. This is done for performance reasons. 716 * 717 * @param[in] part The part name 718 * @param[in] param The parameter details, including its name, type and actual 719 * value. This pointer should be valid, and the parameter must exist in 720 * #Edje_External_Type.parameters_info, with the exact type, otherwise the 721 * operation will fail and @c false will be returned. 722 * 723 * @return @c true if everything went fine, @c false on errors. 724 * 725 * @ingroup Edje_Object_Part 726 */ 727 EAPI Eina_Bool edje_object_part_external_param_set(Evas_Object *obj, const char *part, const Edje_External_Param *param); 728 729 /** 730 * @brief Gets the parameter for the external part. 731 * 732 * Parts of type external may carry extra properties that have meanings defined 733 * by the external plugin. For instance, it may be a string that defines a 734 * button label. This property can be modified by state parameters, by explicit 735 * calls to edje_object_part_external_param_set() or getting the actual object 736 * with edje_object_part_external_object_get() and calling native functions. 737 * 738 * This function asks the external plugin what is the current value, 739 * independent on how it was set. 740 * 741 * @param[in] part The part name 742 * @param[out] param The parameter details. It is used as both input and output 743 * variable. This pointer should be valid, and the parameter must exist in 744 * #Edje_External_Type.parameters_info, with the exact type, otherwise the 745 * operation will fail and @c false will be returned. 746 * 747 * @return @c true if everything went fine and param members are filled with 748 * information, @c false on errors and param member values are not set or 749 * valid. 750 * 751 * @ingroup Edje_Object_Part 752 */ 753 EAPI Eina_Bool edje_object_part_external_param_get(const Evas_Object *obj, const char *part, Edje_External_Param *param); 754 755 /** 756 * @brief Gets the object created by this external part. 757 * 758 * Parts of type external creates the part object using information provided by 759 * external plugins. It's somehow like "swallow" (edje_object_part_swallow()), 760 * but it's all set automatically. 761 * 762 * This function returns the part created by such external plugins and being 763 * currently managed by this Edje. 764 * 765 * @note Almost all swallow rules apply: you should not move, resize, hide, 766 * show, set the color or clipper of such part. It's a bit more restrictive as 767 * one must never delete this object! 768 * 769 * @param[in] part The part name 770 * 771 * @return The externally created object, or @c null if there is none or part 772 * is not an external. 773 * 774 * @ingroup Edje_Object_Part 775 */ 776 EAPI Evas_Object *edje_object_part_external_object_get(const Evas_Object *obj, const char * part); 777 778 /** 779 * @brief Gets an object contained in an part of type EXTERNAL 780 * 781 * The content string must not be @c null. Its actual value depends on the code 782 * providing the EXTERNAL. 783 * 784 * @param[in] part The name of the part holding the EXTERNAL 785 * @param[in] content A string identifying which content from the EXTERNAL to 786 * get 787 * 788 * @return Canvas object 789 * 790 * @ingroup Edje_Object_Part 791 */ 792 EAPI Evas_Object *edje_object_part_external_content_get(const Evas_Object *obj, const char *part, const char *content); 793 794 /** 795 * @} 796 */ 797 798 /** 799 * @deprecated use evas_object_size_hint_min_set() instead. 800 * @brief Sets the object minimum size. 801 * 802 * @param obj A valid Evas_Object handle 803 * @param minw The minimum width 804 * @param minh The minimum height 805 * 806 * This sets the minimum size restriction for the object. 807 * 808 * @ingroup Edje_Object_Group 809 * 810 */ 811 EINA_DEPRECATED EAPI void edje_extern_object_min_size_set (Evas_Object *obj, Evas_Coord minw, Evas_Coord minh); 812 813 /** 814 * @deprecated use evas_object_size_hint_max_set() instead. 815 * @brief Sets the object maximum size. 816 * 817 * @param obj A valid Evas_Object handle 818 * @param maxw The maximum width 819 * @param maxh The maximum height 820 * 821 * This sets the maximum size restriction for the object. 822 * 823 * @ingroup Edje_Object_Group 824 * 825 */ 826 EINA_DEPRECATED EAPI void edje_extern_object_max_size_set (Evas_Object *obj, Evas_Coord maxw, Evas_Coord maxh); 827 828 /** 829 * @deprecated use evas_object_size_hint_aspect_set() instead. 830 * @brief Sets the object aspect size. 831 * 832 * @param obj A valid Evas_Object handle 833 * @param aspect The aspect control axes 834 * @param aw The aspect radio width 835 * @param ah The aspect ratio height 836 * 837 * This sets the desired aspect ratio to keep an object that will be 838 * swallowed by Edje. The width and height define a preferred size 839 * ASPECT and the object may be scaled to be larger or smaller, but 840 * retaining the relative scale of both aspect width and height. 841 * 842 * @ingroup Edje_Object_Group 843 * 844 */ 845 EINA_DEPRECATED EAPI void edje_extern_object_aspect_set (Evas_Object *obj, Edje_Aspect_Control aspect, Evas_Coord aw, Evas_Coord ah); 846 847 /** 848 * @brief Sets the @b EDJ file (and group within it) to load an Edje 849 * object's contents from 850 * 851 * @return @c EINA_TRUE on success, or @c EINA_FALSE on errors (check 852 * edje_object_load_error_get() after this call to get errors causes) 853 * 854 * Edje expects EDJ files, which are theming objects' descriptions and 855 * resources packed together in an EET file, to read Edje object 856 * definitions from. They usually are created with the @c .edj 857 * extension. EDJ files, in turn, are assembled from @b textual object 858 * description files, where one describes Edje objects declaratively 859 * -- the EDC files (see @ref edcref "the syntax" for those files). 860 * 861 * Those description files were designed so that many Edje object 862 * definitions -- also called @b groups (or collections) -- could be 863 * packed together <b>in the same EDJ file</b>, so that a whole 864 * application's theme could be packed in one file only. This is the 865 * reason for the @p group argument. 866 * 867 * Use this function after you instantiate a new Edje object, so that 868 * you can "give him life", telling where to get its contents from. 869 * 870 * @see edje_object_add() 871 * @see edje_object_file_get() 872 * @see edje_object_mmap_set() 873 * 874 * @param[in] file The path to the EDJ file to load @p from 875 * @param[in] group The name of the group, in @p file, which implements an 876 Edje object 877 * 878 * @ingroup Edje_Object_Group 879 */ 880 EAPI Eina_Bool edje_object_file_set(Evas_Object *obj, const char *file, const char *group); 881 882 /** 883 * @brief Gets the file and group name that a given Edje object is bound to. 884 * 885 * This gets the EDJ file's path, with the respective group set for 886 * the given Edje object. If @a obj is either not an Edje file, or has 887 * not had its file/group set previously, by edje_object_file_set(), 888 * then both @p file and @p group will be set to @c NULL, indicating 889 * an error. 890 * 891 * @see edje_object_file_set() 892 * 893 * @note Use @c NULL pointers on the file/group components you're not 894 * interested in: they'll be ignored by the function. 895 * 896 * @param[out] file The path to the EDJ file to load @p from 897 * @param[out] group The name of the group, in @p file, which implements an 898 Edje object 899 * 900 * @ingroup Edje_Object_Group 901 */ 902 EAPI void edje_object_file_get(const Evas_Object *obj, const char **file, const char **group); 903 904 905 /** 906 * @brief Sets the @b EDJ file (and group within it) to load an Edje 907 * object's contents from. 908 * 909 * @return @c EINA_TRUE on success, or @c EINA_FALSE on errors (check 910 * edje_object_load_error_get() after this call to get errors causes) 911 * 912 * Edje expects EDJ files, which are theming objects' descriptions and 913 * resources packed together in an EET file, to read Edje object 914 * definitions from. They usually are created with the @c .edj 915 * extension. EDJ files, in turn, are assembled from @b textual object 916 * description files, where one describes Edje objects declaratively 917 * -- the EDC files (see @ref edcref "the syntax" for those files). 918 * 919 * Those description files were designed so that many Edje object 920 * definitions -- also called @b groups (or collections) -- could be 921 * packed together <b>in the same EDJ file</b>, so that a whole 922 * application's theme could be packed in one file only. This is the 923 * reason for the @p group argument. 924 * 925 * Use this function after you instantiate a new Edje object, so that 926 * you can "give him life", telling where to get its contents from. 927 * 928 * @see edje_object_add() 929 * @see edje_object_file_get() 930 * @since 1.8 931 * 932 * @param[in] file The Eina.File pointing to the EDJ file to load @p from 933 * @param[in] group The name of the group, in @p file, which implements an 934 Edje object 935 * 936 * @ingroup Edje_Object_Group 937 * 938 */ 939 EAPI Eina_Bool edje_object_mmap_set(Evas_Object *obj, const Eina_File *file, const char *group); 940 941 /** 942 * @brief "Swallows" an object into one of the Edje object @c SWALLOW parts. 943 * 944 * Swallowing an object into an Edje object is, for a given part of type 945 * @c SWALLOW in the EDC group which gave life to obj, to set an external 946 * object to be controlled by obj, being displayed exactly over that part's 947 * region inside the whole Edje object's viewport. 948 * 949 * From this point on, obj will have total control over obj_swallow's geometry 950 * and visibility. For instance, if obj is visible, as in @ref 951 * evas_object_show(), the swallowed object will be visible too -- if the given 952 * @c SWALLOW part it's in is also visible. Other actions on obj will also 953 * reflect on the swallowed object as well (e.g. resizing, moving, 954 * raising/lowering, etc.). 955 * 956 * Finally, all internal changes to part, specifically, will reflect on the 957 * displaying of obj_swallow, for example state changes leading to different 958 * visibility states, geometries, positions, etc. 959 * 960 * If an object has already been swallowed into this part, then it will first 961 * be unswallowed (as in edje_object_part_unswallow()) before the new object is 962 * swallowed. 963 * 964 * @note obj won't delete the swallowed object once it is deleted -- 965 * obj_swallow will get to an unparented state again. 966 * 967 * For more details on EDC @c SWALLOW parts, see @ref edcref "syntax 968 * reference". 969 * 970 * @param[in] obj_swallow The object to occupy that part 971 * 972 * @ingroup Edje_Object_Part 973 */ 974 EAPI Eina_Bool edje_object_part_swallow(Evas_Object *obj, const char *part, Evas_Object *obj_swallow); 975 976 /** 977 * @brief Gets the object currently swallowed by a part. 978 * 979 * @param[in] part The part name 980 * 981 * @return The swallowed object, or @c null if there is none. 982 * 983 * @ingroup Edje_Object_Part 984 */ 985 EAPI Evas_Object *edje_object_part_swallow_get(const Evas_Object *obj, const char *part); 986 987 /** 988 * @brief Unswallows an object. 989 * 990 * Causes the edje to regurgitate a previously swallowed object. :) 991 * 992 * @note obj_swallow will not be deleted or hidden. Note: obj_swallow may 993 * appear shown on the evas depending on its state when it got unswallowed. 994 * Make sure you delete it or hide it if you do not want it to. 995 * 996 * @param[in] obj_swallow The swallowed object 997 * 998 * @ingroup Edje_Object_Part 999 */ 1000 EAPI void edje_object_part_unswallow(Evas_Object *obj, Evas_Object *obj_swallow); 1001 1002 /** 1003 * @brief Retrieves a list all accessibility part names 1004 * 1005 * @return A list all accessibility part names on obj 1006 * 1007 * @since 1.7.0 1008 * 1009 * @ingroup Edje_Object_Part 1010 */ 1011 EAPI Eina_List *edje_object_access_part_list_get(const Evas_Object *obj); 1012 1013 /** 1014 * @brief Appends an object to the box. 1015 * 1016 * Appends child to the box indicated by part. 1017 * 1018 * See also @ref edje_object_part_box_prepend(), 1019 * @ref edje_object_part_box_insert_before(), 1020 * @ref edje_object_part_box_insert_after() and 1021 * @ref edje_object_part_box_insert_at() 1022 * 1023 * @param[in] child The object to append 1024 * 1025 * @return @c true: Successfully added. @c false: An error occurred. 1026 * 1027 * @ingroup Edje_Object_Part 1028 */ 1029 EAPI Eina_Bool edje_object_part_box_append(Evas_Object *obj, const char *part, Evas_Object *child); 1030 1031 /** 1032 * @brief Prepends an object to the box. 1033 * 1034 * Prepends child to the box indicated by part. 1035 * 1036 * See also @ref edje_object_part_box_append(), 1037 * @ref edje_object_part_box_insert_before(), 1038 * @ref edje_object_part_box_insert_after and 1039 * @ref edje_object_part_box_insert_at() 1040 * 1041 * @param[in] child The object to prepend 1042 * 1043 * @return @c true: Successfully added. @c false: An error occurred. 1044 * 1045 * @ingroup Edje_Object_Part 1046 */ 1047 EAPI Eina_Bool edje_object_part_box_prepend(Evas_Object *obj, const char *part, Evas_Object *child); 1048 1049 /** 1050 * @brief Adds an object to the box. 1051 * 1052 * Inserts child in the box given by part, in the position marked by reference. 1053 * 1054 * See also @ref edje_object_part_box_append(), 1055 * @ref edje_object_part_box_prepend(), 1056 * @ref edje_object_part_box_insert_after() and 1057 * @ref edje_object_part_box_insert_at() 1058 * 1059 * @param[in] child The object to insert 1060 * @param[in] reference The object to be used as reference 1061 * 1062 * @return @c true: Successfully added. @c false: An error occurred. 1063 * 1064 * @ingroup Edje_Object_Part 1065 */ 1066 EAPI Eina_Bool edje_object_part_box_insert_before(Evas_Object *obj, const char *part, Evas_Object *child, const Evas_Object *reference); 1067 1068 /** 1069 * @brief Adds an object to the box. 1070 * 1071 * Inserts child in the box given by part, in the position marked by reference. 1072 * 1073 * See also @ref edje_object_part_box_append(), 1074 * @ref edje_object_part_box_prepend(), 1075 * @ref edje_object_part_box_insert_before() and 1076 * @ref edje_object_part_box_insert_at() 1077 * 1078 * @param[in] child The object to insert 1079 * @param[in] reference The object to be used as reference 1080 * 1081 * @return @c true: Successfully added. @c false: An error occurred. 1082 * 1083 * @since 1.18 1084 * @ingroup Edje_Object 1085 */ 1086 EAPI Eina_Bool edje_object_part_box_insert_after(Evas_Object *obj, const char *part, Evas_Object *child, const Evas_Object *reference); 1087 1088 /** 1089 * @brief Inserts an object to the box. 1090 * 1091 * Adds child to the box indicated by part, in the position given by pos. 1092 * 1093 * See also @ref edje_object_part_box_append(), 1094 * @ref edje_object_part_box_prepend(), 1095 * @ref edje_object_part_box_insert_before() and 1096 * @ref edje_object_part_box_insert_after() 1097 * 1098 * @param[in] child The object to insert 1099 * @param[in] pos The position where to insert child 1100 * 1101 * @return @c true: Successfully added. @c false: An error occurred. 1102 * 1103 * @ingroup Edje_Object_Part 1104 */ 1105 EAPI Eina_Bool edje_object_part_box_insert_at(Evas_Object *obj, const char *part, Evas_Object *child, unsigned int pos); 1106 1107 /** 1108 * @brief Removes an object from the box. 1109 * 1110 * Removes from the box indicated by part, the object in the position pos. 1111 * 1112 * See also @ref edje_object_part_box_remove() and 1113 * @ref edje_object_part_box_remove_all() 1114 * 1115 * @param[in] pos The position index of the object (starts counting from 0) 1116 * 1117 * @return Pointer to the object removed, or @c null. 1118 * 1119 * @ingroup Edje_Object_Part 1120 */ 1121 EAPI Evas_Object *edje_object_part_box_remove_at(Evas_Object *obj, const char *part, unsigned int pos); 1122 1123 /** 1124 * @brief Removes an object from the box. 1125 * 1126 * Removes child from the box indicated by part. 1127 * 1128 * See also @ref edje_object_part_box_remove_at() and 1129 * @ref edje_object_part_box_remove_all() 1130 * 1131 * @param[in] child The object to remove 1132 * 1133 * @return Pointer to the object removed, or @c null. 1134 * 1135 * @ingroup Edje_Object_Part 1136 */ 1137 EAPI Evas_Object *edje_object_part_box_remove(Evas_Object *obj, const char *part, Evas_Object *child); 1138 1139 /** 1140 * @brief Removes all elements from the box. 1141 * 1142 * Removes all the external objects from the box indicated by part. Elements 1143 * created from the theme will not be removed. 1144 * 1145 * See also @ref edje_object_part_box_remove() and 1146 * @ref edje_object_part_box_remove_at() 1147 * 1148 * @param[in] clear Delete objects on removal 1149 * 1150 * @return 1: Successfully cleared. 0: An error occurred. 1151 * 1152 * @ingroup Edje_Object_Part 1153 */ 1154 EAPI Eina_Bool edje_object_part_box_remove_all(Evas_Object *obj, const char *part, Eina_Bool clear); 1155 1156 /** 1157 * @brief Packs an object into the table. 1158 * 1159 * Packs an object into the table indicated by part. 1160 * 1161 * @param[in] child_obj The object to pack in 1162 * @param[in] col The column to place it in 1163 * @param[in] row The row to place it in 1164 * @param[in] colspan Columns the child will take 1165 * @param[in] rowspan Rows the child will take 1166 * 1167 * @return @c true object was added, @c false on failure 1168 * 1169 * @ingroup Edje_Object_Part 1170 */ 1171 EAPI Eina_Bool edje_object_part_table_pack(Evas_Object *obj, const char *part, Evas_Object *child_obj, unsigned short col, unsigned short row, unsigned short colspan, unsigned short rowspan); 1172 1173 /** 1174 * @brief Removes an object from the table. 1175 * 1176 * Removes an object from the table indicated by part. 1177 * 1178 * @param[in] child_obj The object to pack in 1179 * 1180 * @return @c true object removed, @c false on failure 1181 * 1182 * @ingroup Edje_Object_Part 1183 */ 1184 EAPI Eina_Bool edje_object_part_table_unpack(Evas_Object *obj, const char *part, Evas_Object *child_obj); 1185 1186 /** 1187 * @brief Gets the number of columns and rows the table has. 1188 * 1189 * Retrieves the size of the table in number of columns and rows. 1190 * 1191 * @param[out] cols Pointer where to store number of columns (can be @c null) 1192 * @param[out] rows Pointer where to store number of rows (can be @c null) 1193 * 1194 * @return @c true get some data, @c false on failure 1195 * 1196 * @ingroup Edje_Object_Part 1197 */ 1198 EAPI Eina_Bool edje_object_part_table_col_row_size_get(const Evas_Object *obj, const char *part, int *cols, int *rows); 1199 1200 /** 1201 * @brief Retrieves a child from a table 1202 * 1203 * @param[in] col The column of the child to get 1204 * @param[in] row The row of the child to get 1205 * 1206 * @return The child Efl.Canvas.Object 1207 * 1208 * @ingroup Edje_Object_Part 1209 */ 1210 EAPI Evas_Object *edje_object_part_table_child_get(const Evas_Object *obj, const char *part, unsigned int col, unsigned int row); 1211 1212 /** 1213 * @brief Removes all object from the table. 1214 * 1215 * Removes all object from the table indicated by part, except the internal 1216 * ones set from the theme. 1217 * 1218 * @param[in] clear If set, will delete subobjs on remove 1219 * 1220 * @return @c true clear the table, @c false on failure 1221 * 1222 * @ingroup Edje_Object_Part 1223 */ 1224 EAPI Eina_Bool edje_object_part_table_clear(Evas_Object *obj, const char *part, Eina_Bool clear); 1225 1226 /** 1227 * @brief Sets the object color class. 1228 * 1229 * This function sets the color values for an object level color class. This 1230 * will cause all edje parts in the specified object that have the specified 1231 * color class to have their colors multiplied by these values. 1232 * 1233 * The first color is the object, the second is the text outline, and the third 1234 * is the text shadow. (Note that the second two only apply to text parts). 1235 * 1236 * Setting color emits a signal "color_class,set" with source being the given 1237 * color. 1238 * 1239 * @note unlike Evas, Edje colors are not pre-multiplied. That is, 1240 * half-transparent white is 255 255 255 128. 1241 * 1242 * @param[in] color_class The name of color class 1243 * @param[in] r Object Red value 1244 * @param[in] g Object Green value 1245 * @param[in] b Object Blue value 1246 * @param[in] a Object Alpha value 1247 * @param[in] r2 Outline Red value 1248 * @param[in] g2 Outline Green value 1249 * @param[in] b2 Outline Blue value 1250 * @param[in] a2 Outline Alpha value 1251 * @param[in] r3 Shadow Red value 1252 * @param[in] g3 Shadow Green value 1253 * @param[in] b3 Shadow Blue value 1254 * @param[in] a3 Shadow Alpha value 1255 * 1256 * @ingroup Edje_Object_Color_Class 1257 */ 1258 EAPI Eina_Bool edje_object_color_class_set(Evas_Object *obj, 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); 1259 1260 /** 1261 * @brief Gets the object color class. 1262 * 1263 * This function gets the color values for an object level color class. If no 1264 * explicit object color is set, then global values will be used. 1265 * 1266 * The first color is the object, the second is the text outline, and the third 1267 * is the text shadow. (Note that the second two only apply to text parts). 1268 * 1269 * @note unlike Evas, Edje colors are not pre-multiplied. That is, 1270 * half-transparent white is 255 255 255 128. 1271 * 1272 * @param[in] color_class The name of color class 1273 * @param[out] r Object Red value 1274 * @param[out] g Object Green value 1275 * @param[out] b Object Blue value 1276 * @param[out] a Object Alpha value 1277 * @param[out] r2 Outline Red value 1278 * @param[out] g2 Outline Green value 1279 * @param[out] b2 Outline Blue value 1280 * @param[out] a2 Outline Alpha value 1281 * @param[out] r3 Shadow Red value 1282 * @param[out] g3 Shadow Green value 1283 * @param[out] b3 Shadow Blue value 1284 * @param[out] a3 Shadow Alpha value 1285 * 1286 * @return true if found or false if not found and all values are zeroed. 1287 * 1288 * @ingroup Edje_Object_Color_Class 1289 */ 1290 EAPI Eina_Bool edje_object_color_class_get(const Evas_Object *obj, 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); 1291 1292 /** 1293 * @brief Delete the object color class. 1294 * 1295 * This function deletes any values at the object level for the specified 1296 * object and color class. 1297 * 1298 * Deleting the color class will revert it to the values defined by 1299 * edje_color_class_set() or the color class defined in the theme file. 1300 * 1301 * Deleting the color class will emit the signal "color_class,del" for the 1302 * given Edje object. 1303 * 1304 * @param[in] color_class The color class to be deleted. 1305 * 1306 * @ingroup Edje_Object_Color_Class 1307 */ 1308 EAPI void edje_object_color_class_del(Evas_Object *obj, const char *color_class); 1309 1310 /** 1311 * @brief Delete all color classes defined in object level. 1312 * 1313 * This function deletes any color classes defined in object level. 1314 * Clearing color classes will revert the color of all edje parts to 1315 * the values defined in global level or theme file. 1316 * 1317 * @return @c true, on success or @c false, on error 1318 * 1319 * @since 1.17.0 1320 * 1321 * @ingroup Edje_Object_Color_Class 1322 */ 1323 EAPI Eina_Bool edje_object_color_class_clear(const Evas_Object *obj); 1324 1325 /** 1326 * @brief Sets Edje text class. 1327 * 1328 * This function sets the text class for the Edje. 1329 * 1330 * @param[in] text_class The text class name 1331 * @param[in] font Font name 1332 * @param[in] size Font Size 1333 * 1334 * @return @c true, on success or @c false, on error 1335 * 1336 * @ingroup Edje_Object_Text_Class 1337 */ 1338 EAPI Eina_Bool edje_object_text_class_set(Evas_Object *obj, const char * text_class, const char *font, Evas_Font_Size size); 1339 1340 /** 1341 * @brief Gets font and font size from edje text class. 1342 * 1343 * This function gets the font and the font size from the object text class. 1344 * The font string will only be valid until the text class is changed or the 1345 * edje object is deleted. 1346 * 1347 * @param[in] text_class The text class name 1348 * @param[out] font Font name 1349 * @param[out] size Font Size 1350 * 1351 * @return @c true, on success or @c false, on error 1352 * 1353 * @ingroup Edje_Object_Text_Class 1354 */ 1355 EAPI Eina_Bool edje_object_text_class_get(const Evas_Object *obj, const char * text_class, const char **font, Evas_Font_Size *size); 1356 1357 /** 1358 * @brief Delete the object text class. 1359 * 1360 * This function deletes any values at the object level for the specified 1361 * object and text class. 1362 * 1363 * Deleting the text class will revert it to the values defined by 1364 * edje_text_class_set() or the text class defined in the theme file. 1365 * 1366 * @param[in] text_class The color class to be deleted. 1367 * 1368 * @since 1.17 1369 * 1370 * @ingroup Edje_Object_Text_Class 1371 */ 1372 EAPI void edje_object_text_class_del(Evas_Object *obj, const char *text_class); 1373 1374 /** 1375 * @brief Sets the object size class. 1376 * 1377 * This function sets the min and max values for an object level size class. 1378 * This will make all edje parts in the specified object that have the 1379 * specified size class update their min and max size with given values. 1380 * 1381 * @param[in] size_class The size class name 1382 * @param[in] minw The min width 1383 * @param[in] minh The min height 1384 * @param[in] maxw The max width 1385 * @param[in] maxh The max height 1386 * 1387 * @return @c true, on success or @c false, on error 1388 * 1389 * @since 1.17 1390 * 1391 * @ingroup Edje_Object_Size_Class 1392 */ 1393 EAPI Eina_Bool edje_object_size_class_set(Evas_Object *obj, const char * size_class, int minw, int minh, int maxw, int maxh); 1394 1395 /** 1396 * @brief Gets the object size class. 1397 * 1398 * This function gets the min and max values for an object level size class. 1399 * These values will only be valid until the size class is changed or the edje 1400 * object is deleted. 1401 * 1402 * @param[in] size_class The size class name 1403 * @param[out] minw The min width 1404 * @param[out] minh The min height 1405 * @param[out] maxw The max width 1406 * @param[out] maxh The max height 1407 * 1408 * @return @c true, on success or @c false, on error 1409 * 1410 * @since 1.17 1411 * 1412 * @ingroup Edje_Object_Size_Class 1413 */ 1414 EAPI Eina_Bool edje_object_size_class_get(const Evas_Object *obj, const char * size_class, int *minw, int *minh, int *maxw, int *maxh); 1415 1416 /** 1417 * @brief Delete the object size class. 1418 * 1419 * This function deletes any values at the object level for the specified 1420 * object and size class. 1421 * 1422 * Deleting the size class will revert it to the values defined by 1423 * edje_size_class_set() or the color class defined in the theme file. 1424 * 1425 * @param[in] size_class Size class name 1426 * 1427 * @since 1.17 1428 * 1429 * @ingroup Edje_Object_Size_Class 1430 */ 1431 EAPI void edje_object_size_class_del(Evas_Object *obj, const char *size_class); 1432 1433 /** 1434 * @brief Enables selection if the entry is an EXPLICIT selection mode type. 1435 * 1436 * The default is to not allow selection. This function only affects user 1437 * selection, functions such as edje_object_part_text_select_all() and 1438 * edje_object_part_text_select_none() are not affected. 1439 * 1440 * @param[in] part The part name 1441 * @param[in] allow true to enable, false otherwise 1442 * 1443 * @ingroup Edje_Object_Part 1444 */ 1445 EAPI void edje_object_part_text_select_allow_set(const Evas_Object *obj, const char *part, Eina_Bool allow); 1446 1447 /** 1448 * @brief Sets the RTL orientation for this object. 1449 * 1450 * @param[in] rtl New value of flag @c true/$false 1451 * 1452 * @since 1.1.0 1453 * 1454 * @ingroup Edje_Object_Group 1455 */ 1456 EAPI void edje_object_mirrored_set(Evas_Object *obj, Eina_Bool rtl); 1457 1458 /** 1459 * @brief Gets the RTL orientation for this object. 1460 * 1461 * You can RTL orientation explicitly with edje_object_mirrored_set. 1462 * 1463 * @return New value of flag @c true/$false 1464 * 1465 * @since 1.1.0 1466 * 1467 * @ingroup Edje_Object_Group 1468 */ 1469 EAPI Eina_Bool edje_object_mirrored_get(const Evas_Object *obj); 1470 1471 /** 1472 * @brief Sets the language for this object. 1473 * 1474 * @param[in] language The language value 1475 * 1476 * @since 1.1.0 1477 * 1478 * @ingroup Edje_Object_Group 1479 */ 1480 EAPI void edje_object_language_set(Evas_Object *obj, const char *language); 1481 1482 /** 1483 * @brief Gets the language for this object. 1484 * 1485 * @return The language value 1486 * 1487 * @since 1.1.0 1488 * 1489 * @ingroup Edje_Object_Group 1490 */ 1491 EAPI const char *edje_object_language_get(const Evas_Object *obj); 1492 1493 /** 1494 * @brief Sets the scaling factor for a given Edje object. 1495 * 1496 * This function sets an individual scaling factor on the obj Edje object. 1497 * This property (or Edje's global scaling factor, when applicable), will 1498 * affect this object's part sizes. If scale is not zero, than the individual 1499 * scaling will override any global scaling set, for the object obj's parts. 1500 * Put it back to zero to get the effects of the global scaling again. 1501 * 1502 * @warning Only parts which, at EDC level, had the @"scale" property set to 1503 * @1, will be affected by this function. Check the complete @ref edcref 1504 * "syntax reference" for EDC files. 1505 * 1506 * See also @ref edje_object_scale_get() @ref edje_scale_get() for more details 1507 * 1508 * @param[in] scale The scaling factor (the default value is @0.0, meaning 1509 * individual scaling not set) 1510 * 1511 * @return @c true on success, @c false otherwise 1512 * 1513 * @ingroup Edje_Object_Scale 1514 */ 1515 EAPI Eina_Bool edje_object_scale_set(Evas_Object *obj, double scale); 1516 1517 /** 1518 * @brief Gets a given Edje object's scaling factor. 1519 * 1520 * This function returns the individual scaling factor set on the obj Edje 1521 * object. 1522 * 1523 * See also @ref edje_object_scale_set() for more details 1524 * 1525 * @return The scaling factor (the default value is @0.0, meaning individual 1526 * scaling not set) 1527 * 1528 * @ingroup Edje_Object_Scale 1529 */ 1530 EAPI double edje_object_scale_get(const Evas_Object *obj); 1531 1532 /** 1533 * @brief Gets a given Edje object's base_scale factor. 1534 * 1535 * This function returns the base_scale factor set on the obj Edje object. The 1536 * base_scale can be set in the collection of edc. If it isn't set, the default 1537 * value is 1.0 1538 * 1539 * @return The base_scale factor (the default value is @ 1.0, that means the 1540 * edc file is made based on scale 1.0. 1541 * 1542 * @ingroup Edje_Object_Scale 1543 */ 1544 EAPI double edje_object_base_scale_get(const Evas_Object *obj); 1545 1546 /** 1547 * @defgroup Edje_Part_Drag Edje Drag 1548 * @ingroup Edje_Object_Part 1549 * 1550 * @brief Functions that deal with dragable parts. 1551 * 1552 * To create a movable part it must be declared as dragable 1553 * in EDC file. To do so, one must define a "dragable" block inside 1554 * the "part" block. 1555 * 1556 * These functions are used to set dragging properties to a 1557 * part or get dragging information about it. 1558 * 1559 * @see @ref tutorial_edje_drag * 1560 * 1561 * @{ 1562 */ 1563 1564 /** Directions in which a part can be dragged .*/ 1565 typedef enum _Edje_Drag_Dir 1566 { 1567 EDJE_DRAG_DIR_NONE = 0, /**< Part cannot be dragged. */ 1568 EDJE_DRAG_DIR_X = 1, /**< Part can be dragged in the horizontal direction. */ 1569 EDJE_DRAG_DIR_Y = 2, /**< Part can be dragged in the vertical direction. */ 1570 EDJE_DRAG_DIR_XY = 3 /**< Part can be dragged in every direction. */ 1571 } Edje_Drag_Dir; 1572 1573 /** 1574 * @brief Sets the dragable object location. 1575 * 1576 * Places the dragable object at the given location. 1577 * 1578 * Values for dx and dy are real numbers that range from 0 to 1, representing 1579 * the relative position to the dragable area on that axis. 1580 * 1581 * This value means, for the vertical axis, that 0.0 will be at the top if the 1582 * first parameter of @c y in the dragable part theme is 1, and at bottom if it 1583 * is -1. 1584 * 1585 * For the horizontal axis, 0.0 means left if the first parameter of @c x in 1586 * the dragable part theme is 1, and right if it is -1. 1587 * 1588 * See also @ref edje_object_part_drag_value_get() 1589 * 1590 * @param[in] part The part name 1591 * @param[in] dx The x value 1592 * @param[in] dy The y value 1593 * 1594 * @return @c true on success, @c false otherwise 1595 * 1596 * @ingroup Edje_Part_Drag 1597 */ 1598 EAPI Eina_Bool edje_object_part_drag_value_set(Evas_Object *obj, const char * part, double dx, double dy); 1599 1600 /** 1601 * @brief Gets the dragable object location. 1602 * 1603 * Values for dx and dy are real numbers that range from 0 to 1, representing 1604 * the relative position to the dragable area on that axis. 1605 * 1606 * See also @ref edje_object_part_drag_value_set() 1607 * 1608 * Gets the drag location values. 1609 * 1610 * @param[in] part The part name 1611 * @param[out] dx The x value 1612 * @param[out] dy The y value 1613 * 1614 * @return @c true on success, @c false otherwise 1615 * 1616 * @ingroup Edje_Part_Drag 1617 */ 1618 EAPI Eina_Bool edje_object_part_drag_value_get(const Evas_Object *obj, const char * part, double *dx, double *dy); 1619 1620 /** 1621 * @brief Sets the dragable object size. 1622 * 1623 * Values for dw and dh are real numbers that range from 0 to 1, representing 1624 * the relative size of the dragable area on that axis. 1625 * 1626 * Sets the size of the dragable object. 1627 * 1628 * See also @ref edje_object_part_drag_size_get() 1629 * 1630 * @param[in] part The part name 1631 * @param[in] dw The drag width 1632 * @param[in] dh The drag height 1633 * 1634 * @return @c true on success, @c false otherwise 1635 * 1636 * @ingroup Edje_Part_Drag 1637 */ 1638 EAPI Eina_Bool edje_object_part_drag_size_set(Evas_Object *obj, const char * part, double dw, double dh); 1639 1640 /** 1641 * @brief Gets the dragable object size. 1642 * 1643 * Gets the dragable object size. 1644 * 1645 * See also @ref edje_object_part_drag_size_set() 1646 * 1647 * @param[in] part The part name 1648 * @param[out] dw The drag width 1649 * @param[out] dh The drag height 1650 * 1651 * @return @c true on success, @c false otherwise 1652 * 1653 * @ingroup Edje_Part_Drag 1654 */ 1655 EAPI Eina_Bool edje_object_part_drag_size_get(const Evas_Object *obj, const char * part, double *dw, double *dh); 1656 1657 /** 1658 * @brief Determines dragable directions. 1659 * 1660 * The dragable directions are defined in the EDC file, inside the 1661 * "dragable" section, by the attributes @c x and @c y. See the @ref edcref for 1662 * more information. 1663 * 1664 * @param[in] part The part name 1665 * 1666 * @return #EDJE_DRAG_DIR_NONE: Not dragable #EDJE_DRAG_DIR_X: Dragable in X 1667 * direction #EDJE_DRAG_DIR_Y: Dragable in Y direction #EDJE_DRAG_DIR_XY: 1668 * Dragable in X & Y directions 1669 * 1670 * @ingroup Edje_Part_Drag 1671 */ 1672 EAPI Edje_Drag_Dir edje_object_part_drag_dir_get(const Evas_Object *obj, const char * part); 1673 1674 /** 1675 * @brief Sets the drag step increment. 1676 * 1677 * Sets the x,y step increments for a dragable object. 1678 * 1679 * Values for dx and dy are real numbers that range from 0 to 1, representing 1680 * the relative size of the dragable area on that axis by which the part will 1681 * be moved. 1682 * 1683 * See also @ref edje_object_part_drag_step_get() 1684 * 1685 * @param[in] part The part name 1686 * @param[in] dx The x step amount 1687 * @param[in] dy The y step amount 1688 * 1689 * @return @c true on success, @c false otherwise 1690 * 1691 * @ingroup Edje_Part_Drag 1692 */ 1693 EAPI Eina_Bool edje_object_part_drag_step_set(Evas_Object *obj, const char * part, double dx, double dy); 1694 1695 /** 1696 * @brief Gets the drag step increment values. 1697 * 1698 * Gets the x and y step increments for the dragable object. 1699 * 1700 * See also @ref edje_object_part_drag_step_set() 1701 * 1702 * @param[in] part The part name 1703 * @param[out] dx The x step amount 1704 * @param[out] dy The y step amount 1705 * 1706 * @return @c true on success, @c false otherwise 1707 * 1708 * @ingroup Edje_Part_Drag 1709 */ 1710 EAPI Eina_Bool edje_object_part_drag_step_get(const Evas_Object *obj, const char * part, double *dx, double *dy); 1711 1712 /** 1713 * @brief Steps the dragable x,y steps. 1714 * 1715 * Steps x,y where the step increment is the amount set by 1716 * @ref edje_object_part_drag_step_set(). 1717 * 1718 * Values for dx and dy are real numbers that range from 0 to 1. 1719 * 1720 * See also @ref edje_object_part_drag_page() 1721 * 1722 * @param[in] part The part name 1723 * @param[in] dx The x step 1724 * @param[in] dy The y step 1725 * 1726 * @return @c true on success, @c false otherwise 1727 * 1728 * @ingroup Edje_Part_Drag 1729 */ 1730 EAPI Eina_Bool edje_object_part_drag_step(Evas_Object *obj, const char *part, double dx, double dy); 1731 1732 /** 1733 * @brief Sets the page step increments. 1734 * 1735 * Sets the x,y page step increment values. 1736 * 1737 * Values for dx and dy are real numbers that range from 0 to 1, representing 1738 * the relative size of the dragable area on that axis by which the part will 1739 * be moved. 1740 * 1741 * See also @ref edje_object_part_drag_page_get() 1742 * 1743 * @param[in] part The part name 1744 * @param[in] dx The x page step increment 1745 * @param[in] dy The y page step increment 1746 * 1747 * @return @c true on success, @c false otherwise 1748 * 1749 * @ingroup Edje_Part_Drag 1750 */ 1751 EAPI Eina_Bool edje_object_part_drag_page_set(Evas_Object *obj, const char * part, double dx, double dy); 1752 1753 /** 1754 * @brief Gets the page step increments. 1755 * 1756 * Gets the x,y page step increments for the dragable object. 1757 * 1758 * See also @ref edje_object_part_drag_page_set() 1759 * 1760 * @param[in] part The part name 1761 * @param[out] dx The x page step increment 1762 * @param[out] dy The y page step increment 1763 * 1764 * @return @c true on success, @c false otherwise 1765 * 1766 * @ingroup Edje_Part_Drag 1767 */ 1768 EAPI Eina_Bool edje_object_part_drag_page_get(const Evas_Object *obj, const char * part, double *dx, double *dy); 1769 1770 /** 1771 * @brief Pages x,y steps. 1772 * 1773 * Pages x,y where the increment is defined by 1774 * @ref edje_object_part_drag_page_set(). 1775 * 1776 * Values for dx and dy are real numbers that range from 0 to 1. 1777 * 1778 * @warning Paging is bugged! 1779 * 1780 * See also @ref edje_object_part_drag_step() 1781 * 1782 * @param[in] part The part name 1783 * @param[in] dx The x step 1784 * @param[in] dy The y step 1785 * 1786 * @return @c true on success, @c false otherwise 1787 * 1788 * @ingroup Edje_Part_Drag 1789 */ 1790 EAPI Eina_Bool edje_object_part_drag_page(Evas_Object *obj, const char *part, double dx, double dy); 1791 1792 /** 1793 * @} 1794 */ 1795 1796 /** 1797 * @brief Sets a given text to an Edje object @c TEXT or TEXTBLOCK 1798 * parts. 1799 * 1800 * @param[in] part The part name 1801 * @param[in] text The text to set on that part 1802 * 1803 * @ingroup Edje_Object_Part 1804 */ 1805 EAPI Eina_Bool edje_object_part_text_set(const Evas_Object *obj, const char *part, const char *text); 1806 1807 /** 1808 * @brief Gets the text currntly set to the given part 1809 * 1810 * @param[in] part The part name 1811 * 1812 * @return The text set on the part, @c null otherwise. 1813 * 1814 * @ingroup Edje_Object_Part 1815 */ 1816 EAPI const char * edje_object_part_text_get(const Evas_Object *obj, const char *part); 1817 1818 /** 1819 * @brief Moves the cursor to the beginning of the text part @ref 1820 * evas_textblock_cursor_paragraph_first 1821 * 1822 * @param[in] part The part name 1823 * @param[in] cur The edje cursor to work on 1824 * 1825 * @ingroup Edje_Object_Part 1826 */ 1827 EAPI void edje_object_part_text_cursor_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur); 1828 1829 /** 1830 * @brief Moves the cursor to the end of the text part. @ref 1831 * evas_textblock_cursor_paragraph_last 1832 * 1833 * @param[in] part The part name 1834 * @param[in] cur The edje cursor to work on 1835 * 1836 * @ingroup Edje_Object_Part 1837 */ 1838 EAPI void edje_object_part_text_cursor_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur); 1839 1840 /** 1841 * @brief Sets the cursor position to the given value 1842 * 1843 * @param[in] part The part name 1844 * @param[in] cur The cursor to move 1845 * @param[in] pos The position of the cursor 1846 * 1847 * @since 1.1.0 1848 * 1849 * @ingroup Edje_Object_Part 1850 */ 1851 EAPI void edje_object_part_text_cursor_pos_set(Evas_Object *obj, const char * part, Edje_Cursor cur, int pos); 1852 1853 /** 1854 * @brief Retrieves the current position of the cursor 1855 * 1856 * @param[in] part The part name 1857 * @param[in] cur The cursor to move 1858 * 1859 * @return The position of the cursor 1860 * 1861 * @since 1.1.0 1862 * 1863 * @ingroup Edje_Object_Part 1864 */ 1865 EAPI int edje_object_part_text_cursor_pos_get(const Evas_Object *obj, const char * part, Edje_Cursor cur); 1866 1867 /** 1868 * @brief Position the given cursor to a X,Y position. 1869 * 1870 * This is frequently used with the user cursor. 1871 * 1872 * @param[in] part The part containing the object. 1873 * @param[in] cur The cursor to adjust. 1874 * @param[in] x X Coordinate. 1875 * @param[in] y Y Coordinate. 1876 * 1877 * @return @c true on success, @c false otherwise 1878 * 1879 * @ingroup Edje_Object_Part 1880 */ 1881 EAPI Eina_Bool edje_object_part_text_cursor_coord_set(Evas_Object *obj, const char *part, Edje_Cursor cur, int x, int y); 1882 1883 /** 1884 * @brief Moves the cursor to the beginning of the line. @ref 1885 * evas_textblock_cursor_line_char_first 1886 * 1887 * @param[in] part The part name 1888 * @param[in] cur The edje cursor to work on 1889 * 1890 * @ingroup Edje_Object_Part 1891 */ 1892 EAPI void edje_object_part_text_cursor_line_begin_set(Evas_Object *obj, const char *part, Edje_Cursor cur); 1893 1894 /** 1895 * @brief Moves the cursor to the end of the line. @ref 1896 * evas_textblock_cursor_line_char_last 1897 * 1898 * @param[in] part The part name 1899 * @param[in] cur The edje cursor to work on 1900 * 1901 * @ingroup Edje_Object_Part 1902 */ 1903 EAPI void edje_object_part_text_cursor_line_end_set(Evas_Object *obj, const char *part, Edje_Cursor cur); 1904 1905 /** 1906 * @brief Moves the cursor to the previous char @ref 1907 * evas_textblock_cursor_char_prev 1908 * 1909 * @param[in] part The part name 1910 * @param[in] cur The edje cursor to work on 1911 * 1912 * @return @c true on success, @c false otherwise 1913 * 1914 * @ingroup Edje_Object_Part 1915 */ 1916 EAPI Eina_Bool edje_object_part_text_cursor_prev(Evas_Object *obj, const char *part, Edje_Cursor cur); 1917 1918 /** 1919 * @brief Advances the cursor to the next cursor position. @ref 1920 * evas_textblock_cursor_char_next 1921 * 1922 * @param[in] part The part name 1923 * @param[in] cur The edje cursor to advance 1924 * 1925 * @return @c true on success, @c false otherwise 1926 * 1927 * @ingroup Edje_Object_Part 1928 */ 1929 EAPI Eina_Bool edje_object_part_text_cursor_next(Evas_Object *obj, const char *part, Edje_Cursor cur); 1930 1931 /** 1932 * @brief Moves the cursor to the char above the current cursor position. 1933 * 1934 * @param[in] part The part name 1935 * @param[in] cur The edje cursor to work on 1936 * 1937 * @return @c true on success, @c false otherwise 1938 * 1939 * @ingroup Edje_Object_Part 1940 */ 1941 EAPI Eina_Bool edje_object_part_text_cursor_up(Evas_Object *obj, const char *part, Edje_Cursor cur); 1942 1943 /** 1944 * @brief Moves the cursor to the char below the current cursor position. 1945 * 1946 * @param[in] part The part name 1947 * @param[in] cur The edje cursor to work on 1948 * 1949 * @return @c true on success, @c false otherwise 1950 * 1951 * @ingroup Edje_Object_Part 1952 */ 1953 EAPI Eina_Bool edje_object_part_text_cursor_down(Evas_Object *obj, const char *part, Edje_Cursor cur); 1954 1955 /** 1956 * @brief Copies the cursor to another cursor. 1957 * 1958 * @param[in] part The part name 1959 * @param[in] src The cursor to copy from 1960 * @param[in] dst The cursor to copy to 1961 * 1962 * @ingroup Edje_Object_Part 1963 */ 1964 EAPI void edje_object_part_text_cursor_copy(Evas_Object *obj, const char *part, Edje_Cursor src, Edje_Cursor dst); 1965 1966 /** 1967 * @brief Returns the content (char) at the cursor position. @ref 1968 * evas_textblock_cursor_content_get 1969 * 1970 * You must free the return (if not @c null) after you are done with it. 1971 * 1972 * @param[in] part The part name 1973 * @param[in] cur The cursor to use 1974 * 1975 * @return The character string pointed to (may be a multi-byte utf8 sequence) 1976 * terminated by a null byte. 1977 * 1978 * @ingroup Edje_Object_Part 1979 */ 1980 EAPI char *edje_object_part_text_cursor_content_get(const Evas_Object *obj, const char * part, Edje_Cursor cur); 1981 1982 /** 1983 * @brief Returns the cursor geometry of the part relative to the edje object. 1984 * 1985 * @param[in] part The part name 1986 * @param[out] x Cursor X position 1987 * @param[out] y Cursor Y position 1988 * @param[out] w Cursor width 1989 * @param[out] h Cursor height 1990 * 1991 * @ingroup Edje_Object_Part 1992 */ 1993 EAPI void edje_object_part_text_cursor_geometry_get(const Evas_Object *obj, const char * part, int *x, int *y, int *w, int *h); 1994 1995 /** 1996 * @brief Hides visible last character for password mode. 1997 * 1998 * @param[in] part The part name 1999 * 2000 * @return @c true if the visible character is hidden. @c false if there is no 2001 * visible character or the object is not set for password mode. 2002 * 2003 * @since 1.18.0 2004 * 2005 * @ingroup Edje_Object_Part 2006 */ 2007 EAPI Eina_Bool edje_object_part_text_hide_visible_password(Evas_Object *obj, const char *part); 2008 2009 /** 2010 * @brief Returns whether the cursor points to a format. @ref 2011 * evas_textblock_cursor_is_format 2012 * 2013 * @param[in] part The part name 2014 * @param[in] cur The cursor to adjust. 2015 * 2016 * @return @c true if the cursor points to a format, @c false otherwise. 2017 * 2018 * @ingroup Edje_Object_Part 2019 */ 2020 EAPI Eina_Bool edje_object_part_text_cursor_is_format_get(const Evas_Object *obj, const char * part, Edje_Cursor cur); 2021 2022 /** 2023 * @brief Returns @c true if the cursor points to a visible format For example 2024 * \\t, \\n, item and etc. @ref evas_textblock_cursor_format_is_visible_get 2025 * 2026 * @param[in] part The part name 2027 * @param[in] cur The cursor to adjust. 2028 * 2029 * @return @c true if the cursor points to a visible format, @c false 2030 * otherwise. 2031 * 2032 * @ingroup Edje_Object_Part 2033 */ 2034 EAPI Eina_Bool edje_object_part_text_cursor_is_visible_format_get(const Evas_Object *obj, const char * part, Edje_Cursor cur); 2035 2036 /** 2037 * @brief Returns a list of Evas_Textblock_Rectangle anchor rectangles. 2038 * 2039 * This function return a list of Evas_Textblock_Rectangle anchor rectangles. 2040 * 2041 * @param[in] part The part name 2042 * @param[in] anchor The anchor name 2043 * 2044 * @return The list of anchor rects (const Evas_Textblock_Rectangle *), do not 2045 * modify! Geometry is relative to entry part. 2046 * 2047 * @ingroup Edje_Object_Part 2048 */ 2049 EAPI const Eina_List *edje_object_part_text_anchor_geometry_get(const Evas_Object *obj, const char * part, const char * anchor); 2050 2051 /** 2052 * @brief Returns a list of char anchor names. 2053 * 2054 * This function returns a list of char anchor names. 2055 * 2056 * @param[in] part The part name 2057 * 2058 * @return The list of anchors (const char *), do not modify! 2059 * 2060 * @ingroup Edje_Object_Part 2061 */ 2062 EAPI const Eina_List *edje_object_part_text_anchor_list_get(const Evas_Object *obj, const char * part); 2063 2064 /** 2065 * @brief Returns the text of the object part. 2066 * 2067 * This function returns the style associated with the textblock part. 2068 * 2069 * @param[in] part The part name 2070 * 2071 * @return The text string 2072 * 2073 * @since 1.2.0 2074 * 2075 * @ingroup Edje_Object_Part 2076 */ 2077 EAPI const char *edje_object_part_text_style_user_peek(const Evas_Object *obj, const char *part); 2078 2079 /** 2080 * @brief Sets the style of the 2081 * 2082 * This function sets the style associated with the textblock part. 2083 * 2084 * @param[in] part The part name 2085 * @param[in] style The style to set (textblock conventions). 2086 * 2087 * @since 1.2.0 2088 * 2089 * @ingroup Edje_Object_Part 2090 */ 2091 EAPI void edje_object_part_text_style_user_push(Evas_Object *obj, const char *part, const char *style); 2092 2093 /** 2094 * @brief Deletes the top style form the user style stack. 2095 * 2096 * @param[in] part The part name 2097 * 2098 * @since 1.2.0 2099 * 2100 * @ingroup Edje_Object_Part 2101 */ 2102 EAPI void edje_object_part_text_style_user_pop(Evas_Object *obj, const char *part); 2103 2104 /** 2105 * @brief Returns item geometry. 2106 * 2107 * This function return a list of Evas_Textblock_Rectangle item rectangles. 2108 * 2109 * @param[in] part The part name 2110 * @param[in] item The item name 2111 * @param[out] cx Item x return (relative to entry part) 2112 * @param[out] cy Item y return (relative to entry part) 2113 * @param[out] cw Item width return 2114 * @param[out] ch Item height return 2115 * 2116 * @return $1 if item exists, $0 if not 2117 * 2118 * @ingroup Edje_Object_Part 2119 */ 2120 EAPI Eina_Bool edje_object_part_text_item_geometry_get(const Evas_Object *obj, const char * part, const char * item, int *cx, int *cy, int *cw, int *ch); 2121 2122 /** 2123 * @brief Returns a list of char item names. 2124 * 2125 * This function returns a list of char item names. 2126 * 2127 * @param[in] part The part name 2128 * 2129 * @return The list of items (const char *), do not modify! 2130 * 2131 * @ingroup Edje_Object_Part 2132 */ 2133 EAPI const Eina_List *edje_object_part_text_item_list_get(const Evas_Object *obj, const char * part); 2134 2135 /** 2136 * @brief Adds a filter function for newly inserted text. 2137 * 2138 * Whenever text is inserted (not the same as set) into the given part, the 2139 * list of filter functions will be called to decide if and how the new text 2140 * will be accepted. There are three types of filters, EDJE_TEXT_FILTER_TEXT, 2141 * EDJE_TEXT_FILTER_FORMAT and EDJE_TEXT_FILTER_MARKUP. The text parameter in 2142 * the func filter can be modified by the user and it's up to him to free the 2143 * one passed if he's to change the pointer. If doing so, the newly set text 2144 * should be malloc'ed, as once all the filters are called Edje will free it. 2145 * If the text is to be rejected, freeing it and setting the pointer to @c null 2146 * will make Edje break out of the filter cycle and reject the inserted text. 2147 * 2148 * @warning This function will be deprecated because of difficulty in use. The 2149 * type(format, text, or markup) of text should be always checked in the filter 2150 * function for correct filtering. Please use 2151 * edje_object_text_markup_filter_callback_add() instead. There is no need to 2152 * check the type of text in the filter function because the text is always 2153 * markup. Warning: If you use this function with 2154 * edje_object_text_markup_filter_callback_add() together, all 2155 * Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions will be 2156 * executed, and then filtered text will be inserted. 2157 * 2158 * See also @ref edje_object_text_insert_filter_callback_del, 2159 * @ref edje_object_text_insert_filter_callback_del_full and 2160 * @ref edje_object_text_markup_filter_callback_add 2161 * 2162 * @param[in] part The part name 2163 * @param[in] func The callback function that will act as filter 2164 * @param[in] data User provided data to pass to the filter function 2165 * 2166 * @ingroup Edje_Object_Group 2167 */ 2168 EAPI void edje_object_text_insert_filter_callback_add(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data); 2169 2170 /** 2171 * @brief Deletes a function from the filter list. 2172 * 2173 * Delete the given func filter from the list in part. Returns the user data 2174 * pointer given when added. 2175 * 2176 * See also @ref edje_object_text_insert_filter_callback_add and 2177 * @ref edje_object_text_insert_filter_callback_del_full 2178 * 2179 * @param[in] part The part name 2180 * @param[in] func The function callback to remove 2181 * 2182 * @return The user data pointer if successful, or @c null otherwise 2183 * 2184 * @ingroup Edje_Object_Group 2185 */ 2186 EAPI void *edje_object_text_insert_filter_callback_del(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func); 2187 2188 /** 2189 * @brief Deletes a function and matching user data from the filter list. 2190 * 2191 * Delete the given func filter and data user data from the list in part. 2192 * Returns the user data pointer given when added. 2193 * 2194 * See also @ref edje_object_text_insert_filter_callback_add and 2195 * @ref edje_object_text_insert_filter_callback_del 2196 * 2197 * @param[in] part The part name 2198 * @param[in] func The function callback to remove 2199 * @param[in] data The data passed to the callback function 2200 * 2201 * @return The same data pointer if successful, or @c null otherwise 2202 * 2203 * @ingroup Edje_Object_Group 2204 */ 2205 EAPI void *edje_object_text_insert_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Text_Filter_Cb func, void *data); 2206 2207 /** 2208 * @brief Adds a markup filter function for newly inserted text. 2209 * 2210 * Whenever text is inserted (not the same as set) into the given part, the 2211 * list of markup filter functions will be called to decide if and how the new 2212 * text will be accepted. The text parameter in the func filter is always 2213 * markup. It can be modified by the user and it's up to him to free the one 2214 * passed if he's to change the pointer. If doing so, the newly set text should 2215 * be malloc'ed, as once all the filters are called Edje will free it. If the 2216 * text is to be rejected, freeing it and setting the pointer to @c null will 2217 * make Edje break out of the filter cycle and reject the inserted text. This 2218 * function is different from edje_object_text_insert_filter_callback_add() in 2219 * that the text parameter in the func filter is always markup. 2220 * 2221 * @warning If you use this function with 2222 * edje_object_text_insert_filter_callback_add() together, all 2223 * Edje_Text_Filter_Cb functions and Edje_Markup_Filter_Cb functions will be 2224 * executed, and then filtered text will be inserted. 2225 * 2226 * See also @ref edje_object_text_markup_filter_callback_del, 2227 * @ref edje_object_text_markup_filter_callback_del_full and 2228 * @ref edje_object_text_insert_filter_callback_add 2229 * 2230 * @param[in] part The part name 2231 * @param[in] func The callback function that will act as markup filter 2232 * @param[in] data User provided data to pass to the filter function 2233 * 2234 * @since 1.2.0 2235 * 2236 * @ingroup Edje_Object_Group 2237 */ 2238 EAPI void edje_object_text_markup_filter_callback_add(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data); 2239 2240 /** 2241 * @brief Deletes a function from the markup filter list. 2242 * 2243 * Delete the given func filter from the list in part. Returns the user data 2244 * pointer given when added. 2245 * 2246 * See also @ref edje_object_text_markup_filter_callback_add and 2247 * @ref edje_object_text_markup_filter_callback_del_full 2248 * 2249 * @param[in] part The part name 2250 * @param[in] func The function callback to remove 2251 * 2252 * @return The user data pointer if successful, or @c null otherwise 2253 * 2254 * @since 1.2.0 2255 * 2256 * @ingroup Edje_Object_Group 2257 */ 2258 EAPI void *edje_object_text_markup_filter_callback_del(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func); 2259 2260 /** 2261 * @brief Deletes a function and matching user data from the markup filter 2262 * list. 2263 * 2264 * Delete the given func filter and data user data from the list in part. 2265 * Returns the user data pointer given when added. 2266 * 2267 * See also @ref edje_object_text_markup_filter_callback_add and 2268 * @ref edje_object_text_markup_filter_callback_del 2269 * 2270 * @param[in] part The part name 2271 * @param[in] func The function callback to remove 2272 * @param[in] data The data passed to the callback function 2273 * 2274 * @return The same data pointer if successful, or @c null otherwise 2275 * 2276 * @since 1.2.0 2277 * 2278 * @ingroup Edje_Object_Group 2279 */ 2280 EAPI void *edje_object_text_markup_filter_callback_del_full(Evas_Object *obj, const char *part, Edje_Markup_Filter_Cb func, void *data); 2281 2282 /** 2283 * @brief This function inserts text as if the user has inserted it. 2284 * 2285 * This means it actually registers as a change and emits signals, triggers 2286 * callbacks as appropriate. 2287 * 2288 * @param[in] part The part name 2289 * @param[in] text The text string 2290 * 2291 * @since 1.2.0 2292 * 2293 * @ingroup Edje_Object_Part 2294 */ 2295 EAPI void edje_object_part_text_user_insert(const Evas_Object *obj, const char *part, const char *text); 2296 2297 /** 2298 * @brief Inserts text for an object part. 2299 * 2300 * This function inserts the text for an object part at the end; It does not 2301 * move the cursor. 2302 * 2303 * @param[in] part The part name 2304 * @param[in] text The text string 2305 * 2306 * @since 1.1 2307 * 2308 * @ingroup Edje_Object_Part 2309 */ 2310 EAPI void edje_object_part_text_append(Evas_Object *obj, const char *part, const char *text); 2311 2312 /** 2313 * @brief Sets the text for an object part, but converts HTML escapes to UTF8 2314 * 2315 * This converts the given string text to UTF8 assuming it contains HTML style 2316 * escapes like "&" and "©" etc. IF the part is of type TEXT, as 2317 * opposed to TEXTBLOCK. 2318 * 2319 * @param[in] part The part name 2320 * @param[in] text The text string 2321 * 2322 * @return @c true on success, @c false otherwise 2323 * 2324 * @since 1.2 2325 * 2326 * @ingroup Edje_Object_Part 2327 */ 2328 EAPI Eina_Bool edje_object_part_text_escaped_set(Evas_Object *obj, const char *part, const char *text); 2329 2330 /** 2331 * @brief Sets the raw (non escaped) text for an object part. 2332 * 2333 * This function will not do escape for you if it is a TEXTBLOCK part, that is, 2334 * if text contain tags, these tags will not be interpreted/parsed by 2335 * TEXTBLOCK. 2336 * 2337 * See also @ref edje_object_part_text_unescaped_get(). 2338 * 2339 * @param[in] part The part name 2340 * @param[in] text_to_escape The text string 2341 * 2342 * @return @c true on success, @c false otherwise 2343 * 2344 * @ingroup Edje_Object_Part 2345 */ 2346 EAPI Eina_Bool edje_object_part_text_unescaped_set(Evas_Object *obj, const char * part, const char *text_to_escape); 2347 2348 /** 2349 * @brief Returns the text of the object part, without escaping. 2350 * 2351 * This function is the counterpart of 2352 * @ref edje_object_part_text_unescaped_set(). Please notice that the result is 2353 * newly allocated memory and should be released with free() when done. 2354 * 2355 * See also @ref edje_object_part_text_unescaped_set(). 2356 * 2357 * @param[in] part The part name 2358 * 2359 * @return The text string 2360 * 2361 * @ingroup Edje_Object_Part 2362 */ 2363 EAPI char *edje_object_part_text_unescaped_get(const Evas_Object *obj, const char * part); 2364 2365 /** 2366 * @brief Inserts text for an object part. 2367 * 2368 * This function inserts the text for an object part just before the cursor 2369 * position. 2370 * 2371 * @param[in] part The part name 2372 * @param[in] text The text string 2373 * 2374 * @ingroup Edje_Object_Part 2375 */ 2376 EAPI void edje_object_part_text_insert(Evas_Object *obj, const char *part, const char *text); 2377 2378 /** 2379 * @brief Sets the autocapitalization type on the immodule. 2380 * 2381 * @param[in] part The part name 2382 * @param[in] autocapital_type The type of autocapitalization 2383 * 2384 * @since 1.1.0 2385 * 2386 * @ingroup Edje_Object_Part 2387 */ 2388 EAPI void edje_object_part_text_autocapital_type_set(Evas_Object *obj, const char *part, Edje_Text_Autocapital_Type autocapital_type); 2389 2390 /** 2391 * @brief Retrieves the autocapitalization type 2392 * 2393 * @param[in] part The part name 2394 * 2395 * @return The type of autocapitalization 2396 * 2397 * @since 1.1.0 2398 * 2399 * @ingroup Edje_Object_Part 2400 */ 2401 EAPI Edje_Text_Autocapital_Type edje_object_part_text_autocapital_type_get(const Evas_Object *obj, const char *part); 2402 2403 /** 2404 * @brief Sets whether the prediction is allowed or not. 2405 * 2406 * @param[in] part The part name 2407 * @param[in] prediction If @c true, the prediction feature is allowed. 2408 * 2409 * @since 1.2.0 2410 * 2411 * @ingroup Edje_Object_Part 2412 */ 2413 EAPI void edje_object_part_text_prediction_allow_set(Evas_Object *obj, const char *part, Eina_Bool prediction); 2414 2415 /** 2416 * @brief Gets whether the prediction is allowed or not. 2417 * 2418 * @param[in] part The part name 2419 * 2420 * @return If @c true, the prediction feature is allowed. 2421 * 2422 * @since 1.2.0 2423 * 2424 * @ingroup Edje_Object_Part 2425 */ 2426 EAPI Eina_Bool edje_object_part_text_prediction_allow_get(const Evas_Object *obj, const char *part); 2427 2428 /** 2429 * @brief Gets the input method context in entry. 2430 * 2431 * If ecore_imf was not available when edje was compiled, this function returns 2432 * @c null otherwise, the returned pointer is an Ecore_IMF 2433 * 2434 * @param[in] part The part name 2435 * 2436 * @return The input method context (Ecore_IMF_Context *) in entry 2437 * 2438 * @since 1.2.0 2439 * 2440 * @ingroup Edje_Object_Part 2441 */ 2442 EAPI void *edje_object_part_text_imf_context_get(const Evas_Object *obj, const char *part); 2443 2444 /** 2445 * @brief Resets the input method context if needed. 2446 * 2447 * This can be necessary in the case where modifying the buffer would confuse 2448 * on-going input method behavior 2449 * 2450 * @param[in] part The part name 2451 * 2452 * @since 1.2.0 2453 * 2454 * @ingroup Edje_Object_Part 2455 */ 2456 EAPI void edje_object_part_text_imf_context_reset(const Evas_Object *obj, const char *part); 2457 2458 /** 2459 * @brief Sets the input hint which allows input methods to fine-tune their 2460 * behavior. 2461 * 2462 * @param[in] part The part name 2463 * @param[in] input_hints Input hints 2464 * 2465 * @since 1.12.0 2466 * 2467 * @ingroup Edje_Object_Part 2468 */ 2469 EAPI void edje_object_part_text_input_hint_set(Evas_Object *obj, const char *part, Edje_Input_Hints input_hints); 2470 2471 /** 2472 * @brief Gets the value of input hint 2473 * 2474 * @param[in] part The part name 2475 * 2476 * @return Input hints 2477 * 2478 * @since 1.12.0 2479 * 2480 * @ingroup Edje_Object_Part 2481 */ 2482 EAPI Edje_Input_Hints edje_object_part_text_input_hint_get(const Evas_Object *obj, const char *part); 2483 2484 /** 2485 * @brief Shows the input panel (virtual keyboard) based on the input panel 2486 * property such as layout, autocapital types, and so on. 2487 * 2488 * Note that input panel is shown or hidden automatically according to the 2489 * focus state. This API can be used in the case of manually controlling by 2490 * using edje_object_part_text_input_panel_enabled_set. 2491 * 2492 * @param[in] part The part name 2493 * 2494 * @since 1.2.0 2495 * 2496 * @ingroup Edje_Object_Part 2497 */ 2498 EAPI void edje_object_part_text_input_panel_show(const Evas_Object *obj, const char *part); 2499 2500 /** 2501 * @brief Hides the input panel (virtual keyboard). See also 2502 * @ref edje_object_part_text_input_panel_show 2503 * 2504 * Note that input panel is shown or hidden automatically according to the 2505 * focus state. This API can be used in the case of manually controlling by 2506 * using edje_object_part_text_input_panel_enabled_set. 2507 * 2508 * @param[in] part The part name 2509 * 2510 * @since 1.2.0 2511 * 2512 * @ingroup Edje_Object_Part 2513 */ 2514 EAPI void edje_object_part_text_input_panel_hide(const Evas_Object *obj, const char *part); 2515 2516 /** 2517 * @brief Sets the input panel-specific data to deliver to the input panel. 2518 * 2519 * This API is used by applications to deliver specific data to the input 2520 * panel. The data format MUST be negotiated by both application and the input 2521 * panel. The size and format of data are defined by the input panel. 2522 * 2523 * @param[in] part The part name 2524 * @param[in] data The specific data to be set to the input panel. 2525 * @param[in] len The length of data, in bytes, to send to the input panel 2526 * 2527 * @since 1.2.0 2528 * 2529 * @ingroup Edje_Object_Part 2530 */ 2531 EAPI void edje_object_part_text_input_panel_imdata_set(Evas_Object *obj, const char *part, const void *data, int len); 2532 2533 /** 2534 * @brief Gets the specific data of the current active input panel. 2535 * 2536 * @param[in] part The part name 2537 * @param[in] data The specific data to be set to the input panel. 2538 * @param[out] len The length of data, in bytes, to send to the input panel 2539 * 2540 * @return FIXME: void needed here? 2541 * 2542 * @since 1.2.0 2543 * 2544 * @ingroup Edje_Object_Part 2545 */ 2546 EAPI void edje_object_part_text_input_panel_imdata_get(const Evas_Object *obj, const char *part, void *data, int *len); 2547 2548 /** 2549 * @brief Sets the layout of the input panel. 2550 * 2551 * The layout of the input panel or virtual keyboard can make it easier or 2552 * harder to enter content. This allows you to hint what kind of input you are 2553 * expecting to enter and thus have the input panel automatically come up with 2554 * the right mode. 2555 * 2556 * @param[in] part The part name 2557 * @param[in] layout Layout type of the input panel 2558 * 2559 * @since 1.1 2560 * 2561 * @ingroup Edje_Object_Part 2562 */ 2563 EAPI void edje_object_part_text_input_panel_layout_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Layout layout); 2564 2565 /** 2566 * @brief Gets the layout of the input panel. 2567 * 2568 * See also @ref edje_object_part_text_input_panel_layout_set 2569 * 2570 * @param[in] part The part name 2571 * 2572 * @return Layout type of the input panel 2573 * 2574 * @since 1.1 2575 * 2576 * @ingroup Edje_Object_Part 2577 */ 2578 EAPI Edje_Input_Panel_Layout edje_object_part_text_input_panel_layout_get(const Evas_Object *obj, const char *part); 2579 2580 /** 2581 * @brief Sets the language mode of the input panel. 2582 * 2583 * This API can be used if you want to show the Alphabet keyboard. 2584 * 2585 * @param[in] part The part name 2586 * @param[in] lang The language to be set to the input panel. 2587 * 2588 * @since 1.2.0 2589 * 2590 * @ingroup Edje_Object_Part 2591 */ 2592 EAPI void edje_object_part_text_input_panel_language_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Lang lang); 2593 2594 /** 2595 * @brief Gets the language mode of the input panel. 2596 * 2597 * See also @ref edje_object_part_text_input_panel_language_set for more 2598 * details. 2599 * 2600 * @param[in] part The part name 2601 * 2602 * @return The language to be set to the input panel. 2603 * 2604 * @since 1.2.0 2605 * 2606 * @ingroup Edje_Object_Part 2607 */ 2608 EAPI Edje_Input_Panel_Lang edje_object_part_text_input_panel_language_get(const Evas_Object *obj, const char *part); 2609 2610 /** 2611 * @brief Sets the layout variation of the input panel. 2612 * 2613 * The layout variation of the input panel or virtual keyboard can make it 2614 * easier or harder to enter content. This allows you to hint what kind of 2615 * input you are expecting to enter and thus have the input panel automatically 2616 * come up with the right mode. 2617 * 2618 * @param[in] part The part name 2619 * @param[in] variation Layout variation type 2620 * 2621 * @since 1.8 2622 * 2623 * @ingroup Edje_Object_Part 2624 */ 2625 EAPI void edje_object_part_text_input_panel_layout_variation_set(Evas_Object *obj, const char *part, int variation); 2626 2627 /** 2628 * @brief Gets the layout variation of the input panel. 2629 * 2630 * See also @ref edje_object_part_text_input_panel_layout_variation_set 2631 * 2632 * @param[in] part The part name 2633 * 2634 * @return Layout variation type 2635 * 2636 * @since 1.8 2637 * 2638 * @ingroup Edje_Object_Part 2639 */ 2640 EAPI int edje_object_part_text_input_panel_layout_variation_get(const Evas_Object *obj, const char *part); 2641 2642 /** 2643 * @brief Sets the attribute to show the input panel automatically. 2644 * 2645 * @param[in] part The part name 2646 * @param[in] enabled If @c true, the input panel is appeared when entry is 2647 * clicked or has a focus 2648 * 2649 * @since 1.1.0 2650 * 2651 * @ingroup Edje_Object_Part 2652 */ 2653 EAPI void edje_object_part_text_input_panel_enabled_set(Evas_Object *obj, const char *part, Eina_Bool enabled); 2654 2655 /** 2656 * @brief Retrieves the attribute to show the input panel automatically. See 2657 * also @ref edje_object_part_text_input_panel_enabled_set 2658 * 2659 * @param[in] part The part name 2660 * 2661 * @return If @c true, the input panel is appeared when entry is clicked or has 2662 * a focus 2663 * 2664 * @since 1.1.0 2665 * 2666 * @ingroup Edje_Object_Part 2667 */ 2668 EAPI Eina_Bool edje_object_part_text_input_panel_enabled_get(const Evas_Object *obj, const char *part); 2669 2670 /** 2671 * @brief Sets the return key on the input panel to be disabled. 2672 * 2673 * @param[in] part The part name 2674 * @param[in] disabled The state 2675 * 2676 * @since 1.2.0 2677 * 2678 * @ingroup Edje_Object_Part 2679 */ 2680 EAPI void edje_object_part_text_input_panel_return_key_disabled_set(Evas_Object *obj, const char *part, Eina_Bool disabled); 2681 2682 /** 2683 * @brief Gets whether the return key on the input panel should be disabled or 2684 * not. 2685 * 2686 * @param[in] part The part name 2687 * 2688 * @return The state 2689 * 2690 * @since 1.2.0 2691 * 2692 * @ingroup Edje_Object_Part 2693 */ 2694 EAPI Eina_Bool edje_object_part_text_input_panel_return_key_disabled_get(const Evas_Object *obj, const char *part); 2695 2696 /** 2697 * @brief Sets the "return" key type. This type is used to set string or icon 2698 * on the "return" key of the input panel. 2699 * 2700 * An input panel displays the string or icon associated with this type 2701 * 2702 * @param[in] part The part name 2703 * @param[in] return_key_type The type of "return" key on the input panel 2704 * 2705 * @since 1.2.0 2706 * 2707 * @ingroup Edje_Object_Part 2708 */ 2709 EAPI void edje_object_part_text_input_panel_return_key_type_set(Evas_Object *obj, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type); 2710 2711 /** 2712 * @brief Gets the "return" key type. 2713 * 2714 * See also @ref edje_object_part_text_input_panel_return_key_type_set() for 2715 * more details 2716 * 2717 * @param[in] part The part name 2718 * 2719 * @return The type of "return" key on the input panel 2720 * 2721 * @since 1.2.0 2722 * 2723 * @ingroup Edje_Object_Part 2724 */ 2725 EAPI Edje_Input_Panel_Return_Key_Type edje_object_part_text_input_panel_return_key_type_get(const Evas_Object *obj, const char *part); 2726 2727 /** 2728 * @brief Sets the attribute to show the input panel in case of only a user's 2729 * explicit Mouse Up event. It doesn't request to show the input panel even 2730 * though it has focus. 2731 * 2732 * @param[in] part The part name 2733 * @param[in] ondemand If @c true, the input panel will be shown in case of 2734 * only Mouse up event. (Focus event will be ignored.) 2735 * 2736 * @since 1.9.0 2737 * 2738 * @ingroup Edje_Object_Part 2739 */ 2740 EAPI void edje_object_part_text_input_panel_show_on_demand_set(Evas_Object *obj, const char *part, Eina_Bool ondemand); 2741 2742 /** 2743 * @brief Gets the attribute to show the input panel in case of only a user's 2744 * explicit Mouse Up event. 2745 * 2746 * @param[in] part The part name 2747 * 2748 * @return If @c true, the input panel will be shown in case of only Mouse up 2749 * event. (Focus event will be ignored.) 2750 * 2751 * @since 1.9.0 2752 * 2753 * @ingroup Edje_Object_Part 2754 */ 2755 EAPI Eina_Bool edje_object_part_text_input_panel_show_on_demand_get(const Evas_Object *obj, const char *part); 2756 2757 /** 2758 * @brief Sets the prediction hint to use an intelligent reply suggestion 2759 * service. 2760 * 2761 * @param[in] part The part name 2762 * @param[in] prediction_hint Prediction hint 2763 * 2764 * @since 1.20.0 2765 * 2766 * @ingroup Edje_Object_Part 2767 */ 2768 EAPI void edje_object_part_text_prediction_hint_set(Evas_Object *obj, const char *part, const char *prediction_hint); 2769 2770 /** 2771 * @brief Sets the prediction hint data at the specified key. 2772 * 2773 * @param[in] part The part name 2774 * @param[in] key The key of the prediction hint 2775 * @param[in] value The data to replace 2776 * 2777 * @return @c true on success, @c false otherwise 2778 * 2779 * @since 1.21.0 2780 * 2781 * @ingroup Edje_Object_Part 2782 */ 2783 EAPI Eina_Bool edje_object_part_text_prediction_hint_hash_set(Evas_Object *obj, const char *part, const char *key, const char *value); 2784 2785 /** 2786 * @brief Removes the prediction hint data identified by a key 2787 * 2788 * @param[in] part The part name 2789 * @param[in] key The key of the prediction hint 2790 * 2791 * @return @c true on success, @c false otherwise 2792 * 2793 * @since 1.21.0 2794 * 2795 * @ingroup Edje_Object_Part 2796 */ 2797 EAPI Eina_Bool edje_object_part_text_prediction_hint_hash_del(Evas_Object *obj, const char *part, const char *key); 2798 2799 /** 2800 * @brief Starts selecting at current cursor position 2801 * 2802 * @param[in] part The part name 2803 * 2804 * @ingroup Edje_Object_Part 2805 */ 2806 EAPI void edje_object_part_text_select_begin(const Evas_Object *obj, const char *part); 2807 2808 /** 2809 * @brief Aborts any selection action on a part. 2810 * 2811 * @param[in] part The part name 2812 * 2813 * @ingroup Edje_Object_Part 2814 */ 2815 EAPI void edje_object_part_text_select_abort(const Evas_Object *obj, const char *part); 2816 2817 /** 2818 * @brief Extends the current selection to the current cursor position 2819 * 2820 * @param[in] part The part name 2821 * 2822 * @ingroup Edje_Object_Part 2823 */ 2824 EAPI void edje_object_part_text_select_extend(const Evas_Object *obj, const char *part); 2825 2826 /** 2827 * @brief Sets the selection to be everything. 2828 * 2829 * This function selects all text of the object of the part. 2830 * 2831 * @param[in] part The part name 2832 * 2833 * @ingroup Edje_Object_Part 2834 */ 2835 EAPI void edje_object_part_text_select_all(const Evas_Object *obj, const char *part); 2836 2837 /** 2838 * @brief Sets the selection to be none. 2839 * 2840 * This function sets the selection text to be none. 2841 * 2842 * @param[in] part The part name 2843 * 2844 * @ingroup Edje_Object_Part 2845 */ 2846 EAPI void edje_object_part_text_select_none(const Evas_Object *obj, const char *part); 2847 2848 /** 2849 * @brief Returns the selection text of the object part. 2850 * 2851 * This function returns selection text of the object part. 2852 * 2853 * See also @ref edje_object_part_text_select_all() and 2854 * @ref edje_object_part_text_select_none() 2855 * 2856 * @param[in] part The part name 2857 * 2858 * @return The text string 2859 * 2860 * @ingroup Edje_Object_Part 2861 */ 2862 EAPI const char *edje_object_part_text_selection_get(const Evas_Object *obj, const char *part); 2863 2864 /** 2865 * @brief Whether this object is playing or not. 2866 * 2867 * This property indicates whether the object is running or not. If stopped (or 2868 * paused), all transitions are disabled and programs stop running, until 2869 * resumed. 2870 * 2871 * If play is disabled, the object will remain the same, and its parts will not 2872 * change state. Note that play can be disabled during a transition between 2873 * states, effectively freezing the object in flight. When paused, no events 2874 * will be processed or sent. 2875 * 2876 * Setting to @c true resumes playing from the current state. 2877 * 2878 * Start or stop playing programs in this object. 2879 * 2880 * @param[in] play The play state, @c true by default. 2881 * 2882 * @ingroup Edje_Object_Group 2883 */ 2884 EAPI void edje_object_play_set(Evas_Object *obj, Eina_Bool play); 2885 2886 /** 2887 * @brief Whether this object is playing or not. 2888 * 2889 * This property indicates whether the object is running or not. If stopped (or 2890 * paused), all transitions are disabled and programs stop running, until 2891 * resumed. 2892 * 2893 * If play is disabled, the object will remain the same, and its parts will not 2894 * change state. Note that play can be disabled during a transition between 2895 * states, effectively freezing the object in flight. When paused, no events 2896 * will be processed or sent. 2897 * 2898 * Setting to @c true resumes playing from the current state. 2899 * 2900 * Get the current state of play, @c true by default. 2901 * 2902 * @return The play state, @c true by default. 2903 * 2904 * @ingroup Edje_Object_Group 2905 */ 2906 EAPI Eina_Bool edje_object_play_get(const Evas_Object *obj); 2907 2908 /** 2909 * @brief Transition duration factor. 2910 * 2911 * This defines a multiplier for the duration of transitions as they are 2912 * defined in EDC. By default this factor is 1.0, which means animations play 2913 * at the same speed as described in EDC. 2914 * 2915 * Sets transition duration factor. 2916 * 2917 * @param[in] scale The transition duration factor. 2918 * 2919 * @ingroup Edje_Object_Group 2920 */ 2921 EAPI void edje_object_transition_duration_factor_set(Evas_Object *obj, double scale); 2922 2923 /** 2924 * @brief Transition duration factor. 2925 * 2926 * This defines a multiplier for the duration of transitions as they are 2927 * defined in EDC. By default this factor is 1.0, which means animations play 2928 * at the same speed as described in EDC. 2929 * 2930 * Gets transition duration factor. 2931 * 2932 * @return The transition duration factor. 2933 * 2934 * @ingroup Edje_Object_Group 2935 */ 2936 EAPI double edje_object_transition_duration_factor_get(const Evas_Object *obj); 2937 2938 /** 2939 * @brief Gets the minimum size specified -- as an EDC property -- for a given 2940 * Edje object 2941 * 2942 * This function retrieves the obj object's minimum size values, as declared in 2943 * its EDC group definition. For instance, for an Edje object of minimum size 2944 * 100x100 pixels: collections { group { name: "a_group"; min: 100 100; } } 2945 * 2946 * @note If the @c min EDC property was not declared for this object, this call 2947 * will return 0x0. 2948 * 2949 * @note On failure, this function also return 0x0. 2950 * 2951 * See also @ref edje_object_size_max_get. 2952 * 2953 * @param[out] minw Pointer to a variable where to store the minimum width 2954 * @param[out] minh Pointer to a variable where to store the minimum height 2955 * 2956 * @ingroup Edje_Object_Group 2957 */ 2958 EAPI void edje_object_size_min_get(const Evas_Object *obj, int *minw, int *minh); 2959 2960 /** 2961 * @brief Gets the maximum size specified -- as an EDC property -- for a given 2962 * Edje object 2963 * 2964 * This function retrieves the object's maximum size values, as declared in its 2965 * EDC group definition. For instance, for an Edje object of maximum size 2966 * 100x100 pixels: collections { group { name: "a_group"; max: 100 100; } } 2967 * 2968 * @note If the @c max EDC property was not declared for the object, this call 2969 * will return the maximum size a given Edje object may have, for each axis. 2970 * 2971 * @note On failure, this function will return 0x0. 2972 * 2973 * See also @ref edje_object_size_min_get. 2974 * 2975 * @param[out] maxw The maximum width 2976 * @param[out] maxh The maximum height 2977 * 2978 * @ingroup Edje_Object_Group 2979 */ 2980 EAPI void edje_object_size_max_get(const Evas_Object *obj, int *maxw, int *maxh); 2981 2982 /** 2983 * @brief Checks if a part exists in a given Edje object's group definition. 2984 * 2985 * This function returns if a given part exists in the Edje group bound to this 2986 * object (with @ref edje_object_file_set()). 2987 * 2988 * This call is useful, for example, when one could expect or not a given GUI 2989 * element, depending on the theme applied to the object. 2990 * 2991 * @param[in] part The part's name to check for existence in obj's group 2992 * 2993 * @return @c true if the Edje part exists in obj's group, or @c false 2994 * otherwise (and on errors) 2995 * 2996 * @ingroup Edje_Object_Part 2997 */ 2998 EAPI Eina_Bool edje_object_part_exists(const Evas_Object *obj, const char *part); 2999 3000 /** 3001 * @brief Sets the function that provides item objects for named items in an 3002 * edje entry text 3003 * 3004 * Item objects may be deleted any time by Edje, and will be deleted when the 3005 * Edje object is deleted (or file is set to a new file). 3006 * 3007 * @param[in] obj The object. 3008 * @param[in] func The function to call (or @c null to disable) to get item 3009 * objects 3010 * @param[in] data The data pointer to pass to the func callback 3011 * 3012 * @ingroup Edje_Object_Group 3013 */ 3014 EAPI void edje_object_item_provider_set(Edje_Object *obj, Edje_Item_Provider_Cb func, void *data); 3015 3016 3017 /** 3018 * @brief Gets the description of an object color class. 3019 * 3020 * This function gets the description of a color class in use by an object. 3021 * 3022 * @param[in] color_class Color class description 3023 * 3024 * @return The description of the target color class or @c null if not found 3025 * 3026 * @ingroup Edje_Object_Color_Class 3027 */ 3028 EAPI const char *edje_object_color_class_description_get(const Edje_Object *obj, const char * color_class); 3029 3030 /** 3031 * @defgroup Edje_Perspective Edje Perspective 3032 * @ingroup Edje_Object_Group 3033 * 3034 * @brief Functions that deal with 3D projection of an 2D object. 3035 * 3036 * @{ 3037 */ 3038 3039 /** 3040 * @brief Creates a new perspective in the given canvas. 3041 * 3042 * @param e The given canvas (Evas). 3043 * @return An @ref Edje_Perspective object for this canvas, or @c NULL on errors. 3044 * 3045 * This function creates a perspective object that can be set on an Edje 3046 * object, or globally to all Edje objects on this canvas. 3047 * 3048 * @see edje_perspective_set() 3049 * @see edje_perspective_free() 3050 */ 3051 EAPI Edje_Perspective *edje_perspective_new (Evas *e); 3052 /** 3053 * @brief Deletes the given perspective object. 3054 * 3055 * @param ps A valid perspective object, or @c NULL. 3056 * 3057 * This function will delete the perspective object. If the perspective 3058 * effect was being applied to any Edje object or part, this effect won't be 3059 * applied anymore. 3060 * 3061 * @see edje_perspective_new() 3062 */ 3063 EAPI void edje_perspective_free (Edje_Perspective *ps); 3064 /** 3065 * @brief Sets up the transform for this perspective object. 3066 * 3067 * This sets the parameters of the perspective transformation. X, Y and Z 3068 * values are used. The px and py points specify the "infinite distance" point 3069 * in the 3D conversion (where all lines converge to like when artists draw 3070 * 3D by hand). The @p z0 value specifies the z value at which there is a 1:1 3071 * mapping between spatial coordinates and screen coordinates. Any points 3072 * on this z value will not have their X and Y values modified in the transform. 3073 * Those further away (Z value higher) will shrink into the distance, and 3074 * those less than this value will expand and become bigger. The @p foc value 3075 * determines the "focal length" of the camera. This is in reality the distance 3076 * between the camera lens plane itself (at or closer than this rendering 3077 * results are undefined) and the "z0" z value. This allows for some "depth" 3078 * control and @p foc must be greater than 0. 3079 * 3080 * @param ps The perspective object 3081 * @param px The perspective distance X coordinate 3082 * @param py The perspective distance Y coordinate 3083 * @param z0 The "0" z plane value 3084 * @param foc The focal distance 3085 */ 3086 EAPI void edje_perspective_set (Edje_Perspective *ps, Evas_Coord px, Evas_Coord py, Evas_Coord z0, Evas_Coord foc); 3087 /** 3088 * @brief Makes this perspective object be global for its canvas. 3089 * 3090 * @param ps The given perspective object 3091 * @param global @c EINA_TRUE if the perspective should be global, @c 3092 * EINA_FALSE otherwise. 3093 * 3094 * The canvas which this perspective object is being set as global is the one 3095 * given as argument upon the object creation (the @p evas parameter on the 3096 * function @c edje_perspective_new(evas) ). 3097 * 3098 * There can be only one global perspective object set per canvas, and if 3099 * a perspective object is set to global when there was already another 3100 * global perspective set, the old one will be set as non-global. 3101 * 3102 * A global perspective just affects a part if its Edje object doesn't have a 3103 * perspective object set to it, and if the part doesn't point to another 3104 * part to be used as perspective. 3105 * 3106 * @see edje_object_perspective_set() 3107 * @see edje_perspective_global_get() 3108 * @see edje_perspective_new() 3109 */ 3110 EAPI void edje_perspective_global_set (Edje_Perspective *ps, Eina_Bool global); 3111 /** 3112 * @brief Gets whether the given perspective object is global or not. 3113 * 3114 * @param ps The given perspective object. 3115 * @return @c EINA_TRUE if this perspective object is global, @c EINA_FALSE 3116 * otherwise. 3117 * 3118 * @see edje_perspective_global_set() 3119 */ 3120 EAPI Eina_Bool edje_perspective_global_get (const Edje_Perspective *ps); 3121 /** 3122 * @brief Gets the global perspective object set for this canvas. 3123 * 3124 * @param e The given canvas (Evas). 3125 * @return The perspective object set as global for this canvas. Or @c NULL 3126 * if there is no global perspective set and on errors. 3127 * 3128 * This function will return the perspective object that was set as global 3129 * with edje_perspective_global_set(). 3130 * 3131 * @see edje_perspective_global_set() 3132 * @see edje_perspective_global_get() 3133 */ 3134 EAPI const Edje_Perspective *edje_evas_global_perspective_get(const Evas *e); 3135 3136 /** 3137 * @brief Sets the given perspective object on this Edje object. 3138 * 3139 * Make the given perspective object be the default perspective for this Edje 3140 * object. 3141 * 3142 * There can be only one perspective object per Edje object, and if a previous 3143 * one was set, it will be removed and the new perspective object will be used. 3144 * 3145 * An Edje perspective will only affect a part if it doesn't point to another 3146 * part to be used as perspective. 3147 * 3148 * @ref edje_object_perspective_new() See also 3149 * @ref edje_object_perspective_get() @ref edje_perspective_set() 3150 * 3151 * @param[in] obj The object. 3152 * @param[in] ps The perspective object that will be used. 3153 */ 3154 EAPI void edje_object_perspective_set(Evas_Object *obj, Edje_Perspective *ps); 3155 3156 /** 3157 * @brief Gets the current perspective used on this Edje object. 3158 * 3159 * See also @ref edje_object_perspective_set() 3160 * 3161 * @param[in] obj The object. 3162 * 3163 * @return The perspective object that will be used. 3164 */ 3165 EAPI const Edje_Perspective *edje_object_perspective_get(const Evas_Object *obj); 3166 3167 /** 3168 * @} 3169 */ 3170 3171 /** 3172 * @brief Sets Edje text class for edje file (if loaded) 3173 * 3174 * This function sets the text class for All Edje Objects created from Edje file. 3175 * (if edje file loaded before) 3176 * 3177 * @param[in] file edje file path 3178 * @param[in] text_class The text class name 3179 * @param[in] font Font name 3180 * @param[in] size Font Size 3181 * 3182 * @return @c true, on success or @c false, on error 3183 * 3184 * @ingroup Edje_Object_Text_Class 3185 * 3186 */ 3187 EAPI Eina_Bool edje_file_text_class_set(const char *file, const char *text_class, const char *font, Evas_Font_Size size); 3188 3189 /** 3190 * @brief Delete the file text class. 3191 * 3192 * This function deletes any values at the file level for the specified 3193 * file and text class. 3194 * 3195 * @param[in] text_class The text class to be deleted. 3196 * 3197 * @ingroup Edje_Object_Text_Class 3198 * 3199 */ 3200 EAPI Eina_Bool edje_file_text_class_del(const char *file, const char *text_class); 3201 3202 /** 3203 * @brief Gets font and font size from edje file if loaded. 3204 * 3205 * This function gets the font and the font size from the file text class. 3206 * 3207 * @param[in] text_class The text class name 3208 * @param[out] font Font name 3209 * @param[out] size Font Size 3210 * 3211 * @return @c true, on success or @c false, on error 3212 * 3213 * @ingroup Edje_Object_Text_Class 3214 * 3215 */ 3216 EAPI Eina_Bool edje_file_text_class_get(const char *file, const char * text_class, const char **font, Evas_Font_Size *size); 3217 3218 3219 /** 3220 * @defgroup Edje_Object_Part Edje Part 3221 * 3222 * @brief Functions that deal with layout components 3223 * 3224 * Parts are layout components, but as a layout, they are objects too. 3225 * 3226 * There are several types of parts, these types can be divided into two 3227 * main categories, the first being containers. Containers are parts 3228 * that are in effect a group of elements. The second group is that of 3229 * the elements, these part types may not contain others. 3230 * 3231 * This section has some functions specific for some types and others that 3232 * could be applied to any type. 3233 * 3234 * @ingroup Edje_Object_Group 3235 * 3236 * @{ 3237 */ 3238 3239 /** 3240 * @typedef Edje_Part_Type 3241 * 3242 * All possible "part" types in Edje 3243 */ 3244 typedef enum _Edje_Part_Type 3245 { 3246 EDJE_PART_TYPE_NONE = 0, /**< None type value */ 3247 EDJE_PART_TYPE_RECTANGLE = 1, /**< Rectangle type value */ 3248 EDJE_PART_TYPE_TEXT = 2, /**< Text type value */ 3249 EDJE_PART_TYPE_IMAGE = 3, /**< Image type value */ 3250 EDJE_PART_TYPE_SWALLOW = 4, /**< Swallow type value */ 3251 EDJE_PART_TYPE_TEXTBLOCK = 5, /**< Text block type value */ 3252 EDJE_PART_TYPE_GRADIENT = 6, /**< Gradient type value */ 3253 EDJE_PART_TYPE_GROUP = 7, /**< Group type value */ 3254 EDJE_PART_TYPE_BOX = 8, /**< Box type value */ 3255 EDJE_PART_TYPE_TABLE = 9, /**< Table type value */ 3256 EDJE_PART_TYPE_EXTERNAL = 10, /**< External type value */ 3257 EDJE_PART_TYPE_PROXY = 11, /**< Proxy type value */ 3258 EDJE_PART_TYPE_SPACER = 12, /**< Spacer type value @since 1.7 */ 3259 EDJE_PART_TYPE_MESH_NODE = 13, 3260 EDJE_PART_TYPE_LIGHT = 14, 3261 EDJE_PART_TYPE_CAMERA = 15, 3262 EDJE_PART_TYPE_SNAPSHOT = 16, /**< Snapshot @since 1.16 */ 3263 EDJE_PART_TYPE_VECTOR = 17, /**< Vector @since 1.18 */ 3264 EDJE_PART_TYPE_LAST = 18 /**< Last type value */ 3265 } Edje_Part_Type; 3266 /** 3267 * @} 3268 */ 3269 3270 #include "efl_canvas_layout_eo.legacy.h" 3271 #include "edje_edit_eo.legacy.h" 3272 #include "efl_layout_group_eo.legacy.h" 3273