gwy

1 # This is dummy GENERATED file used for generation of documentation

2 -class Axis:

3 - def __init__( orientation ):

4 """ 5 Creates a new axis. 6 7 8 @return: New axis as a B{C{GtkWidget}}. 9 10 """ 11 return None

12 - def set_logarithmic( is_logarithmic ):

13 """ 14 Sets logarithmic mode. 15 16 @param is_logarithmic: logarithmic mode I{(bool)} 17 @return: 18 """ 19 return None

20 - def set_visible( is_visible ):

21 """ 22 Sets the visibility of an axis. 23 24 @param is_visible: visibility I{(bool)} 25 @return: 26 """ 27 return None

28 - def is_visible( ):

29 """ 30 Determines whether axis is set to be visible. 31 32 Return: B{C{True}} if B{C{axis}} is set to be visible. 33 34 @return: 35 """ 36 return None

37 - def is_logarithmic( ):

38 """ 39 Determines whether axis is set to be locarithmic. 40 41 42 @return: B{C{True}} if B{C{axis}} is logarithmic. 43 44 """ 45 return None

46 - def get_orientation( ):

47 """ 48 Gets the orientation of an axis. 49 50 51 @return: The orientation. 52 53 """ 54 return None

55 - def set_auto( is_auto ):

56 """ 57 Enables or disables automatic axis adjustmet. 58 59 @param is_auto: B{C{True}} to enable automatic tick size and distribution adjustment, 60 B{C{False}} to disable it. I{(bool)} 61 @return: 62 """ 63 return None

64 - def request_range( min , max ):

65 """ 66 Sets the requisition of axis boundaries. 67 68 The axis will adjust the boundaries to satisfy requisition but still have 69 reasonable tick values and spacing. Use L{Axis.get_range}() to obtain the 70 boundaries the axis actually decided to use. 71 72 @param min: Minimum requisition (min boundary value). I{(float)} 73 @param max: Maximum requisition (max boundary value). I{(float)} 74 @return: 75 """ 76 return None

77 - def get_range( min , max ):

78 """ 79 Gets the actual boundaries of an axis. 80 81 @param min: Location to store actual axis minimum, or B{C{NULL}}. I{(float)} 82 @param max: Location to store actual axis maximum, or B{C{NULL}}. I{(float)} 83 @return: 84 """ 85 return None

86 - def get_requested_range( min , max ):

87 """ 88 Gets the requested boundaries of an axis. 89 90 @param min: Location to store requested axis minimum, or B{C{NULL}}. I{(float)} 91 @param max: Location to store requested axis maximum, or B{C{NULL}}. I{(float)} 92 @return: 93 """ 94 return None

95 - def get_magnification( ):

96 """ 97 98 @return: Magnification value of the axis 99 100 """ 101 return None

102 - def get_magnification_string( ):

103 """ 104 Gets the magnification string of an axis. 105 106 107 @return: Magnification string of the axis, owned by the axis. 108 109 """ 110 return None

111 - def set_label( label ):

112 """ 113 Sets the label text of an axis. 114 115 @param label: The new label text (it can be B{C{NULL}} for an empty label). I{(string)} 116 @return: 117 """ 118 return None

119 - def get_label( ):

120 """ 121 Gets the label of an axis. 122 123 124 @return: Axis label as a string owned by B{C{axis}}. 125 126 """ 127 return None

128 - def set_si_unit( unit ):

129 """ 130 Sets the axis unit. This will be added automatically 131 to the label. B{C{unit}} is duplicated. 132 133 @param unit: axis unit I{(L{SIUnit})} 134 @return: 135 """ 136 return None

137 - def enable_label_edit( enable ):

138 """ 139 Enables/disables user to change axis label by clicking on axis widget. 140 141 @param enable: enable/disable user to change axis label I{(bool)} 142 @return: 143 """ 144 return None

145 - def draw_on_drawable( drawable , gc , xmin , ymin , width , height ):

146 """ 147 Draws the x and y-axis on a drawable 148 149 @param drawable: Drawable to draw on. I{(GdkDrawable*)} 150 @param gc: Graphics context. 151 It is modified by this function unpredictably. I{(GdkGC*)} 152 @param xmin: The minimum x-axis value. I{(int)} 153 @param ymin: The minimum y-axis value. I{(int)} 154 @param width: The width of the x-axis. I{(int)} 155 @param height: The height of the y-axis. I{(int)} 156 @return: 157 """ 158 return None

159 - def UNIMPLEMENTED_export_vector( xmin , ymin , width , height , fontsize ):

160 """ 161 162 @param xmin: I{(int)} 163 @param ymin: I{(int)} 164 @param width: width of the x-axis I{(int)} 165 @param height: hieght of the y-axis I{(int)} 166 @param fontsize: I{(int)} 167 @return: 168 """ 169 return None

170 - def get_major_ticks( nticks ):

171 """ 172 Gets the positions of major ticks of an axis. 173 174 175 @param nticks: Location to store the number of returned ticks. I{(int)} 176 @return: The positions of axis major ticks (as real values, not pixels). 177 The returned array is owned by the axis. 178 179 """ 180 return None

181 -class ColorAxis:

182 - def __init__( orientation ):

183 """ 184 Creates a new color axis. 185 186 187 @return: The newly created color axis as a B{C{GtkWidget}}. 188 189 """ 190 return None

191 - def get_range( min , max ):

192 """ 193 Gets the range of a color axis. 194 195 @param min: Location to store the range maximum (or B{C{NULL}}). I{(float)} 196 @param max: Location to store the range minimum (or B{C{NULL}}). I{(float)} 197 @return: 198 """ 199 return None

200 - def set_range( min , max ):

201 """ 202 Sets the range of a color axis. 203 204 @param min: The range minimum. I{(float)} 205 @param max: The range maximum. I{(float)} 206 @return: 207 """ 208 return None

209 - def get_si_unit( ):

210 """ 211 Gets the SI unit a color axis displays. 212 213 214 @return: The SI unit. 215 216 """ 217 return None

218 - def set_si_unit( unit ):

219 """ 220 Sets the SI unit a color axis displays. 221 222 @param unit: A SI unit to display next to minimum and maximum value. I{(L{SIUnit})} 223 @return: 224 """ 225 return None

226 - def set_gradient( gradient ):

227 """ 228 Sets the color gradient a color axis should use. 229 230 @param gradient: Name of gradient B{C{axis}} should use. It should exist. I{(string)} 231 @return: 232 """ 233 return None

234 - def get_gradient( ):

235 """ 236 Gets the color gradient a color axis uses. 237 238 239 @return: The color gradient. 240 241 """ 242 return None

243 - def get_ticks_style( ):

244 """ 245 Gets ticks style of a color axis. 246 247 248 @return: The ticks style. 249 250 """ 251 return None

252 - def set_ticks_style( ticks_style ):

253 """ 254 Sets the ticks style of a color axis. 255 256 @param ticks_style: The ticks style to use. I{(TicksStyle)} 257 @return: 258 """ 259 return None

260 - def get_labels_visible( ):

261 """ 262 Gets the visibility of labels of a color axis. 263 264 265 @return: B{C{True}} if labels are displayed, B{C{False}} if they are omitted. 266 267 """ 268 return None

269 - def set_labels_visible( labels_visible ):

270 """ 271 Sets the visibility of labels of a color axis. 272 273 @param labels_visible: B{C{True}} to display labels with minimum and maximum values, 274 B{C{False}} to display no labels. I{(bool)} 275 @return: 276 """ 277 return None

278 -class ColorButton:

279 - def __init__( ):

280 """ 281 Creates a new color button. This returns a widget in the form of 282 a small button containing a swatch representing the current selected 283 color. When the button is clicked, a color-selection dialog will open, 284 allowing the user to select a color. The swatch will be updated to reflect 285 the new color when the user finishes. 286 287 288 @return: a new color button. 289 290 """ 291 return None

292 - def set_color( color ):

293 """ 294 Sets the current color to be B{C{color}}. 295 296 @param color: A B{C{RGBA}} to set the current color with. I{(L{RGBA})} 297 @return: 298 """ 299 return None

300 - def get_color( color ):

301 """ 302 Sets B{C{color}} to be the current color in the B{C{ColorButton}} widget. 303 304 @param color: a B{C{RGBA}} to fill in with the current color. I{(L{RGBA})} 305 @return: 306 """ 307 return None

308 - def set_use_alpha( use_alpha ):

309 """ 310 Sets whether or not the color button should use the alpha channel. 311 312 @param use_alpha: B{C{True}} if color button should use alpha channel, B{C{False}} if not. I{(bool)} 313 @return: 314 """ 315 return None

316 - def get_use_alpha( ):

317 """ 318 Does the color selection dialog use the alpha channel? 319 320 321 @return: B{C{True}} if the color sample uses alpha channel, B{C{False}} if not. 322 323 """ 324 return None

325 -class Container:

326 - def __init__( ):

327 """ 328 Creates a new B{C{Container}}. 329 330 331 @return: The container, as a B{C{GObject}}. 332 333 """ 334 return None

335 - def get_n_items( ):

336 """ 337 Gets the number of items in a container. 338 339 340 @return: The number of items. 341 342 """ 343 return None

344 - def value_type( key ):

345 """ 346 Returns the type of value in B{C{container}} identified by B{C{key}}. 347 348 349 @param key: A B{C{GQuark}} key. I{(int)} 350 @return: The value type as B{C{GType}}; 0 if there is no such value. 351 352 """ 353 return None

354 - def contains( key ):

355 """ 356 Returns B{C{True}} if B{C{container}} contains a value identified by B{C{key}}. 357 358 359 @param key: A B{C{GQuark}} key. I{(int)} 360 @return: Whether B{C{container}} contains something identified by B{C{key}}. 361 362 """ 363 return None

364 - def get_value( key ):

365 """ 366 Returns the value in B{C{container}} identified by B{C{key}}. 367 368 369 @param key: A B{C{GQuark}} key. I{(int)} 370 @return: The value as a B{C{GValue}}. 371 372 """ 373 return None

374 - def UNIMPLEMENTED_gis_value( key , value ):

375 """ 376 Get-if-set a generic value from a container. 377 378 379 @param key: A B{C{GQuark}} key. I{(int)} 380 @param value: Pointer to a B{C{GValue}} to update. If item does not exist, 381 it is left untouched. I{(GValue*)} 382 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 383 such value in the container. 384 385 """ 386 return None

387 - def remove( key ):

388 """ 389 Removes a value identified by B{C{key}} from a container. 390 391 392 @param key: A B{C{GQuark}} key. I{(int)} 393 @return: B{C{True}} if there was such a value and was removed. 394 395 """ 396 return None

397 - def remove_by_prefix( prefix ):

398 """ 399 Removes a values whose key start with B{C{prefix}} from container B{C{container}}. 400 401 B{C{prefix}} can be B{C{NULL}}, all values are then removed. 402 403 404 @param prefix: A nul-terminated id prefix. I{(string)} 405 @return: The number of values removed. 406 407 """ 408 return None

409 - def transfer( dest , source_prefix , dest_prefix , force ):

410 """ 411 Copies a items from one place in container to another place. 412 413 The copies are shallow, objects are not physically duplicated, only 414 referenced in B{C{dest}}. 415 416 417 @param dest: Destination container. It may be the same container as B{C{source}}, but 418 B{C{source_prefix}} and B{C{dest_prefix}} may not overlap then. I{(L{Container})} 419 @param source_prefix: Prefix in B{C{source}} to take values from. I{(string)} 420 @param dest_prefix: Prefix in B{C{dest}} to put values to. I{(string)} 421 @param force: B{C{True}} to replace existing values in B{C{dest}}. I{(bool)} 422 @return: The number of actually transferred items. 423 424 """ 425 return None

426 - def rename( key , newkey , force ):

427 """ 428 Makes a value in B{C{container}} identified by B{C{key}} to be identified by B{C{newkey}}. 429 430 When B{C{force}} is B{C{True}} existing value at B{C{newkey}} is removed from B{C{container}}. 431 When it's B{C{False}}, an existing value B{C{newkey}} inhibits the rename and B{C{False}} 432 is returned. 433 434 435 @param key: The current key. I{(int)} 436 @param newkey: A new key for the value. I{(int)} 437 @param force: Whether to replace existing value at B{C{newkey}}. I{(bool)} 438 @return: Whether the rename succeeded. 439 440 """ 441 return None

442 - def UNIMPLEMENTED_foreach( prefix , function , user_data ):

443 """ 444 Calls B{C{function}} on each B{C{container}} item whose identifier starts with 445 B{C{prefix}}. 446 447 The function is called B{C{function}}(B{C{GQuark}} key, B{C{GValue}} *value, user_data). 448 449 450 @param prefix: A nul-terminated id prefix. I{(string)} 451 @param function: The function called on the items. I{(GHFunc)} 452 @param user_data: The user data passed to B{C{function}}. I{(gpointer)} 453 @return: The number of items B{C{function}} was called on. 454 455 """ 456 return None

457 - def keys( ):

458 """ 459 Gets all quark keys of a container. 460 461 Since: 2.7 462 463 @return: A newly allocated array with quark keys of all B{C{container}} items, 464 in no particular order. The number of items can be obtained 465 with L{Container.get_n_items}(). If there are no items, B{C{NULL}} 466 is returned. 467 468 469 """ 470 return None

471 - def keys_by_name( ):

472 """ 473 Gets all string keys of a container. 474 475 Since: 2.7 476 477 @return: A newly allocated array with string keys of all B{C{container}} items, 478 in no particular order. The number of items can be obtained 479 with L{Container.get_n_items}(). If there are no items, B{C{NULL}} 480 is returned. Unlike the array the strings are owned by GLib and 481 must not be freed. 482 483 484 """ 485 return None

486 - def set_boolean( key , value ):

487 """ 488 Stores a boolean into B{C{container}}, identified by B{C{key}}. 489 490 @param key: A B{C{GQuark}} key. I{(int)} 491 @param value: A boolean. I{(bool)} 492 @return: 493 """ 494 return None

495 - def get_boolean( key ):

496 """ 497 Returns the boolean in B{C{container}} identified by B{C{key}}. 498 499 500 @param key: A B{C{GQuark}} key. I{(int)} 501 @return: The boolean as B{C{gboolean}}. 502 503 """ 504 return None

505 - def UNIMPLEMENTED_gis_boolean( key , value ):

506 """ 507 Get-if-set a boolean from a container. 508 509 510 @param key: A B{C{GQuark}} key. I{(int)} 511 @param value: Pointer to the boolean to update. I{(gboolean*)} 512 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 513 such boolean in the container. 514 515 """ 516 return None

517 - def set_uchar( key , value ):

518 """ 519 Stores an unsigned character into B{C{container}}, identified by B{C{key}}. 520 521 @param key: A B{C{GQuark}} key. I{(int)} 522 @param value: An unsigned character. I{(guchar)} 523 @return: 524 """ 525 return None

526 - def get_uchar( key ):

527 """ 528 Returns the unsigned character in B{C{container}} identified by B{C{key}}. 529 530 531 @param key: A B{C{GQuark}} key. I{(int)} 532 @return: The character as B{C{guchar}}. 533 534 """ 535 return None

536 - def UNIMPLEMENTED_gis_uchar( key , value ):

537 """ 538 Get-if-set an unsigned char from a container. 539 540 541 @param key: A B{C{GQuark}} key. I{(int)} 542 @param value: Pointer to the unsigned char to update. I{(guchar*)} 543 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 544 such unsigned char in the container. 545 546 """ 547 return None

548 - def set_int32( key , value ):

549 """ 550 Stores a 32bit integer into B{C{container}}, identified by B{C{key}}. 551 552 @param key: A B{C{GQuark}} key. I{(int)} 553 @param value: A 32bit integer. I{(int)} 554 @return: 555 """ 556 return None

557 - def get_int32( key ):

558 """ 559 Returns the 32bit integer in B{C{container}} identified by B{C{key}}. 560 561 562 @param key: A B{C{GQuark}} key. I{(int)} 563 @return: The integer as B{C{guint32}}. 564 565 """ 566 return None

567 - def UNIMPLEMENTED_gis_int32( key , value ):

568 """ 569 Get-if-set a 32bit integer from a container. 570 571 572 @param key: A B{C{GQuark}} key. I{(int)} 573 @param value: Pointer to the 32bit integer to update. I{(int)} 574 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 575 such 32bit integer in the container. 576 577 """ 578 return None

579 - def set_enum( key , value ):

580 """ 581 Stores an enum into B{C{container}}, identified by B{C{key}}. 582 583 Note enums are treated as 32bit integers. 584 585 @param key: A B{C{GQuark}} key. I{(int)} 586 @param value: An enum integer. I{(int)} 587 @return: 588 """ 589 return None

590 - def get_enum( key ):

591 """ 592 Returns the enum in B{C{container}} identified by B{C{key}}. 593 594 Note enums are treated as 32bit integers. 595 596 597 @param key: A B{C{GQuark}} key. I{(int)} 598 @return: The enum as B{C{gint}}. 599 600 """ 601 return None

602 - def UNIMPLEMENTED_gis_enum( key , value ):

603 """ 604 Get-if-set an enum from a container. 605 606 Note enums are treated as 32bit integers. 607 608 609 @param key: A B{C{GQuark}} key. I{(int)} 610 @param value: Pointer to the enum to update. I{(int)} 611 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 612 such enum in the container. 613 614 """ 615 return None

616 - def set_int64( key , value ):

617 """ 618 Stores a 64bit integer into B{C{container}}, identified by B{C{key}}. 619 620 @param key: A B{C{GQuark}} key. I{(int)} 621 @param value: A 64bit integer. I{(gint64)} 622 @return: 623 """ 624 return None

625 - def get_int64( key ):

626 """ 627 Returns the 64bit integer in B{C{container}} identified by B{C{key}}. 628 629 630 @param key: A B{C{GQuark}} key. I{(int)} 631 @return: The 64bit integer as B{C{guint64}}. 632 633 """ 634 return None

635 - def UNIMPLEMENTED_gis_int64( key , value ):

636 """ 637 Get-if-set a 64bit integer from a container. 638 639 640 @param key: A B{C{GQuark}} key. I{(int)} 641 @param value: Pointer to the 64bit integer to update. I{(int)} 642 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 643 such 64bit integer in the container. 644 645 """ 646 return None

647 - def set_double( key , value ):

648 """ 649 Stores a double into B{C{container}}, identified by B{C{key}}. 650 651 @param key: A B{C{GQuark}} key. I{(int)} 652 @param value: A double. I{(float)} 653 @return: 654 """ 655 return None

656 - def get_double( key ):

657 """ 658 Returns the double in B{C{container}} identified by B{C{key}}. 659 660 661 @param key: A B{C{GQuark}} key. I{(int)} 662 @return: The double as B{C{gdouble}}. 663 664 """ 665 return None

666 - def UNIMPLEMENTED_gis_double( key , value ):

667 """ 668 Get-if-set a double from a container. 669 670 671 @param key: A B{C{GQuark}} key. I{(int)} 672 @param value: Pointer to the double to update. I{(float)} 673 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 674 such double in the container. 675 676 """ 677 return None

678 - def set_string( key , value ):

679 """ 680 Set string for key to given value 681 682 683 @param value: new string I{(string)} 684 @return: 685 """ 686 return None

687 - def get_string( key ):

688 """ 689 Returns the string in B{C{container}} identified by B{C{key}}. 690 691 The returned string must be treated as constant and never freed or modified. 692 693 694 @param key: A B{C{GQuark}} key. I{(int)} 695 @return: The string. 696 697 """ 698 return None

699 - def UNIMPLEMENTED_gis_string( key , value ):

700 """ 701 Get-if-set a string from a container. 702 703 The string eventually stored in B{C{value}} must be treated as constant and 704 never freed or modified. 705 706 707 @param key: A B{C{GQuark}} key. I{(int)} 708 @param value: Pointer to the string pointer to update. I{(const-guchar**)} 709 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 710 such string in the container. 711 712 """ 713 return None

714 - def set_object( key , value ):

715 """ 716 Stores an object into B{C{container}}, identified by B{C{key}}. 717 718 The container claims ownership on the object, i.e. its reference count is 719 incremented. 720 721 The object must implement B{C{Serializable}} interface to allow serialization 722 of the container. 723 724 @param key: A B{C{GQuark}} key. I{(int)} 725 @param value: An object to store into container. I{(gpointer)} 726 @return: 727 """ 728 return None

729 - def get_object( key ):

730 """ 731 Get object of given key from container. 732 733 734 @return: object of given key 735 736 """ 737 return None

738 - def gis_object( key , value ):

739 """ 740 Get-if-set an object from a container. 741 742 The object eventually stored in B{C{value}} doesn't have its reference count 743 increased, use g_object_ref() if you want to access it even when 744 B{C{container}} may cease to exist. 745 746 747 @param key: A B{C{GQuark}} key. I{(int)} 748 @param value: Pointer to the object pointer to update. I{(gpointer)} 749 @return: B{C{True}} if B{C{v}} was actually updated, B{C{False}} when there is no 750 such object in the container. 751 752 """ 753 return None

754 - def UNIMPLEMENTED_serialize_to_text( ):

755 """ 756 Creates a text representation of B{C{container}} contents. 757 758 Note only simple data types are supported as serialization of compound 759 objects is not controllable. 760 761 762 @return: A pointer array, each item containing string with one container 763 item representation (name, type, value). The array is sorted by name. 764 765 """ 766 return None

767 - def contains_by_name( name ):

768 """ 769 Expands to B{C{True}} if container B{C{c}} contains a value identified by name B{C{n}}. 770 771 @param n: A nul-terminated name (id). 772 @return: 773 """ 774 return None

775 - def remove_by_name( name ):

776 """ 777 Removes a value identified by name B{C{n}} from container B{C{c}}. 778 779 Expands to B{C{True}} if there was such a value and was removed. 780 781 @param n: A nul-terminated name (id). 782 @return: 783 """ 784 return None

785 - def rename_by_name( name , new_name , delete ):

786 """ 787 Makes a value in container B{C{c}} identified by name B{C{n}} to be identified by 788 new name B{C{nn}}. 789 790 See L{Container.rename}() for details. 791 792 @param n: A nul-terminated name (id). 793 @param nn: A nul-terminated name (id). 794 @param f: Whether to delete existing value at B{C{newkey}}. 795 @return: 796 """ 797 return None

798 - def set_boolean_by_name( name , value ):

799 """ 800 Stores a boolean into container B{C{c}}, identified by name B{C{n}}. 801 802 @param n: A nul-terminated name (id). 803 @param v: A boolean. 804 @return: 805 """ 806 return None

807 - def set_double_by_name( name , value ):

808 """ 809 Stores a double into container B{C{c}}, identified by name B{C{n}}. 810 811 @param n: A nul-terminated name (id). 812 @param v: A double integer. 813 @return: 814 """ 815 return None

816 - def set_enum_by_name( name , value ):

817 """ 818 Stores an enum into container B{C{c}}, identified by name B{C{n}}. 819 820 Note enums are treated as 32bit integers. 821 822 @param n: A nul-terminated name (id). 823 @param v: An enum. 824 @return: 825 """ 826 return None

827 - def set_int32_by_name( name , value ):

828 """ 829 Stores a 32bit integer into container B{C{c}}, identified by name B{C{n}}. 830 831 @param n: A nul-terminated name (id). 832 @param v: A 32bit integer. 833 @return: 834 """ 835 return None

836 - def set_int64_by_name( name , value ):

837 """ 838 Stores a 64bit integer into container B{C{c}}, identified by name B{C{n}}. 839 840 @param n: A nul-terminated name (id). 841 @param v: A 64bit integer. 842 @return: 843 """ 844 return None

845 - def set_object_by_name( name , value ):

846 """ 847 Stores an object into container B{C{c}}, identified by name B{C{n}}. 848 849 See L{Container.set_object}() for details. 850 851 @param n: A nul-terminated name (id). 852 @param v: An object to store into container. 853 @return: 854 """ 855 return None

856 - def set_uchar_by_name( name , value ):

857 """ 858 Stores an unsigned character into container B{C{c}}, identified by name B{C{n}}. 859 860 @param n: A nul-terminated name (id). 861 @param v: An unsigned character. 862 @return: 863 """ 864 return None

865 - def set_string_by_name( name , value ):

866 """ 867 Stores a string into container B{C{c}}, identified by name B{C{n}}. 868 869 The container takes ownership of the string, so it can't be used on 870 static strings, use g_strdup() to duplicate them first. 871 872 @param n: A nul-terminated name (id). 873 @param v: A nul-terminated string. 874 @return: 875 """ 876 return None

877 - def get_boolean_by_name( name ):

878 """ 879 Gets the boolean in container B{C{c}} identified by name B{C{n}}. 880 881 @param n: A nul-terminated name (id). 882 @return: 883 """ 884 return None

885 - def get_double_by_name( name ):

886 """ 887 Gets the double in container B{C{c}} identified by name B{C{n}}. 888 889 @param n: A nul-terminated name (id). 890 @return: 891 """ 892 return None

893 - def get_enum_by_name( name ):

894 """ 895 Gets the enum in container B{C{c}} identified by name B{C{n}}. 896 897 Note enums are treated as 32bit integers. 898 899 @param n: A nul-terminated name (id). 900 @return: 901 """ 902 return None

903 - def get_int32_by_name( name ):

904 """ 905 Gets the 32bit integer in container B{C{c}} identified by name B{C{n}}. 906 907 @param n: A nul-terminated name (id). 908 @return: 909 """ 910 return None

911 - def get_int64_by_name( name ):

912 """ 913 Gets the 64bit integer in container B{C{c}} identified by name B{C{n}}. 914 915 @param n: A nul-terminated name (id). 916 @return: 917 """ 918 return None

919 - def get_object_by_name( name ):

920 """ 921 Gets the object in container B{C{c}} identified by name B{C{n}}. 922 923 The returned object doesn't have its reference count increased, use 924 g_object_ref() if you want to access it even when B{C{container}} may cease 925 to exist. 926 927 @param n: A nul-terminated name (id). 928 @return: 929 """ 930 return None

931 - def get_uchar_by_name( name ):

932 """ 933 Gets the unsigned character in container B{C{c}} identified by name B{C{n}}. 934 935 @param n: A nul-terminated name (id). 936 @return: 937 """ 938 return None

939 - def get_value_by_name( name ):

940 """ 941 Gets the value in container B{C{c}} identified by name B{C{n}}. 942 943 @param n: A nul-terminated name (id). 944 @return: 945 """ 946 return None

947 - def get_string_by_name( name ):

948 """ 949 Gets the string in container B{C{c}} identified by name B{C{n}}. 950 951 The returned string must be treated as constant and never freed or modified. 952 953 @param n: A nul-terminated name (id). 954 @return: 955 """ 956 return None

957 - def get_object( key ):

958 """ 959 Get object of given key from container. 960 961 962 @return: object of given key 963 964 """ 965 return None

966 - def set_string( key , value ):

967 """ 968 Set string for key to given value 969 970 971 @param value: new string I{(some_type)} 972 @return: 973 """ 974 return None

975 -class Curve:

976 - def __init__( ):

977 """ 978 Creates B{C{Curve}} widget. By default, the widget will have 3 curves. 979 980 981 @return: new B{C{Curve}} widget. 982 983 """ 984 return None

985 - def reset( ):

986 """ 987 Removes all control points, resetting the curves to their initial state. 988 989 990 @return: 991 """ 992 return None

993 - def set_range( min_x , max_x , min_y , max_y ):

994 return None

995 - def set_curve_type( type ):

996 return None

997 - def set_channels( num_channels , colors ):

998 return None

999 - def UNIMPLEMENTED_set_control_points( channel_data , prune ):

1000 return None

1001 - def UNIMPLEMENTED_get_control_points( channel_data , triplets ):

1002 return None

1003 -class DataField:

1004 - def __init__( xres , yres , xreal , yreal , nullme ):

1005 """ 1006 Creates a new data field. 1007 1008 1009 @param yres: Y-resolution, i.e., the number of rows. I{(int)} 1010 @param xreal: Real horizontal physical dimension. I{(float)} 1011 @param yreal: Real vertical physical dimension. I{(float)} 1012 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 1013 the data will not be initialized. I{(bool)} 1014 @return: A newly created data field. 1015 1016 """ 1017 return None

1018 - def sum_fields( operand1 , operand2 ):

1019 """ 1020 Sums two data fields. 1021 1022 @param operand1: First data field operand. I{(L{DataField})} 1023 @param operand2: Second data field operand. I{(L{DataField})} 1024 @return: 1025 """ 1026 return None

1027 - def subtract_fields( operand1 , operand2 ):

1028 """ 1029 Subtracts one data field from another. 1030 1031 @param operand1: First data field operand. I{(L{DataField})} 1032 @param operand2: Second data field operand. I{(L{DataField})} 1033 @return: 1034 """ 1035 return None

1036 - def divide_fields( operand1 , operand2 ):

1037 """ 1038 Divides one data field with another. 1039 1040 @param operand1: First data field operand. I{(L{DataField})} 1041 @param operand2: Second data field operand. I{(L{DataField})} 1042 @return: 1043 """ 1044 return None

1045 - def multiply_fields( operand1 , operand2 ):

1046 """ 1047 Multiplies two data fields. 1048 1049 @param operand1: First data field operand. I{(L{DataField})} 1050 @param operand2: Second data field operand. I{(L{DataField})} 1051 @return: 1052 """ 1053 return None

1054 - def min_of_fields( operand1 , operand2 ):

1055 """ 1056 Finds point-wise maxima of two data fields. 1057 1058 @param operand1: First data field operand. I{(L{DataField})} 1059 @param operand2: Second data field operand. I{(L{DataField})} 1060 @return: 1061 """ 1062 return None

1063 - def max_of_fields( operand1 , operand2 ):

1064 """ 1065 Finds point-wise minima of two data fields. 1066 1067 @param operand1: First data field operand. I{(L{DataField})} 1068 @param operand2: Second data field operand. I{(L{DataField})} 1069 @return: 1070 """ 1071 return None

1072 - def check_compatibility( data_field2 , check ):

1073 """ 1074 Checks whether two data fields are compatible. 1075 1076 1077 @param data_field2: Another data field. I{(L{DataField})} 1078 @param check: The compatibility tests to perform. I{(DataCompatibilityFlags)} 1079 @return: Zero if all tested properties are compatible. Flags corresponding 1080 to failed tests if data fields are not compatible. 1081 1082 """ 1083 return None

1084 - def correct_laplace_iteration( mask_field , buffer_field , corrfactor , error ):

1085 """ 1086 Performs one interation of Laplace data correction. 1087 1088 Tries to remove all the points in mask off the data by using 1089 iterative method similar to solving heat flux equation. 1090 1091 Use this function repeatedly until reasonable B{C{error}} is reached. 1092 1093 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 1094 @param buffer_field: Initialized to same size as mask and data. I{(L{DataField})} 1095 @param error: Maximum change within last step. I{(float)} 1096 @param corrfactor: Correction factor within step. I{(float)} 1097 @return: 1098 """ 1099 return None

1100 - def correct_average( mask_field ):

1101 """ 1102 Fills data under mask with average value. 1103 1104 Simply puts average value of all the B{C{data_field}} values into 1105 points in B{C{data_field}} lying under points where B{C{mask_field}} values 1106 are nonzero. 1107 1108 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 1109 @return: 1110 """ 1111 return None

1112 - def mask_outliers( mask_field , thresh ):

1113 """ 1114 Creates mask of data that are above or below B{C{thresh}}*sigma from average 1115 height. 1116 1117 Sigma denotes root-mean square deviation of heights. This criterium 1118 corresponds to the usual Gaussian distribution outliers detection if 1119 B{C{thresh}} is 3. 1120 1121 @param mask_field: A data field to be filled with mask. I{(L{DataField})} 1122 @param thresh: Threshold value. I{(float)} 1123 @return: 1124 """ 1125 return None

1126 - def mask_outliers2( mask_field , thresh_low , thresh_high ):

1127 """ 1128 Creates mask of data that are above or below multiples of rms from average 1129 height. 1130 1131 Data that are below B{C{mean}}-B{C{thresh_low}}*B{C{sigma}} or above 1132 B{C{mean}}+B{C{thresh_high}}*B{C{sigma}} are marked as outliers, where B{C{sigma}} denotes the 1133 root-mean square deviation of heights. 1134 1135 Since: 2.26 1136 1137 @param mask_field: A data field to be filled with mask. I{(L{DataField})} 1138 @param thresh_low: Lower threshold value. I{(float)} 1139 @param thresh_high: Upper threshold value. I{(float)} 1140 @return: 1141 """ 1142 return None

1143 - def UNIMPLEMENTED_distort( dest , invtrans , user_data , interp , exterior , fill_value ):

1144 """ 1145 Distorts a data field in the horizontal plane. 1146 1147 Note the transform function B{C{invtrans}} is the inverse transform, in other 1148 words it calculates the old coordinates from tne new coordinates (the 1149 transform would not be uniquely defined the other way round). 1150 1151 Since: 2.5 1152 1153 @param dest: Destination data field. I{(L{DataField})} 1154 @param invtrans: Inverse transform function, that is the transformation from 1155 new coordinates to old coordinates. It gets 1156 (B{C{j}}+0.5, B{C{i}}+0.5), where B{C{i}} and B{C{j}} are the new row and column 1157 indices, passed as the input coordinates. The output coordinates 1158 should follow the same convention. Unless a special exterior 1159 handling is requires, the transform function does not need to 1160 concern itself with coordinates being outside of the data. I{(CoordTransform2DFunc)} 1161 @param user_data: Pointer passed as B{C{user_data}} to B{C{invtrans}}. I{(gpointer)} 1162 @param interp: Interpolation type to use. I{(InterpolationType)} 1163 @param exterior: Exterior pixels handling. I{(ExteriorType)} 1164 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}}. I{(float)} 1165 @return: 1166 """ 1167 return None

1168 - def get_correlation_score( kernel_field , col , row , kernel_col , kernel_row , kernel_width , kernel_height ):

1169 """ 1170 Calculates a correlation score in one point. 1171 1172 Correlation window size is given 1173 by B{C{kernel_col}}, B{C{kernel_row}}, B{C{kernel_width}}, B{C{kernel_height}}, 1174 postion of the correlation window on data is given by 1175 B{C{col}}, B{C{row}}. 1176 1177 If anything fails (data too close to boundary, etc.), 1178 function returns -1.0 (none correlation).. 1179 1180 1181 @param kernel_field: Kernel to correlate data field with. I{(L{DataField})} 1182 @param col: Upper-left column position in the data field. I{(int)} 1183 @param row: Upper-left row position in the data field. I{(int)} 1184 @param kernel_col: Upper-left column position in kernel field. I{(int)} 1185 @param kernel_row: Upper-left row position in kernel field. I{(int)} 1186 @param kernel_width: Width of kernel field area. I{(int)} 1187 @param kernel_height: Heigh of kernel field area. I{(int)} 1188 @return: Correlation score (between -1.0 and 1.0). Value 1.0 denotes 1189 maximum correlation, -1.0 none correlation. 1190 1191 """ 1192 return None

1193 - def crosscorrelate( data_field2 , x_dist , y_dist , score , search_width , search_height , window_width , window_height ):

1194 """ 1195 Algorithm for matching two different images of the same object under changes. 1196 1197 It does not use any special features 1198 for matching. It simply searches for all points (with their neighbourhood) 1199 of B{C{data_field1}} within B{C{data_field2}}. Parameters B{C{search_width}} and 1200 B{C{search_height}} 1201 determine maimum area where to search for points. The area is cenetered 1202 in the B{C{data_field2}} at former position of points at B{C{data_field1}}. 1203 1204 @param data_field2: A data field. I{(L{DataField})} 1205 @param x_dist: A data field to store x-distances to. I{(L{DataField})} 1206 @param y_dist: A data field to store y-distances to. I{(L{DataField})} 1207 @param score: Data field to store correlation scores to. I{(L{DataField})} 1208 @param search_width: Search area width. I{(int)} 1209 @param search_height: Search area height. I{(int)} 1210 @param window_width: Correlation window width. I{(int)} 1211 @param window_height: Correlation window height. I{(int)} 1212 @return: 1213 """ 1214 return None

1215 - def UNIMPLEMENTED_crosscorrelate_init( data_field2 , x_dist , y_dist , score , search_width , search_height , window_width , window_height ):

1216 """ 1217 Initializes a cross-correlation iterator. 1218 1219 This iterator reports its state as B{C{ComputationStateType}}. 1220 1221 1222 @param data_field2: A data field. I{(L{DataField})} 1223 @param x_dist: A data field to store x-distances to, or B{C{NULL}}. I{(L{DataField})} 1224 @param y_dist: A data field to store y-distances to, or B{C{NULL}}. I{(L{DataField})} 1225 @param score: Data field to store correlation scores to, or B{C{NULL}}. I{(L{DataField})} 1226 @param search_width: Search area width. I{(int)} 1227 @param search_height: Search area height. I{(int)} 1228 @param window_width: Correlation window width. I{(int)} 1229 @param window_height: Correlation window height. I{(int)} 1230 @return: A new cross-correlation iterator. 1231 1232 """ 1233 return None

1234 - def correlate( kernel_field , score , method ):

1235 """ 1236 Computes correlation score for all positions in a data field. 1237 1238 Correlation score is compute for all points in data field B{C{data_field}} 1239 and full size of correlation kernel B{C{kernel_field}}. 1240 1241 The points in B{C{score}} correspond to centers of kernel. More precisely, the 1242 point ((B{C{kxres}}-1)/2, (B{C{kyres}}-1)/2) in B{C{score}} corresponds to kernel field 1243 top left corner coincident with data field top left corner. Points outside 1244 the area where the kernel field fits into the data field completely are 1245 set to -1 for B{C{CORRELATION_NORMAL}}. 1246 1247 @param kernel_field: Correlation kernel. I{(L{DataField})} 1248 @param score: Data field to store correlation scores to. I{(L{DataField})} 1249 @param method: Correlation score calculation method. I{(CorrelationType)} 1250 @return: 1251 """ 1252 return None

1253 - def UNIMPLEMENTED_correlate_init( kernel_field , score ):

1254 """ 1255 Creates a new correlation iterator. 1256 1257 This iterator reports its state as B{C{ComputationStateType}}. 1258 1259 1260 @param kernel_field: Kernel to correlate data field with. I{(L{DataField})} 1261 @param score: Data field to store correlation scores to. I{(L{DataField})} 1262 @return: A new correlation iterator. 1263 1264 """ 1265 return None

1266 - def new_alike( nullme ):

1267 """ 1268 Creates a new data field similar to an existing one. 1269 1270 Use L{DataField.duplicate}() if you want to copy a data field including 1271 data. 1272 1273 1274 @param nullme: Whether the data field should be initialized to zeroes. If B{C{False}}, 1275 the data will not be initialized. I{(bool)} 1276 @return: A newly created data field. 1277 1278 """ 1279 return None

1280 - def data_changed( ):

1281 """ 1282 Emits signal "data-changed" on a data field. 1283 1284 @return: 1285 """ 1286 return None

1287 - def new_resampled( xres , yres , interpolation ):

1288 """ 1289 Creates a new data field by resampling an existing one. 1290 1291 This method is equivalent to L{DataField.duplicate}() followed by 1292 L{DataField.resample}(), but it is more efficient. 1293 1294 1295 @param xres: Desired X resolution. I{(int)} 1296 @param yres: Desired Y resolution. I{(int)} 1297 @param interpolation: Interpolation method to use. I{(InterpolationType)} 1298 @return: A newly created data field. 1299 1300 """ 1301 return None

1302 - def resample( xres , yres , interpolation ):

1303 """ 1304 Resamples a data field using given interpolation method 1305 1306 This method may invalidate raw data buffer returned by 1307 L{DataField.get_data}(). 1308 1309 @param xres: Desired X resolution. I{(int)} 1310 @param yres: Desired Y resolution. I{(int)} 1311 @param interpolation: Interpolation method to use. I{(InterpolationType)} 1312 @return: 1313 """ 1314 return None

1315 - def resize( ulcol , ulrow , brcol , brrow ):

1316 """ 1317 Resizes (crops) a data field. 1318 1319 Crops a data field to a rectangle between upper-left and bottom-right 1320 points, recomputing real size. 1321 1322 This method may invalidate raw data buffer returned by 1323 L{DataField.get_data}(). 1324 1325 @param ulcol: Upper-left column coordinate. I{(int)} 1326 @param ulrow: Upper-left row coordinate. I{(int)} 1327 @param brcol: Bottom-right column coordinate + 1. I{(int)} 1328 @param brrow: Bottom-right row coordinate + 1. I{(int)} 1329 @return: 1330 """ 1331 return None

1332 - def area_extract( col , row , width , height ):

1333 """ 1334 Extracts a rectangular part of a data field to a new data field. 1335 1336 1337 @param row: Upper-left row coordinate. I{(int)} 1338 @param col: Upper-left column coordinate. I{(int)} 1339 @param width: Area width (number of columns). I{(int)} 1340 @param height: Area height (number of rows). I{(int)} 1341 @return: The extracted area as a newly created data field. 1342 1343 """ 1344 return None

1345 - def copy( dest , nondata_too ):

1346 """ 1347 Copies the contents of an already allocated data field to a data field 1348 of the same size. 1349 1350 @param dest: Destination data field. I{(L{DataField})} 1351 @param nondata_too: Whether non-data (units) should be compied too. I{(bool)} 1352 @return: 1353 """ 1354 return None

1355 - def area_copy( dest , col , row , width , height , destcol , destrow ):

1356 """ 1357 Copies a rectangular area from one data field to another. 1358 1359 The area starts at (B{C{col}}, B{C{row}}) in B{C{src}} and its dimension is B{C{width}}*B{C{height}}. 1360 It is copied to B{C{dest}} starting from (B{C{destcol}}, B{C{destrow}}). 1361 1362 The source area has to be completely contained in B{C{src}}. No assumptions are 1363 made about destination position, however, parts of the source area sticking 1364 out the destination data field B{C{dest}} are cut off. 1365 1366 If B{C{src}} is equal to B{C{dest}}, the areas may not overlap. 1367 1368 @param dest: Destination data field. I{(L{DataField})} 1369 @param col: Area upper-left column coordinate in B{C{src}}. I{(int)} 1370 @param row: Area upper-left row coordinate B{C{src}}. I{(int)} 1371 @param width: Area width (number of columns), pass -1 for full B{C{src}} widdth. I{(int)} 1372 @param height: Area height (number of rows), pass -1 for full B{C{src}} height. I{(int)} 1373 @param destcol: Destination column in B{C{dest}}. I{(int)} 1374 @param destrow: Destination row in B{C{dest}}. I{(int)} 1375 @return: 1376 """ 1377 return None

1378 - def get_data( ):

1379 """ 1380 Create a tuple of data which the datafield contains. Content of the tuple is NOT reference to original datafield but its copy. 1381 1382 1383 @return: tuple of raw numeric data from DataField 1384 1385 """ 1386 return None

1387 - def get_xres( ):

1388 """ 1389 Gets X resolution (number of columns) of a data field. 1390 1391 1392 @return: X resolution. 1393 1394 """ 1395 return None

1396 - def get_yres( ):

1397 """ 1398 Gets Y resolution (number of rows) of the field. 1399 1400 1401 @return: Y resolution. 1402 1403 """ 1404 return None

1405 - def get_xreal( ):

1406 """ 1407 Gets the X real (physical) size of a data field. 1408 1409 1410 @return: X real size value. 1411 1412 """ 1413 return None

1414 - def get_yreal( ):

1415 """ 1416 Gets the Y real (physical) size of a data field. 1417 1418 1419 @return: Y real size value. 1420 1421 """ 1422 return None

1423 - def set_xreal( xreal ):

1424 """ 1425 Sets X real (physical) size value of a data field. 1426 1427 @param xreal: New X real size value. I{(float)} 1428 @return: 1429 """ 1430 return None

1431 - def set_yreal( yreal ):

1432 """ 1433 Sets Y real (physical) size value of a data field. 1434 1435 @param yreal: New Y real size value. I{(float)} 1436 @return: 1437 """ 1438 return None

1439 - def get_xoffset( ):

1440 """ 1441 Gets the X offset of data field origin. 1442 1443 1444 @return: X offset value. 1445 1446 """ 1447 return None

1448 - def get_yoffset( ):

1449 """ 1450 Gets the Y offset of data field origin. 1451 1452 1453 @return: Y offset value. 1454 1455 """ 1456 return None

1457 - def set_xoffset( xoff ):

1458 """ 1459 Sets the X offset of a data field origin. 1460 1461 Note offsets don't affect any calculation, nor functions like 1462 L{DataField.rotj}(). 1463 1464 @param xoff: New X offset value. I{(float)} 1465 @return: 1466 """ 1467 return None

1468 - def set_yoffset( yoff ):

1469 """ 1470 Sets the Y offset of a data field origin. 1471 1472 Note offsets don't affect any calculation, nor functions like 1473 L{DataField.rtoi}(). 1474 1475 @param yoff: New Y offset value. I{(float)} 1476 @return: 1477 """ 1478 return None

1479 - def get_si_unit_xy( ):

1480 """ 1481 Returns lateral SI unit of a data field. 1482 1483 1484 @return: SI unit corresponding to the lateral (XY) dimensions of the data 1485 field. Its reference count is not incremented. 1486 1487 """ 1488 return None

1489 - def get_si_unit_z( ):

1490 """ 1491 Returns value SI unit of a data field. 1492 1493 1494 @return: SI unit corresponding to the "height" (Z) dimension of the data 1495 field. Its reference count is not incremented. 1496 1497 """ 1498 return None

1499 - def set_si_unit_xy( si_unit ):

1500 """ 1501 Sets the SI unit corresponding to the lateral (XY) dimensions of a data 1502 field. 1503 1504 It does not assume a reference on B{C{si_unit}}, instead it adds its own 1505 reference. 1506 1507 @param si_unit: SI unit to be set. I{(L{SIUnit})} 1508 @return: 1509 """ 1510 return None

1511 - def set_si_unit_z( si_unit ):

1512 """ 1513 Sets the SI unit corresponding to the "height" (Z) dimension of a data 1514 field. 1515 1516 It does not assume a reference on B{C{si_unit}}, instead it adds its own 1517 reference. 1518 1519 @param si_unit: SI unit to be set. I{(L{SIUnit})} 1520 @return: 1521 """ 1522 return None

1523 - def UNIMPLEMENTED_get_value_format_xy( style , format ):

1524 """ 1525 Finds value format good for displaying coordinates of a data field. 1526 1527 1528 @param style: Unit format style. I{(SIUnitFormatStyle)} 1529 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 1530 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 1531 is returned, otherwise (modified) B{C{format}} itself is returned. 1532 1533 """ 1534 return None

1535 - def UNIMPLEMENTED_get_value_format_z( style , format ):

1536 """ 1537 Finds value format good for displaying values of a data field. 1538 1539 1540 @param style: Unit format style. I{(SIUnitFormatStyle)} 1541 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 1542 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 1543 is returned, otherwise (modified) B{C{format}} itself is returned. 1544 1545 """ 1546 return None

1547 - def copy_units_to_data_line( data_line ):

1548 """ 1549 Sets lateral and value units of a data line to match a data field. 1550 1551 @param data_line: A data line to set units of. I{(L{DataLine})} 1552 @return: 1553 """ 1554 return None

1555 - def itor( row ):

1556 """ 1557 Transforms vertical pixel coordinate to real (physical) Y coordinate. 1558 1559 That is it maps range [0..y-resolution] to range [0..real-y-size]. 1560 It is not suitable for conversion of matrix indices to physical coordinates, 1561 you have to use L{DataField.itor}(B{C{data_field}}, B{C{row}} + 0.5) for that. 1562 1563 1564 @param row: Vertical pixel coordinate. I{(float)} 1565 @return: Real Y coordinate. 1566 1567 """ 1568 return None

1569 - def jtor( col ):

1570 """ 1571 Transforms horizontal pixel coordinate to real (physical) X coordinate. 1572 1573 That is it maps range [0..x-resolution] to range [0..real-x-size]. 1574 It is not suitable for conversion of matrix indices to physical coordinates, 1575 you have to use L{DataField.jtor}(B{C{data_field}}, B{C{col}} + 0.5) for that. 1576 1577 1578 @param col: Horizontal pixel coordinate. I{(float)} 1579 @return: Real X coordinate. 1580 1581 """ 1582 return None

1583 - def rtoi( realy ):

1584 """ 1585 Transforms real (physical) Y coordinate to row. 1586 1587 That is it maps range [0..real-y-size] to range [0..y-resolution]. 1588 1589 1590 @param realy: Real (physical) Y coordinate. I{(float)} 1591 @return: Vertical pixel coodinate. 1592 1593 """ 1594 return None

1595 - def rtoj( realx ):

1596 """ 1597 Transforms real (physical) X coordinate to column. 1598 1599 That is it maps range [0..real-x-size] to range [0..x-resolution]. 1600 1601 1602 @param realx: Real (physical) X coodinate. I{(float)} 1603 @return: Horizontal pixel coordinate. 1604 1605 """ 1606 return None

1607 - def get_val( col , row ):

1608 """ 1609 Gets value at given position in a data field. 1610 1611 Do not access data with this function inside inner loops, it's slow. 1612 Get the raw data buffer with L{DataField.get_data_const}() and access it 1613 directly instead. 1614 1615 1616 @param col: Column index. I{(int)} 1617 @param row: Row index. I{(int)} 1618 @return: Value at (B{C{col}}, B{C{row}}). 1619 1620 """ 1621 return None

1622 - def set_val( col , row , value ):

1623 """ 1624 Sets value at given position in a data field. 1625 1626 Do not set data with this function inside inner loops, it's slow. Get the 1627 raw data buffer with L{DataField.get_data}() and write to it directly 1628 instead. 1629 1630 @param col: Column index. I{(int)} 1631 @param row: Row index. I{(int)} 1632 @param value: Value to set. I{(float)} 1633 @return: 1634 """ 1635 return None

1636 - def get_dval( x , y , interpolation ):

1637 """ 1638 Gets interpolated value at arbitrary data field point indexed by pixel 1639 coordinates. 1640 1641 Note pixel values are centered in pixels, so to get the same 1642 value as L{DataField.get_val}(B{C{data_field}}, B{C{j}}, B{C{i}}) returns, 1643 it's necessary to add 0.5: 1644 L{DataField.get_dval}(B{C{data_field}}, B{C{j}}+0.5, B{C{i}}+0.5, B{C{interpolation}}). 1645 1646 See also L{DataField.get_dval_real}() that does the same, but takes 1647 real coordinates. 1648 1649 1650 @param x: Horizontal position in pixel units, in range [0, x-resolution]. I{(float)} 1651 @param y: Vertical postition in pixel units, in range [0, y-resolution]. I{(float)} 1652 @param interpolation: Interpolation method to be used. I{(InterpolationType)} 1653 @return: Interpolated value at position (B{C{x}},B{C{y}}). 1654 1655 """ 1656 return None

1657 - def get_dval_real( x , y , interpolation ):

1658 """ 1659 Gets interpolated value at arbitrary data field point indexed by real 1660 coordinates. 1661 1662 See also L{DataField.get_dval}() that does the same, but takes pixel 1663 coordinates. 1664 1665 1666 @param x: X postion in real coordinates. I{(float)} 1667 @param y: Y postition in real coordinates. I{(float)} 1668 @param interpolation: Interpolation method to use. I{(InterpolationType)} 1669 @return: Value at position (B{C{x}},B{C{y}}). 1670 1671 """ 1672 return None

1673 - def rotate( angle , interpolation ):

1674 """ 1675 Rotates a data field by a given angle. 1676 1677 Values that get outside of data field by the rotation are lost. 1678 Undefined values from outside of data field that get inside are set to 1679 data field minimum value. 1680 1681 @param angle: Rotation angle (in radians). I{(float)} 1682 @param interpolation: Interpolation method to use. I{(InterpolationType)} 1683 @return: 1684 """ 1685 return None

1686 - def invert( x , y , z ):

1687 """ 1688 Reflects amd/or inverts a data field. 1689 1690 In the case of value reflection, it's inverted about the mean value. 1691 1692 @param x: B{C{True}} to reflect about X axis (i.e., vertically). I{(bool)} 1693 @param y: B{C{True}} to reflect about Y axis (i.e., horizontally). I{(bool)} 1694 @param z: B{C{True}} to invert in Z direction (i.e., invert values). I{(bool)} 1695 @return: 1696 """ 1697 return None

1698 - def fill( value ):

1699 """ 1700 Fills a data field with given value. 1701 1702 @param value: Value to be entered. I{(float)} 1703 @return: 1704 """ 1705 return None

1706 - def clear( ):

1707 """ 1708 Fills a data field with zeroes. 1709 1710 @return: 1711 """ 1712 return None

1713 - def multiply( value ):

1714 """ 1715 Multiplies all values in a data field by given value. 1716 1717 @param value: Value to multiply B{C{data_field}} with. I{(float)} 1718 @return: 1719 """ 1720 return None

1721 - def add( value ):

1722 """ 1723 Adds given value to all values in a data field. 1724 1725 @param value: Value to be added to data field values. I{(float)} 1726 @return: 1727 """ 1728 return None

1729 - def area_fill( col , row , width , height , value ):

1730 """ 1731 Fills a rectangular part of a data field with given value. 1732 1733 @param col: Upper-left column coordinate. I{(int)} 1734 @param row: Upper-left row coordinate. I{(int)} 1735 @param width: Area width (number of columns). I{(int)} 1736 @param height: Area height (number of rows). I{(int)} 1737 @param value: Value to be entered I{(float)} 1738 @return: 1739 """ 1740 return None

1741 - def area_clear( col , row , width , height ):

1742 """ 1743 Fills a rectangular part of a data field with zeroes. 1744 1745 @param col: Upper-left column coordinate. I{(int)} 1746 @param row: Upper-left row coordinate. I{(int)} 1747 @param width: Area width (number of columns). I{(int)} 1748 @param height: Area height (number of rows). I{(int)} 1749 @return: 1750 """ 1751 return None

1752 - def area_multiply( col , row , width , height , value ):

1753 """ 1754 Multiplies values in a rectangular part of a data field by given value 1755 1756 @param col: Upper-left column coordinate. I{(int)} 1757 @param row: Upper-left row coordinate. I{(int)} 1758 @param width: Area width (number of columns). I{(int)} 1759 @param height: Area height (number of rows). I{(int)} 1760 @param value: Value to multiply area with. I{(float)} 1761 @return: 1762 """ 1763 return None

1764 - def area_add( col , row , width , height , value ):

1765 """ 1766 Adds given value to all values in a rectangular part of a data field. 1767 1768 @param col: Upper-left column coordinate. I{(int)} 1769 @param row: Upper-left row coordinate. I{(int)} 1770 @param width: Area width (number of columns). I{(int)} 1771 @param height: Area height (number of rows). I{(int)} 1772 @param value: Value to be added to area values. I{(float)} 1773 @return: 1774 """ 1775 return None

1776 - def get_profile( data_line , scol , srow , ecol , erow , res , thickness , interpolation ):

1777 """ 1778 Extracts a possibly averaged profile from data field to a data line. 1779 1780 1781 @param data_line: A data line. It will be resized to B{C{res}} samples. It is 1782 possible to pass B{C{NULL}} to instantiate and return a new 1783 B{C{DataLine}}. I{(L{DataLine})} 1784 @param scol: The column the line starts at (inclusive). I{(int)} 1785 @param srow: The row the line starts at (inclusive). I{(int)} 1786 @param ecol: The column the line ends at (inclusive). I{(int)} 1787 @param erow: The row the line ends at (inclusive). I{(int)} 1788 @param res: Requested resolution of data line (the number of samples to take). 1789 If nonpositive, data line resolution is chosen to match B{C{data_field}}'s. I{(int)} 1790 @param thickness: Thickness of line to be averaged. I{(int)} 1791 @param interpolation: Interpolation type to use. I{(InterpolationType)} 1792 @return: B{C{data_line}} itself if it was not B{C{NULL}}, otherwise a newly created 1793 data line. 1794 1795 """ 1796 return None

1797 - def get_row( data_line , row ):

1798 """ 1799 Extracts a data field row into a data line. 1800 1801 @param data_line: A data line. It will be resized to width ot B{C{data_field}}. I{(L{DataLine})} 1802 @param row: Row index. I{(int)} 1803 @return: 1804 """ 1805 return None

1806 - def get_column( data_line , col ):

1807 """ 1808 Extracts a data field column into a data line. 1809 1810 @param data_line: A data line. It will be resized to height of B{C{data_field}}. I{(L{DataLine})} 1811 @param col: Column index. I{(int)} 1812 @return: 1813 """ 1814 return None

1815 - def set_row( data_line , row ):

1816 """ 1817 Sets a row in the data field to values of a data line. 1818 1819 Data line length must be equal to width of data field. 1820 1821 @param data_line: A data line. I{(L{DataLine})} 1822 @param row: Row index. I{(int)} 1823 @return: 1824 """ 1825 return None

1826 - def set_column( data_line , col ):

1827 """ 1828 Sets a column in the data field to values of a data line. 1829 1830 Data line length must be equal to height of data field. 1831 1832 @param data_line: A data line. I{(L{DataLine})} 1833 @param col: Column index. I{(int)} 1834 @return: 1835 """ 1836 return None

1837 - def get_row_part( data_line , row , _from , to ):

1838 """ 1839 Extracts part of a data field row into a data line. 1840 1841 @param data_line: A data line. It will be resized to the row part width. I{(L{DataLine})} 1842 @param row: Row index. I{(int)} 1843 @param _from: Start column index. I{(int)} 1844 @param to: End column index + 1. I{(int)} 1845 @return: 1846 """ 1847 return None

1848 - def get_column_part( data_line , col , _from , to ):

1849 """ 1850 Extracts part of a data field column into a data line. 1851 1852 @param data_line: A data line. It will be resized to the column part height. I{(L{DataLine})} 1853 @param col: Column index. I{(int)} 1854 @param _from: Start row index. I{(int)} 1855 @param to: End row index + 1. I{(int)} 1856 @return: 1857 """ 1858 return None

1859 - def set_row_part( data_line , row , _from , to ):

1860 """ 1861 Puts a data line into a data field row. 1862 1863 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 1864 1865 @param data_line: A data line. I{(L{DataLine})} 1866 @param row: Row index. I{(int)} 1867 @param _from: Start row index. I{(int)} 1868 @param to: End row index + 1. I{(int)} 1869 @return: 1870 """ 1871 return None

1872 - def set_column_part( data_line , col , _from , to ):

1873 """ 1874 Puts a data line into data field column. 1875 1876 If data line length differs from B{C{to}}-B{C{from}}, it is resampled to this length. 1877 1878 @param data_line: A data line. I{(L{DataLine})} 1879 @param col: Column index. I{(int)} 1880 @param _from: Start row index. I{(int)} 1881 @param to: End row index + 1. I{(int)} 1882 @return: 1883 """ 1884 return None

1885 - def get_xder( col , row ):

1886 """ 1887 Computes central derivative in X direction. 1888 1889 On border points, one-side derivative is returned. 1890 1891 1892 @param col: Column index. I{(int)} 1893 @param row: Row index. I{(int)} 1894 @return: Derivative in X direction. 1895 1896 """ 1897 return None

1898 - def get_yder( col , row ):

1899 """ 1900 Computes central derivative in Y direction. 1901 1902 On border points, one-side derivative is returned. 1903 1904 Note the derivative is for legacy reasons calulcated for the opposite 1905 y direction than is usual elsewhere in Gwyddion, i.e. if values increase 1906 with increasing row number, the returned value is negative. 1907 1908 1909 @param col: Column index. I{(int)} 1910 @param row: Row index. I{(int)} 1911 @return: Derivative in Y direction 1912 1913 """ 1914 return None

1915 - def get_angder( col , row , theta ):

1916 """ 1917 Computes derivative in direction specified by given angle. 1918 1919 1920 @param col: Column index. I{(int)} 1921 @param row: Row index. I{(int)} 1922 @param theta: Angle defining the direction (in radians, counterclockwise). I{(float)} 1923 @return: Derivative in direction given by angle B{C{theta}}. 1924 1925 """ 1926 return None

1927 - def xdwt( wt_coefs , direction , minsize ):

1928 """ 1929 Performs steps of the X-direction image wavelet decomposition. 1930 1931 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 1932 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 1933 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 1934 1935 1936 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 1937 @param direction: Transform direction. I{(TransformDirection)} 1938 @param minsize: size of minimal transform result block I{(int)} 1939 @return: 1940 """ 1941 return None

1942 - def ydwt( wt_coefs , direction , minsize ):

1943 """ 1944 Performs steps of the Y-direction image wavelet decomposition. 1945 1946 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 1947 B{C{minsize}} = B{C{dfield}}->yres/2 to perform one step of decomposition 1948 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 1949 1950 1951 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 1952 @param direction: Transform direction. I{(TransformDirection)} 1953 @param minsize: size of minimal transform result block I{(int)} 1954 @return: 1955 """ 1956 return None

1957 - def dwt( wt_coefs , direction , minsize ):

1958 """ 1959 Performs steps of the 2D image wavelet decomposition. 1960 1961 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 1962 B{C{minsize}} = B{C{dfield}}->xres/2 to perform one step of decomposition 1963 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 1964 1965 1966 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 1967 @param direction: Transform direction. I{(TransformDirection)} 1968 @param minsize: size of minimal transform result block I{(int)} 1969 @return: 1970 """ 1971 return None

1972 - def dwt_mark_anisotropy( mask , wt_coefs , ratio , lowlimit ):

1973 return None

1974 - def elliptic_area_fill( col , row , width , height , value ):

1975 """ 1976 Fills an elliptic region of a data field with given value. 1977 1978 The elliptic region is defined by its bounding box which must be completely 1979 contained in the data field. 1980 1981 1982 @param col: Upper-left bounding box column coordinate. I{(int)} 1983 @param row: Upper-left bounding box row coordinate. I{(int)} 1984 @param width: Bounding box width (number of columns). I{(int)} 1985 @param height: Bounding box height (number of rows). I{(int)} 1986 @param value: Value to be entered. I{(float)} 1987 @return: The number of filled values. 1988 1989 """ 1990 return None

1991 - def elliptic_area_extract( col , row , width , height , data ):

1992 """ 1993 Extracts values from an elliptic region of a data field. 1994 1995 The elliptic region is defined by its bounding box which must be completely 1996 contained in the data field. 1997 1998 1999 @param col: Upper-left bounding box column coordinate. I{(int)} 2000 @param row: Upper-left bounding box row coordinate. I{(int)} 2001 @param width: Bounding box width (number of columns). I{(int)} 2002 @param height: Bounding box height (number of rows). I{(int)} 2003 @param data: Location to store the extracted values to. Its size has to be 2004 sufficient to contain all the extracted values. As a conservative 2005 estimate B{C{width}}*B{C{height}} can be used, or the 2006 size can be calculated with L{DataField.get_elliptic_area_size}(). I{(gdouble*)} 2007 @return: The number of extracted values. 2008 2009 """ 2010 return None

2011 - def elliptic_area_unextract( col , row , width , height , data ):

2012 """ 2013 Puts values back to an elliptic region of a data field. 2014 2015 The elliptic region is defined by its bounding box which must be completely 2016 contained in the data field. 2017 2018 This method does the reverse of L{DataField.elliptic_area_extract}() 2019 allowing to implement pixel-wise filters on elliptic areas. Values from 2020 B{C{data}} are put back to the same positions 2021 L{DataField.elliptic_area_extract}() took them from. 2022 2023 @param col: Upper-left bounding box column coordinate. I{(int)} 2024 @param row: Upper-left bounding box row coordinate. I{(int)} 2025 @param width: Bounding box width (number of columns). I{(int)} 2026 @param height: Bounding box height (number of rows). I{(int)} 2027 @param data: The values to put back. It must be the same array as in previous 2028 L{DataField.elliptic_area_extract}(). I{(const-gdouble*)} 2029 @return: 2030 """ 2031 return None

2032 - def circular_area_fill( col , row , radius , value ):

2033 """ 2034 Fills an elliptic region of a data field with given value. 2035 2036 2037 @param col: Row index of circular area centre. I{(int)} 2038 @param row: Column index of circular area centre. I{(int)} 2039 @param radius: Circular area radius (in pixels). Any value is allowed, although 2040 to get areas that do not deviate from true circles after 2041 pixelization too much, half-integer values are recommended, 2042 integer values are NOT recommended. I{(float)} 2043 @param value: Value to be entered. I{(float)} 2044 @return: The number of filled values. 2045 2046 """ 2047 return None

2048 - def circular_area_extract( col , row , radius , data ):

2049 """ 2050 Extracts values from a circular region of a data field. 2051 2052 2053 @param col: Row index of circular area centre. I{(int)} 2054 @param row: Column index of circular area centre. I{(int)} 2055 @param radius: Circular area radius (in pixels). See 2056 L{DataField.circular_area_extract_with_pos}() for caveats. I{(float)} 2057 @param data: Location to store the extracted values to. See 2058 L{DataField.circular_area_extract_with_pos}(). I{(gdouble*)} 2059 @return: The number of extracted values. It can be zero when the inside of 2060 the circle does not intersect with the data field. 2061 2062 """ 2063 return None

2064 - def UNIMPLEMENTED_circular_area_extract_with_pos( col , row , radius , data , xpos , ypos ):

2065 """ 2066 Extracts values with positions from a circular region of a data field. 2067 2068 The row and column indices stored to B{C{xpos}} and B{C{ypos}} are relative to the 2069 area centre, i.e. to (B{C{col}}, B{C{row}}). The central pixel will therefore have 2070 0 at the corresponding position in both B{C{xpos}} and B{C{ypos}}. 2071 2072 Since: 2.2 2073 2074 @param col: Row index of circular area centre. I{(int)} 2075 @param row: Column index of circular area centre. I{(int)} 2076 @param radius: Circular area radius (in pixels). Any value is allowed, although 2077 to get areas that do not deviate from true circles after 2078 pixelization too much, half-integer values are recommended, 2079 integer radii are NOT recommended. I{(float)} 2080 @param data: Location to store the extracted values to. Its size has to be 2081 sufficient to contain all the extracted values. As a conservative 2082 estimate (2*floor(B{C{radius}})+1)^2 can be used, or the size can be 2083 calculated with L{DataField.get_circular_area_size}(). I{(gdouble*)} 2084 @param xpos: Location to store relative column indices of values in B{C{data}} to, 2085 the size requirements are the same as for B{C{data}}. I{(int)} 2086 @param ypos: Location to store relative tow indices of values in B{C{data}} to, 2087 the size requirements are the same as for B{C{data}}. I{(int)} 2088 @return: The number of extracted values. It can be zero when the inside of 2089 the circle does not intersect with the data field. 2090 2091 2092 """ 2093 return None

2094 - def circular_area_unextract( col , row , radius , data ):

2095 """ 2096 Puts values back to a circular region of a data field. 2097 2098 This method does the reverse of L{DataField.circular_area_extract}() 2099 allowing to implement pixel-wise filters on circular areas. Values from 2100 B{C{data}} are put back to the same positions 2101 L{DataField.circular_area_extract}() took them from. 2102 2103 @param col: Row index of circular area centre. I{(int)} 2104 @param row: Column index of circular area centre. I{(int)} 2105 @param radius: Circular area radius (in pixels). I{(float)} 2106 @param data: The values to put back. It must be the same array as in previous 2107 L{DataField.circular_area_unextract}(). I{(const-gdouble*)} 2108 @return: 2109 """ 2110 return None

2111 - def normalize( ):

2112 """ 2113 Normalizes data in a data field to range 0.0 to 1.0. 2114 2115 It is equivalent to L{DataField.renormalize}(B{C{data_field}}, 1.0, 0.0); 2116 2117 If B{C{data_field}} is filled with only one value, it is changed to 0.0. 2118 2119 @return: 2120 """ 2121 return None

2122 - def renormalize( range , offset ):

2123 """ 2124 Transforms data in a data field with first linear function to given range. 2125 2126 When B{C{range}} is positive, the new data range is (B{C{offset}}, B{C{offset}}+B{C{range}}); 2127 when B{C{range}} is negative, the new data range is (B{C{offset}}-B{C{range}}, B{C{offset}}). 2128 In neither case the data are flipped, negative range only means different 2129 selection of boundaries. 2130 2131 When B{C{range}} is zero, this method is equivalent to 2132 L{DataField.fill}(B{C{data_field}}, B{C{offset}}). 2133 2134 @param range: New data interval size. I{(float)} 2135 @param offset: New data interval offset. I{(float)} 2136 @return: 2137 """ 2138 return None

2139 - def threshold( threshval , bottom , top ):

2140 """ 2141 Tresholds values of a data field. 2142 2143 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 2144 than B{C{threshold}} or equal to it are set to value B{C{top}} 2145 2146 2147 @param threshval: Threshold value. I{(float)} 2148 @param bottom: Lower replacement value. I{(float)} 2149 @param top: Upper replacement value. I{(float)} 2150 @return: The total number of values above threshold. 2151 2152 """ 2153 return None

2154 - def area_threshold( col , row , width , height , threshval , bottom , top ):

2155 """ 2156 Tresholds values of a rectangular part of a data field. 2157 2158 Values smaller than B{C{threshold}} are set to value B{C{bottom}}, values higher 2159 than B{C{threshold}} or equal to it are set to value B{C{top}} 2160 2161 2162 @param col: Upper-left column coordinate. I{(int)} 2163 @param row: Upper-left row coordinate. I{(int)} 2164 @param width: Area width (number of columns). I{(int)} 2165 @param height: Area height (number of rows). I{(int)} 2166 @param threshval: Threshold value. I{(float)} 2167 @param bottom: Lower replacement value. I{(float)} 2168 @param top: Upper replacement value. I{(float)} 2169 @return: The total number of values above threshold. 2170 2171 """ 2172 return None

2173 - def clamp( bottom , top ):

2174 """ 2175 Limits data field values to a range. 2176 2177 2178 @param bottom: Lower limit value. I{(float)} 2179 @param top: Upper limit value. I{(float)} 2180 @return: The number of changed values, i.e., values that were outside 2181 [B{C{bottom}}, B{C{top}}]. 2182 2183 """ 2184 return None

2185 - def area_clamp( col , row , width , height , bottom , top ):

2186 """ 2187 Limits values in a rectangular part of a data field to a range. 2188 2189 2190 @param col: Upper-left column coordinate. I{(int)} 2191 @param row: Upper-left row coordinate. I{(int)} 2192 @param width: Area width (number of columns). I{(int)} 2193 @param height: Area height (number of rows). I{(int)} 2194 @param bottom: Lower limit value. I{(float)} 2195 @param top: Upper limit value. I{(float)} 2196 @return: The number of changed values, i.e., values that were outside 2197 [B{C{bottom}}, B{C{top}}]. 2198 2199 """ 2200 return None

2201 - def area_gather( result , buffer , hsize , vsize , average , col , row , width , height ):

2202 """ 2203 Sums or averages values in reactangular areas around each sample in a data 2204 field. 2205 2206 When the gathered area extends out of calculation area, only samples from 2207 their intersection are taken into the local sum (or average). 2208 2209 There are no restrictions on values of B{C{hsize}} and B{C{vsize}} with regard to 2210 B{C{width}} and B{C{height}}, but they have to be positive. 2211 2212 The result is calculated by the means of two-dimensional rolling sums. 2213 One one hand it means the calculation time depends linearly on 2214 (B{C{width}} + B{C{hsize}})*(B{C{height}} + B{C{vsize}}) instead of 2215 B{C{width}}*B{C{hsize}}*B{C{height}}*B{C{vsize}}. On the other hand it means absolute rounding 2216 errors of all output values are given by the largest input values, that is 2217 relative precision of results small in absolute value may be poor. 2218 2219 @param result: A data field to put the result to, it may be B{C{data_field}} itself. I{(L{DataField})} 2220 @param buffer: A data field to use as a scratch area, its size must be at least 2221 B{C{width}}*B{C{height}}. May be B{C{NULL}} to allocate a private temporary 2222 buffer. I{(L{DataField})} 2223 @param col: Upper-left column coordinate. I{(int)} 2224 @param row: Upper-left row coordinate. I{(int)} 2225 @param width: Area width (number of columns). I{(int)} 2226 @param height: Area height (number of rows). I{(int)} 2227 @param hsize: Horizontal size of gathered area. The area is centered around 2228 each sample if B{C{hsize}} is odd, it extends one pixel more to the 2229 right if B{C{hsize}} is even. I{(int)} 2230 @param vsize: Vertical size of gathered area. The area is centered around 2231 each sample if B{C{vsize}} is odd, it extends one pixel more down 2232 if B{C{vsize}} is even. I{(int)} 2233 @param average: B{C{True}} to divide resulting sums by the number of involved samples 2234 to get averages instead of sums. I{(bool)} 2235 @return: 2236 """ 2237 return None

2238 - def convolve( kernel_field ):

2239 """ 2240 Convolves a data field with given kernel. 2241 2242 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 2243 @return: 2244 """ 2245 return None

2246 - def area_convolve( kernel_field , col , row , width , height ):

2247 """ 2248 Convolves a rectangular part of a data field with given kernel. 2249 2250 @param kernel_field: Kenrel field to convolve B{C{data_field}} with. I{(L{DataField})} 2251 @param col: Upper-left column coordinate. I{(int)} 2252 @param row: Upper-left row coordinate. I{(int)} 2253 @param width: Area width (number of columns). I{(int)} 2254 @param height: Area height (number of rows). I{(int)} 2255 @return: 2256 """ 2257 return None

2258 - def convolve_1d( kernel_line , orientation ):

2259 """ 2260 Convolves a data field with given linear kernel. 2261 2262 Since: 2.4 2263 2264 @param kernel_line: Kenrel line to convolve B{C{data_field}} with. I{(L{DataLine})} 2265 @param orientation: Filter orientation (see L{DataField.area_convolve_1d}()). I{(Orientation)} 2266 @return: 2267 """ 2268 return None

2269 - def area_convolve_1d( kernel_line , orientation , col , row , width , height ):

2270 """ 2271 Convolves a rectangular part of a data field with given linear kernel. 2272 2273 For large separable kernels it can be more efficient to use a sequence of 2274 horizontal and vertical convolutions instead one 2D convolution. 2275 2276 Since: 2.4 2277 2278 @param kernel_line: Kernel line to convolve B{C{data_field}} with. I{(L{DataLine})} 2279 @param orientation: Filter orientation (B{C{ORIENTATION_HORIZONTAL}} for 2280 row-wise convolution, B{C{ORIENTATION_VERTICAL}} for 2281 column-wise convolution). I{(Orientation)} 2282 @param col: Upper-left column coordinate. I{(int)} 2283 @param row: Upper-left row coordinate. I{(int)} 2284 @param width: Area width (number of columns). I{(int)} 2285 @param height: Area height (number of rows). I{(int)} 2286 @return: 2287 """ 2288 return None

2289 - def filter_median( size ):

2290 """ 2291 Filters a data field with median filter. 2292 2293 @param size: Size of area to take median of. I{(int)} 2294 @return: 2295 """ 2296 return None

2297 - def area_filter_median( size , col , row , width , height ):

2298 """ 2299 Filters a rectangular part of a data field with median filter. 2300 2301 @param size: Size of area to take median of. I{(int)} 2302 @param col: Upper-left column coordinate. I{(int)} 2303 @param row: Upper-left row coordinate. I{(int)} 2304 @param width: Area width (number of columns). I{(int)} 2305 @param height: Area height (number of rows). I{(int)} 2306 @return: 2307 """ 2308 return None

2309 - def filter_mean( size ):

2310 """ 2311 Filters a data field with mean filter of size B{C{size}}. 2312 2313 @param size: Averaged area size. I{(int)} 2314 @return: 2315 """ 2316 return None

2317 - def area_filter_mean( size , col , row , width , height ):

2318 """ 2319 Filters a rectangular part of a data field with mean filter of size B{C{size}}. 2320 2321 This method is a simple L{DataField.area_gather}() wrapper. 2322 2323 @param size: Averaged area size. I{(int)} 2324 @param col: Upper-left column coordinate. I{(int)} 2325 @param row: Upper-left row coordinate. I{(int)} 2326 @param width: Area width (number of columns). I{(int)} 2327 @param height: Area height (number of rows). I{(int)} 2328 @return: 2329 """ 2330 return None

2331 - def filter_conservative( size ):

2332 """ 2333 Filters a data field with conservative denoise filter. 2334 2335 @param size: Filtered area size. I{(int)} 2336 @return: 2337 """ 2338 return None

2339 - def area_filter_conservative( size , col , row , width , height ):

2340 """ 2341 Filters a rectangular part of a data field with conservative denoise filter. 2342 2343 @param size: Filtered area size. I{(int)} 2344 @param col: Upper-left column coordinate. I{(int)} 2345 @param row: Upper-left row coordinate. I{(int)} 2346 @param width: Area width (number of columns). I{(int)} 2347 @param height: Area height (number of rows). I{(int)} 2348 @return: 2349 """ 2350 return None

2351 - def filter_laplacian( ):

2352 """ 2353 Filters a data field with Laplacian filter. 2354 2355 @return: 2356 """ 2357 return None

2358 - def area_filter_laplacian( col , row , width , height ):

2359 """ 2360 Filters a rectangular part of a data field with Laplacian filter. 2361 2362 @param col: Upper-left column coordinate. I{(int)} 2363 @param row: Upper-left row coordinate. I{(int)} 2364 @param width: Area width (number of columns). I{(int)} 2365 @param height: Area height (number of rows). I{(int)} 2366 @return: 2367 """ 2368 return None

2369 - def filter_laplacian_of_gaussians( ):

2370 """ 2371 Filters a data field with Laplacian of Gaussians filter. 2372 2373 Since: 2.23 2374 2375 @return: 2376 """ 2377 return None

2378 - def area_filter_laplacian_of_gaussians( col , row , width , height ):

2379 """ 2380 Filters a rectangular part of a data field with Laplacian of Gaussians filter. 2381 2382 Since: 2.23 2383 2384 @param col: Upper-left column coordinate. I{(int)} 2385 @param row: Upper-left row coordinate. I{(int)} 2386 @param width: Area width (number of columns). I{(int)} 2387 @param height: Area height (number of rows). I{(int)} 2388 @return: 2389 """ 2390 return None

2391 - def filter_sobel( orientation ):

2392 """ 2393 Filters a data field with Sobel filter. 2394 2395 @param orientation: Filter orientation. I{(Orientation)} 2396 @return: 2397 """ 2398 return None

2399 - def area_filter_sobel( orientation , col , row , width , height ):

2400 """ 2401 Filters a rectangular part of a data field with Sobel filter. 2402 2403 @param orientation: Filter orientation. I{(Orientation)} 2404 @param col: Upper-left column coordinate. I{(int)} 2405 @param row: Upper-left row coordinate. I{(int)} 2406 @param width: Area width (number of columns). I{(int)} 2407 @param height: Area height (number of rows). I{(int)} 2408 @return: 2409 """ 2410 return None

2411 - def filter_prewitt( orientation ):

2412 """ 2413 Filters a data field with Prewitt filter. 2414 2415 @param orientation: Filter orientation. I{(Orientation)} 2416 @return: 2417 """ 2418 return None

2419 - def area_filter_prewitt( orientation , col , row , width , height ):

2420 """ 2421 Filters a rectangular part of a data field with Prewitt filter. 2422 2423 @param orientation: Filter orientation. I{(Orientation)} 2424 @param col: Upper-left column coordinate. I{(int)} 2425 @param row: Upper-left row coordinate. I{(int)} 2426 @param width: Area width (number of columns). I{(int)} 2427 @param height: Area height (number of rows). I{(int)} 2428 @return: 2429 """ 2430 return None

2431 - def filter_dechecker( ):

2432 """ 2433 Filters a data field with 5x5 checker pattern removal filter. 2434 2435 Since: 2.1 2436 2437 @return: 2438 """ 2439 return None

2440 - def area_filter_dechecker( col , row , width , height ):

2441 """ 2442 Filters a rectangular part of a data field with 5x5 checker pattern removal 2443 filter. 2444 2445 Since: 2.1 2446 2447 @param col: Upper-left column coordinate. I{(int)} 2448 @param row: Upper-left row coordinate. I{(int)} 2449 @param width: Area width (number of columns). I{(int)} 2450 @param height: Area height (number of rows). I{(int)} 2451 @return: 2452 """ 2453 return None

2454 - def filter_gaussian( sigma ):

2455 """ 2456 Filters a data field with a Gaussian filter. 2457 2458 Since: 2.4 2459 2460 @param sigma: The sigma parameter of the Gaussian. I{(float)} 2461 @return: 2462 """ 2463 return None

2464 - def area_filter_gaussian( sigma , col , row , width , height ):

2465 """ 2466 Filters a rectangular part of a data field with a Gaussian filter. 2467 2468 The Gausian is normalized, i.e. it is sum-preserving. 2469 2470 Since: 2.4 2471 2472 @param sigma: The sigma parameter of the Gaussian. I{(float)} 2473 @param col: Upper-left column coordinate. I{(int)} 2474 @param row: Upper-left row coordinate. I{(int)} 2475 @param width: Area width (number of columns). I{(int)} 2476 @param height: Area height (number of rows). I{(int)} 2477 @return: 2478 """ 2479 return None

2480 - def filter_minimum( size ):

2481 """ 2482 Filters a data field with minimum filter. 2483 2484 @param size: Neighbourhood size for minimum search. I{(int)} 2485 @return: 2486 """ 2487 return None

2488 - def area_filter_minimum( size , col , row , width , height ):

2489 """ 2490 Filters a rectangular part of a data field with minimum filter. 2491 2492 This operation is often called erosion filter. 2493 2494 @param size: Neighbourhood size for minimum search. I{(int)} 2495 @param col: Upper-left column coordinate. I{(int)} 2496 @param row: Upper-left row coordinate. I{(int)} 2497 @param width: Area width (number of columns). I{(int)} 2498 @param height: Area height (number of rows). I{(int)} 2499 @return: 2500 """ 2501 return None

2502 - def filter_maximum( size ):

2503 """ 2504 Filters a data field with maximum filter. 2505 2506 @param size: Neighbourhood size for maximum search. I{(int)} 2507 @return: 2508 """ 2509 return None

2510 - def area_filter_maximum( size , col , row , width , height ):

2511 """ 2512 Filters a rectangular part of a data field with maximum filter. 2513 2514 This operation is often called dilation filter. 2515 2516 @param size: Neighbourhood size for maximum search. I{(int)} 2517 @param col: Upper-left column coordinate. I{(int)} 2518 @param row: Upper-left row coordinate. I{(int)} 2519 @param width: Area width (number of columns). I{(int)} 2520 @param height: Area height (number of rows). I{(int)} 2521 @return: 2522 """ 2523 return None

2524 - def filter_rms( size ):

2525 """ 2526 Filters a data field with RMS filter. 2527 2528 @param size: Area size. I{(int)} 2529 @return: 2530 """ 2531 return None

2532 - def area_filter_rms( size , col , row , width , height ):

2533 """ 2534 Filters a rectangular part of a data field with RMS filter of size B{C{size}}. 2535 2536 RMS filter computes root mean square in given area. 2537 2538 @param size: Area size. I{(int)} 2539 @param col: Upper-left column coordinate. I{(int)} 2540 @param row: Upper-left row coordinate. I{(int)} 2541 @param width: Area width (number of columns). I{(int)} 2542 @param height: Area height (number of rows). I{(int)} 2543 @return: 2544 """ 2545 return None

2546 - def filter_kuwahara( ):

2547 """ 2548 Filters a data field with Kuwahara filter. 2549 2550 @return: 2551 """ 2552 return None

2553 - def area_filter_kuwahara( col , row , width , height ):

2554 """ 2555 Filters a rectangular part of a data field with a Kuwahara 2556 (edge-preserving smoothing) filter. 2557 2558 @param col: Upper-left column coordinate. I{(int)} 2559 @param row: Upper-left row coordinate. I{(int)} 2560 @param width: Area width (number of columns). I{(int)} 2561 @param height: Area height (number of rows). I{(int)} 2562 @return: 2563 """ 2564 return None

2565 - def filter_canny( threshold ):

2566 """ 2567 Filters a rectangular part of a data field with canny edge detector filter. 2568 2569 @param threshold: Slope detection threshold (range 0..1). I{(float)} 2570 @return: 2571 """ 2572 return None

2573 - def shade( target_field , theta , phi ):

2574 """ 2575 Shades a data field. 2576 2577 @param target_field: A data field to put the shade to. It will be resized to 2578 match B{C{data_field}}. I{(L{DataField})} 2579 @param theta: Shading angle (in radians, from north pole). I{(float)} 2580 @param phi: Shade orientation in xy plane (in radians, counterclockwise). I{(float)} 2581 @return: 2582 """ 2583 return None

2584 - def filter_harris( y_gradient , result , neighbourhood , alpha ):

2585 return None

2586 - def fractal_partitioning( xresult , yresult , interpolation ):

2587 """ 2588 Computes data for log-log plot by partitioning. 2589 2590 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 2591 they will contain corresponding values at each position. 2592 2593 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 2594 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 2595 @param interpolation: Interpolation type. I{(InterpolationType)} 2596 @return: 2597 """ 2598 return None

2599 - def fractal_cubecounting( xresult , yresult , interpolation ):

2600 """ 2601 Computes data for log-log plot by cube counting. 2602 2603 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 2604 they will contain corresponding values at each position. 2605 2606 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 2607 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 2608 @param interpolation: Interpolation type. I{(InterpolationType)} 2609 @return: 2610 """ 2611 return None

2612 - def fractal_triangulation( xresult , yresult , interpolation ):

2613 """ 2614 Computes data for log-log plot by triangulation. 2615 2616 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 2617 they will contain corresponding values at each position. 2618 2619 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 2620 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 2621 @param interpolation: Interpolation type. I{(InterpolationType)} 2622 @return: 2623 """ 2624 return None

2625 - def fractal_psdf( xresult , yresult , interpolation ):

2626 """ 2627 Computes data for log-log plot by spectral density method. 2628 2629 Data lines B{C{xresult}} and B{C{yresult}} will be resized to the output size and 2630 they will contain corresponding values at each position. 2631 2632 @param xresult: Data line to store x-values for log-log plot to. I{(L{DataLine})} 2633 @param yresult: Data line to store y-values for log-log plot to. I{(L{DataLine})} 2634 @param interpolation: Interpolation type. I{(InterpolationType)} 2635 @return: 2636 """ 2637 return None

2638 - def fractal_correction( mask_field , interpolation ):

2639 """ 2640 Replaces data under mask with interpolated values using fractal 2641 interpolation. 2642 2643 @param mask_field: Mask of places to be corrected. I{(L{DataField})} 2644 @param interpolation: Interpolation type. I{(InterpolationType)} 2645 @return: 2646 """ 2647 return None

2648 - def grains_mark_curvature( grain_field , threshval , below ):

2649 """ 2650 Marks data that are above/below curvature threshold. 2651 2652 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 2653 @param threshval: Relative curvature threshold, in percents. I{(float)} 2654 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 2655 threshold are marked. I{(bool)} 2656 @return: 2657 """ 2658 return None

2659 - def grains_mark_watershed( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):

2660 """ 2661 Performs watershed algorithm. 2662 2663 @param grain_field: Result of marking (mask). I{(L{DataField})} 2664 @param locate_steps: Locating algorithm steps. I{(int)} 2665 @param locate_thresh: Locating algorithm threshold. I{(int)} 2666 @param locate_dropsize: Locating drop size. I{(float)} 2667 @param wshed_steps: Watershed steps. I{(int)} 2668 @param wshed_dropsize: Watershed drop size. I{(float)} 2669 @param prefilter: Use prefiltering. I{(bool)} 2670 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 2671 @return: 2672 """ 2673 return None

2674 - def grains_remove_grain( col , row ):

2675 """ 2676 Removes one grain at given position. 2677 2678 2679 @param col: Column inside a grain. I{(int)} 2680 @param row: Row inside a grain. I{(int)} 2681 @return: B{C{True}} if a grain was actually removed (i.e., (B{C{col}},B{C{row}}) was 2682 inside a grain). 2683 2684 """ 2685 return None

2686 - def grains_extract_grain( col , row ):

2687 """ 2688 Removes all grains except that one at given position. 2689 2690 If there is no grain at (B{C{col}}, B{C{row}}), all grains are removed. 2691 2692 2693 @param col: Column inside a grain. I{(int)} 2694 @param row: Row inside a grain. I{(int)} 2695 @return: B{C{True}} if a grain remained (i.e., (B{C{col}},B{C{row}}) was inside a grain). 2696 2697 """ 2698 return None

2699 - def grains_remove_by_size( size ):

2700 """ 2701 Removes all grain below specified area. 2702 2703 @param size: Grain area threshold, in square pixels. I{(int)} 2704 @return: 2705 """ 2706 return None

2707 - def grains_remove_by_height( grain_field , threshval , below ):

2708 """ 2709 Removes grains that are higher/lower than given threshold value. 2710 2711 @param grain_field: Field of marked grains (mask) I{(L{DataField})} 2712 @param threshval: Relative height threshold, in percents. I{(float)} 2713 @param below: If B{C{True}}, grains below threshold are removed, otherwise grains above 2714 threshold are removed. I{(bool)} 2715 @return: 2716 """ 2717 return None

2718 - def UNIMPLEMENTED_grains_watershed_init( grain_field , locate_steps , locate_thresh , locate_dropsize , wshed_steps , wshed_dropsize , prefilter , below ):

2719 """ 2720 Initializes the watershed algorithm. 2721 2722 This iterator reports its state as B{C{WatershedStateType}}. 2723 2724 2725 @param grain_field: Result of marking (mask). I{(L{DataField})} 2726 @param locate_steps: Locating algorithm steps. I{(int)} 2727 @param locate_thresh: Locating algorithm threshold. I{(int)} 2728 @param locate_dropsize: Locating drop size. I{(float)} 2729 @param wshed_steps: Watershed steps. I{(int)} 2730 @param wshed_dropsize: Watershed drop size. I{(float)} 2731 @param prefilter: Use prefiltering. I{(bool)} 2732 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 2733 @return: A new watershed iterator. 2734 2735 """ 2736 return None

2737 - def grains_mark_height( grain_field , threshval , below ):

2738 """ 2739 Marks data that are above/below height threshold. 2740 2741 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 2742 @param threshval: Relative height threshold, in percents. I{(float)} 2743 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 2744 threshold are marked. I{(bool)} 2745 @return: 2746 """ 2747 return None

2748 - def grains_mark_slope( grain_field , threshval , below ):

2749 """ 2750 Marks data that are above/below slope threshold. 2751 2752 @param grain_field: Data field to store the resulting mask to. I{(L{DataField})} 2753 @param threshval: Relative slope threshold, in percents. I{(float)} 2754 @param below: If B{C{True}}, data below threshold are marked, otherwise data above 2755 threshold are marked. I{(bool)} 2756 @return: 2757 """ 2758 return None

2759 - def grains_add( add_field ):

2760 """ 2761 Adds B{C{add_field}} grains to B{C{grain_field}}. 2762 2763 Note: This function is equivalent to 2764 <literal>L{DataField.max_of_fields}(grain_field, grain_field, add_field);</literal> 2765 and it will be probably removed someday. 2766 2767 @param add_field: Field of marked grains (mask) to be added. I{(L{DataField})} 2768 @return: 2769 """ 2770 return None

2771 - def grains_intersect( intersect_field ):

2772 """ 2773 Performs intersection betweet two grain fields, 2774 result is stored in B{C{grain_field}}. 2775 2776 Note: This function is equivalent to 2777 <literal>L{DataField.min_of_fields}(grain_field, grain_field, intersect_field);</literal> 2778 and it will be probably removed someday. 2779 2780 @param intersect_field: Field of marked grains (mask). I{(L{DataField})} 2781 @return: 2782 """ 2783 return None

2784 - def UNIMPLEMENTED_number_grains( grains ):

2785 """ 2786 Numbers grains in a mask data field. 2787 2788 2789 @param grains: Zero-filled array of integers of equal size to B{C{mask_field}} to put 2790 grain numbers to. Empty space will be left 0, pixels inside a 2791 grain will be set to grain number. Grains are numbered 2792 sequentially 1, 2, 3, ... I{(gint*)} 2793 @return: The number of last grain (note they are numbered from 1). 2794 2795 """ 2796 return None

2797 - def UNIMPLEMENTED_get_grain_bounding_boxes( ngrains , grains , bboxes ):

2798 """ 2799 Find bounding boxes of all grains. 2800 2801 Since: 2.3 2802 2803 @param ngrains: The number of grains as returned by 2804 L{DataField.number_grains}(). I{(int)} 2805 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 2806 @param bboxes: Array of size at least 4*(B{C{ngrains}}+1) to fill with grain bounding 2807 boxes (as usual zero does not correspond to any grain, grains 2808 start from 1). The bounding boxes are stored as quadruples of 2809 indices: (xmin, ymin, width, height). It can be B{C{NULL}} to allocate 2810 a new array. I{(gint*)} 2811 @return: Either B{C{bboxes}} (if it was not B{C{NULL}}), or a newly allocated array 2812 of size 4B{C{ngrains}}. 2813 2814 2815 """ 2816 return None

2817 - def UNIMPLEMENTED_grains_get_distribution( grain_field , distribution , ngrains , grains , quantity , nstats ):

2818 """ 2819 Computes distribution of requested grain characteristics. 2820 2821 Puts number of grains vs. grain value data into B{C{distribution}}, units, scales 2822 and offsets of B{C{distribution}} are updated accordingly. 2823 2824 2825 @param grain_field: Data field (mask) of marked grains. Note if you pass 2826 non-B{C{NULL}} B{C{grains}} all grain information is taken from it and 2827 B{C{grain_field}} can be even B{C{NULL}} then. I{(L{DataField})} 2828 @param distribution: Data line to store grain distribution to. I{(L{DataLine})} 2829 @param grains: Grain numbers filled with L{DataField.number_grains}() if you 2830 have it, or B{C{NULL}} (the function then finds grain numbers itself 2831 which is not efficient for repeated use on the same grain field). I{(const-gint*)} 2832 @param ngrains: The number of grains as returned by 2833 L{DataField.number_grains}(). Ignored in B{C{grains}} is B{C{NULL}}. I{(int)} 2834 @param quantity: The quantity to calculate. I{(GrainQuantity)} 2835 @param nstats: The number of samples to take on the distribution function. If 2836 nonpositive, a suitable resolution is determined automatically. I{(int)} 2837 @return: A data line with the distribution: B{C{distribution}} itself if it was 2838 not B{C{NULL}}, otherwise a newly created B{C{DataLine}} caller must 2839 destroy. If there are no grains, B{C{NULL}} is returned and 2840 B{C{distribution}} is not changed. 2841 2842 """ 2843 return None

2844 - def UNIMPLEMENTED_grains_get_values( values , ngrains , grains , quantity ):

2845 """ 2846 Calculates characteristics of grains. 2847 2848 This is a bit low-level function, see also 2849 L{DataField.grains_get_distribution}(). 2850 2851 The array B{C{values}} will be filled with the requested grain value for each 2852 individual grain (0th item of B{C{values}} which does not correspond to any grain 2853 will be overwritten with an arbitrary value and should be ignored). 2854 2855 The grain numbers serve as indices in B{C{values}}. Therefore as long as the 2856 same B{C{grains}} is used, the same position in B{C{values}} corresponds to the same 2857 particular grain. This enables one for instance to calculate grain sizes 2858 and grain heights and then correlate them. 2859 2860 2861 @param values: Array of size B{C{ngrains}}+1 to put grain values to. It can be 2862 B{C{NULL}} to allocate and return a new array. I{(gdouble*)} 2863 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 2864 @param ngrains: The number of grains as returned by 2865 L{DataField.number_grains}(). I{(int)} 2866 @param quantity: The quantity to calculate. I{(GrainQuantity)} 2867 @return: B{C{values}} itself if it was not B{C{NULL}}, otherwise a newly allocated 2868 array that caller has to free. 2869 2870 """ 2871 return None

2872 - def UNIMPLEMENTED_grains_get_quantities( values , quantities , nquantities , ngrains , grains ):

2873 """ 2874 Calculates multiple characteristics of grains simultaneously. 2875 2876 See L{DataField.grains_get_values}() for some discussion. This function 2877 is more efficient if several grain quantities need to be calculated since 2878 L{DataField.grains_get_values}() can do lot of repeated work in such case. 2879 2880 Since: 2.22 2881 2882 @param values: Array of B{C{nquantities}} pointers to blocks of length B{C{ngrains}}+1 to 2883 put the calculated grain values to. Each block corresponds to one 2884 requested quantity. B{C{NULL}} can be passed to allocate and return a 2885 new array. I{(gdouble**)} 2886 @param quantities: Array of B{C{nquantities}} items that specify the requested 2887 B{C{GrainQuantity}} to put to corresponding items in B{C{values}}. 2888 Quantities can repeat. I{(const-GrainQuantity*)} 2889 @param nquantities: The number of requested different grain values. I{(int)} 2890 @param grains: Grain numbers filled with L{DataField.number_grains}(). I{(const-gint*)} 2891 @param ngrains: The number of grains as returned by 2892 L{DataField.number_grains}(). I{(int)} 2893 @return: B{C{values}} itself if it was not B{C{NULL}}, otherwise a newly allocated 2894 array that caller has to free with g_free(), including the 2895 contained arrays. 2896 2897 2898 """ 2899 return None

2900 - def area_grains_tgnd( target_line , col , row , width , height , below , nstats ):

2901 """ 2902 Calculates threshold grain number distribution. 2903 2904 This function is a simple L{DataField.area_grains_tgnd_range}() that 2905 calculates the distribution in the full range. 2906 2907 @param target_line: A data line to store the distribution to. It will be 2908 resampled to the requested width. I{(L{DataLine})} 2909 @param col: Upper-left column coordinate. I{(int)} 2910 @param row: Upper-left row coordinate. I{(int)} 2911 @param width: Area width (number of columns). I{(int)} 2912 @param height: Area height (number of rows). I{(int)} 2913 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 2914 @param nstats: The number of samples to take on the distribution function. If 2915 nonpositive, a suitable resolution is determined automatically. I{(int)} 2916 @return: 2917 """ 2918 return None

2919 - def area_grains_tgnd_range( target_line , col , row , width , height , min , max , below , nstats ):

2920 """ 2921 Calculates threshold grain number distribution in given height range. 2922 2923 This is the number of grains for each of B{C{nstats}} equidistant height 2924 threshold levels. For large B{C{nstats}} this function is much faster than the 2925 equivalent number of L{DataField.grains_mark_height}() calls. 2926 2927 @param target_line: A data line to store the distribution to. It will be 2928 resampled to the requested width. I{(L{DataLine})} 2929 @param col: Upper-left column coordinate. I{(int)} 2930 @param row: Upper-left row coordinate. I{(int)} 2931 @param width: Area width (number of columns). I{(int)} 2932 @param height: Area height (number of rows). I{(int)} 2933 @param min: Minimum threshold value. I{(float)} 2934 @param max: Maximum threshold value. I{(float)} 2935 @param below: If B{C{True}}, valleys are marked, otherwise mountains are marked. I{(bool)} 2936 @param nstats: The number of samples to take on the distribution function. If 2937 nonpositive, a suitable resolution is determined automatically. I{(int)} 2938 @return: 2939 """ 2940 return None

2941 - def grains_splash_water( minima , locate_steps , locate_dropsize ):

2942 return None

2943 - def hough_line( x_gradient , y_gradient , result , hwidth , overlapping ):

2944 return None

2945 - def hough_circle( x_gradient , y_gradient , result , radius ):

2946 return None

2947 - def hough_line_strenghten( x_gradient , y_gradient , hwidth , threshold ):

2948 return None

2949 - def hough_circle_strenghten( x_gradient , y_gradient , radius , threshold ):

2950 return None

2951 - def UNIMPLEMENTED_get_local_maxima_list( xdata , ydata , zdata , ndata , skip , threshold , subpixel ):

2952 return None

2953 - def hough_polar_line_to_datafield( rho , theta , px1 , px2 , py1 , py2 ):

2954 return None

2955 - def a_1dfft( iin , rout , iout , orientation , windowing , direction , interpolation , preserverms , level ):

2956 """ 2957 Transforms all rows or columns in a data field with Fast Fourier Transform. 2958 2959 If requested a windowing and/or leveling is applied to preprocess data to 2960 obtain reasonable results. 2961 2962 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 2963 transform which can be somewhat faster than complex-to-complex 2964 transform. I{(L{DataField})} 2965 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 2966 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 2967 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 2968 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 2969 columns. I{(Orientation)} 2970 @param windowing: Windowing type. I{(WindowingType)} 2971 @param direction: FFT direction. I{(TransformDirection)} 2972 @param interpolation: Interpolation type. 2973 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 2974 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 2975 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 2976 line (the number can be interpreted as the first polynomial degree 2977 to keep, but only the enumerated three values are available). I{(int)} 2978 @return: 2979 """ 2980 return None

2981 - def area_1dfft( iin , rout , iout , col , row , width , height , orientation , windowing , direction , interpolation , preserverms , level ):

2982 """ 2983 Transforms all rows or columns in a rectangular part of a data field with 2984 Fast Fourier Transform. 2985 2986 If requested a windowing and/or leveling is applied to preprocess data to 2987 obtain reasonable results. 2988 2989 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 2990 transform which can be somewhat faster than complex-to-complex 2991 transform. I{(L{DataField})} 2992 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 2993 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 2994 @param col: Upper-left column coordinate. I{(int)} 2995 @param row: Upper-left row coordinate. I{(int)} 2996 @param width: Area width (number of columns), must be at least 2 for horizontal 2997 transforms. I{(int)} 2998 @param height: Area height (number of rows), must be at least 2 for vertical 2999 transforms. I{(int)} 3000 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 3001 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 3002 columns. I{(Orientation)} 3003 @param windowing: Windowing type. I{(WindowingType)} 3004 @param direction: FFT direction. I{(TransformDirection)} 3005 @param interpolation: Interpolation type. 3006 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 3007 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 3008 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 3009 lines (the number can be interpreted as the first polynomial degree 3010 to keep, but only the enumerated three values are available). I{(int)} 3011 @return: 3012 """ 3013 return None

3014 - def a_1dfft_raw( iin , rout , iout , orientation , direction ):

3015 """ 3016 Transforms all rows or columns in a data field with Fast Fourier Transform. 3017 3018 No leveling, windowing nor scaling is performed. 3019 3020 Since 2.8 the dimensions need not to be from the set of sizes returned 3021 by L{gwy_fft_find_nice_size}(). 3022 3023 Since: 2.1 3024 3025 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 3026 transform. I{(L{DataField})} 3027 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 3028 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 3029 @param orientation: Orientation: pass B{C{ORIENTATION_HORIZONTAL}} to 3030 transform rows, B{C{ORIENTATION_VERTICAL}} to transform 3031 columns. I{(Orientation)} 3032 @param direction: FFT direction. I{(TransformDirection)} 3033 @return: 3034 """ 3035 return None

3036 - def a_2dfft( iin , rout , iout , windowing , direction , interpolation , preserverms , level ):

3037 """ 3038 Calculates 2D Fast Fourier Transform of a rectangular a data field. 3039 3040 If requested a windowing and/or leveling is applied to preprocess data to 3041 obtain reasonable results. 3042 3043 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 3044 transform which can be somewhat faster than complex-to-complex 3045 transform. I{(L{DataField})} 3046 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 3047 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 3048 @param windowing: Windowing type. I{(WindowingType)} 3049 @param direction: FFT direction. I{(TransformDirection)} 3050 @param interpolation: Interpolation type. I{(InterpolationType)} 3051 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 3052 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 3053 plane (the number can be interpreted as the first polynomial degree 3054 to keep, but only the enumerated three values are available). I{(int)} 3055 @return: 3056 """ 3057 return None

3058 - def area_2dfft( iin , rout , iout , col , row , width , height , windowing , direction , interpolation , preserverms , level ):

3059 """ 3060 Calculates 2D Fast Fourier Transform of a rectangular area of a data field. 3061 3062 If requested a windowing and/or leveling is applied to preprocess data to 3063 obtain reasonable results. 3064 3065 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 3066 transform which can be somewhat faster than complex-to-complex 3067 transform. I{(L{DataField})} 3068 @param rout: Real output data field, it will be resized to area size. I{(L{DataField})} 3069 @param iout: Imaginary output data field, it will be resized to area size. I{(L{DataField})} 3070 @param col: Upper-left column coordinate. I{(int)} 3071 @param row: Upper-left row coordinate. I{(int)} 3072 @param width: Area width (number of columns), must be at least 2. I{(int)} 3073 @param height: Area height (number of rows), must be at least 2. I{(int)} 3074 @param windowing: Windowing type. I{(WindowingType)} 3075 @param direction: FFT direction. I{(TransformDirection)} 3076 @param interpolation: Interpolation type. 3077 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 3078 @param preserverms: B{C{True}} to preserve RMS while windowing. I{(bool)} 3079 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 3080 plane (the number can be interpreted as the first polynomial degree 3081 to keep, but only the enumerated three values are available). I{(int)} 3082 @return: 3083 """ 3084 return None

3085 - def a_2dfft_raw( iin , rout , iout , direction ):

3086 """ 3087 Calculates 2D Fast Fourier Transform of a data field. 3088 3089 No leveling, windowing nor scaling is performed. 3090 3091 Since 2.8 the dimensions need not to be from the set of sizes returned 3092 by L{gwy_fft_find_nice_size}(). 3093 3094 Since: 2.1 3095 3096 @param iin: Imaginary input data field. It can be B{C{NULL}} for real-to-complex 3097 transform. I{(L{DataField})} 3098 @param rout: Real output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 3099 @param iout: Imaginary output data field, it will be resized to B{C{rin}} size. I{(L{DataField})} 3100 @param direction: FFT direction. I{(TransformDirection)} 3101 @return: 3102 """ 3103 return None

3104 - def a_2dfft_humanize( ):

3105 """ 3106 Rearranges 2D FFT output to a human-friendly form. 3107 3108 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 3109 to obtain a humanized 2D FFT output with (0,0) in the centre. 3110 3111 More precisely, for even field dimensions the equally-sized blocks starting 3112 with the Nyquist frequency and with the zero frequency (constant component) 3113 will exchange places. For odd field dimensions, the block containing the 3114 zero frequency is one item larger and the constant component will actually 3115 end up in the exact centre. 3116 3117 Also note if both dimensions are even, this function is involutory and 3118 identical to L{DataField.2dfft_dehumanize}(). However, if any dimension 3119 is odd, L{DataField.2dfft_humanize}() and 3120 L{DataField.2dfft_dehumanize}() are different, therefore they must be 3121 paired properly. 3122 3123 @return: 3124 """ 3125 return None

3126 - def a_2dfft_dehumanize( ):

3127 """ 3128 Rearranges 2D FFT output back from the human-friendly form. 3129 3130 Top-left, top-right, bottom-left and bottom-right sub-rectangles are swapped 3131 to reshuffle a humanized 2D FFT output back into the natural positions. 3132 3133 See L{DataField.2dfft_humanize}() for discussion. 3134 3135 Since: 2.8 3136 3137 @return: 3138 """ 3139 return None

3140 - def fft_filter_1d( result_field , weights , orientation , interpolation ):

3141 """ 3142 Performs 1D FFT filtering of a data field. 3143 3144 @param result_field: A data field to store the result to. It will be resampled 3145 to B{C{data_field}}'s size. I{(L{DataField})} 3146 @param weights: Filter weights for the lower half of the spectrum (the other 3147 half is symmetric). Its size can be arbitrary, it will be 3148 interpolated. I{(L{DataLine})} 3149 @param orientation: Filter direction. I{(Orientation)} 3150 @param interpolation: The interpolation to use for resampling. I{(InterpolationType)} 3151 @return: 3152 """ 3153 return None

3154 - def UNIMPLEMENTED_cwt( interpolation , scale , wtype ):

3155 """ 3156 Computes a continuous wavelet transform (CWT) at given 3157 scale and using given wavelet. 3158 3159 @param interpolation: Interpolation type. 3160 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 3161 @param scale: Wavelet scale. I{(float)} 3162 @param wtype: Wavelet type. I{(2DCWTWaveletType)} 3163 @return: 3164 """ 3165 return None

3166 - def area_fit_plane( mask , col , row , width , height , pa , pbx , pby ):

3167 """ 3168 Fits a plane through a rectangular part of a data field. 3169 3170 The coefficients can be used for plane leveling using the same relation 3171 as in L{DataField.fit_plane}(), counting indices from area top left 3172 corner. 3173 3174 @param mask: Mask of values to take values into account, or B{C{NULL}} for full 3175 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 3176 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 3177 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 3178 for values inside (0.0, 1.0) is undefined (it may be specified 3179 in the future). I{(L{DataField})} 3180 @param col: Upper-left column coordinate. I{(int)} 3181 @param row: Upper-left row coordinate. I{(int)} 3182 @param width: Area width (number of columns). I{(int)} 3183 @param height: Area height (number of rows). I{(int)} 3184 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 3185 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 3186 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 3187 @return: 3188 """ 3189 return None

3190 - def fit_plane( pa , pbx , pby ):

3191 """ 3192 Fits a plane through a data field. 3193 3194 The coefficients can be used for plane leveling using relation 3195 data[i] := data[i] - (pa + pby*i + pbx*j); 3196 3197 @param pa: Where constant coefficient should be stored (or B{C{NULL}}). I{(float)} 3198 @param pbx: Where x plane coefficient should be stored (or B{C{NULL}}). I{(float)} 3199 @param pby: Where y plane coefficient should be stored (or B{C{NULL}}). I{(float)} 3200 @return: 3201 """ 3202 return None

3203 - def plane_level( a , bx , by ):

3204 """ 3205 Subtracts plane from a data field. 3206 3207 See L{DataField.fit_plane}() for details. 3208 3209 @param a: Constant coefficient. I{(float)} 3210 @param bx: X plane coefficient. I{(float)} 3211 @param by: Y plane coefficient. I{(float)} 3212 @return: 3213 """ 3214 return None

3215 - def plane_rotate( xangle , yangle , interpolation ):

3216 """ 3217 Performs rotation of plane along x and y axis. 3218 3219 @param xangle: Rotation angle in x direction (rotation along y axis, in radians). I{(float)} 3220 @param yangle: Rotation angle in y direction (rotation along x axis, in radians). I{(float)} 3221 @param interpolation: Interpolation type (can be only of two-point type). I{(InterpolationType)} 3222 @return: 3223 """ 3224 return None

3225 - def fit_lines( col , row , width , height , degree , exclude , orientation ):

3226 """ 3227 Independently levels profiles on each row/column in a data field. 3228 3229 Lines that have no intersection with area selected by B{C{ulcol}}, B{C{ulrow}}, 3230 B{C{brcol}}, B{C{brrow}} are always leveled as a whole. Lines that have intersection 3231 with selected area, are leveled using polynomial coefficients computed only 3232 from data inside (or outside for B{C{exclude}} = B{C{True}}) the area. 3233 3234 @param col: Upper-left column coordinate. I{(int)} 3235 @param row: Upper-left row coordinate. I{(int)} 3236 @param width: Area width (number of columns). I{(int)} 3237 @param height: Area height (number of rows). I{(int)} 3238 @param degree: Fitted polynomial degree. I{(int)} 3239 @param exclude: If B{C{True}}, outside of area selected by B{C{ulcol}}, B{C{ulrow}}, B{C{brcol}}, 3240 B{C{brrow}} will be used for polynomial coefficients computation, 3241 instead of inside. I{(bool)} 3242 @param orientation: Line orientation. I{(Orientation)} 3243 @return: 3244 """ 3245 return None

3246 - def fit_polynom( col_degree , row_degree , coeffs ):

3247 """ 3248 Fits a two-dimensional polynomial to a data field. 3249 3250 3251 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 3252 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 3253 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 3254 coefficients to, or B{C{NULL}} (a fresh array is allocated then), 3255 see L{DataField.area_fit_polynom}() for details. I{(gdouble*)} 3256 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3257 with coefficients. 3258 3259 """ 3260 return None

3261 - def area_fit_polynom( col , row , width , height , col_degree , row_degree , coeffs ):

3262 """ 3263 Fits a two-dimensional polynomial to a rectangular part of a data field. 3264 3265 The coefficients are stored by row into B{C{coeffs}}, like data in a datafield. 3266 Row index is y-degree, column index is x-degree. 3267 3268 Note naive x^n y^m polynomial fitting is numerically unstable, therefore 3269 this method works only up to B{C{col_degree}} = B{C{row_degree}} = 6. 3270 3271 3272 @param col: Upper-left column coordinate. I{(int)} 3273 @param row: Upper-left row coordinate. I{(int)} 3274 @param width: Area width (number of columns). I{(int)} 3275 @param height: Area height (number of rows). I{(int)} 3276 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 3277 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 3278 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 3279 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 3280 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3281 with coefficients. 3282 3283 """ 3284 return None

3285 - def subtract_polynom( col_degree , row_degree , coeffs ):

3286 """ 3287 Subtracts a two-dimensional polynomial from a data field. 3288 3289 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 3290 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 3291 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 3292 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 3293 @return: 3294 """ 3295 return None

3296 - def area_subtract_polynom( col , row , width , height , col_degree , row_degree , coeffs ):

3297 """ 3298 Subtracts a two-dimensional polynomial from a rectangular part of a data 3299 field. 3300 3301 @param col: Upper-left column coordinate. I{(int)} 3302 @param row: Upper-left row coordinate. I{(int)} 3303 @param width: Area width (number of columns). I{(int)} 3304 @param height: Area height (number of rows). I{(int)} 3305 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 3306 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 3307 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 3308 see L{DataField.area_fit_polynom}() for details. I{(const-gdouble*)} 3309 @return: 3310 """ 3311 return None

3312 - def UNIMPLEMENTED_fit_legendre( col_degree , row_degree , coeffs ):

3313 """ 3314 Fits two-dimensional Legendre polynomial to a data field. 3315 3316 See L{DataField.area_fit_legendre}() for details. 3317 3318 3319 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 3320 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 3321 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 3322 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 3323 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3324 with coefficients. 3325 3326 """ 3327 return None

3328 - def UNIMPLEMENTED_area_fit_legendre( col , row , width , height , col_degree , row_degree , coeffs ):

3329 """ 3330 Fits two-dimensional Legendre polynomial to a rectangular part of a data 3331 field. 3332 3333 The B{C{col_degree}} and B{C{row_degree}} parameters limit the maximum powers of x and 3334 y exactly as if simple powers were fitted, therefore if you do not intend to 3335 interpret contents of B{C{coeffs}} youself, the only difference is that this 3336 method is much more numerically stable. 3337 3338 The coefficients are organized exactly like in 3339 L{DataField.area_fit_polynom}(), but they are not coefficients of 3340 x^n y^m, instead they are coefficients of P_n(x) P_m(x), where P are 3341 Legendre polynomials. The polynomials are evaluated in coordinates where 3342 first row (column) corresponds to -1.0, and the last row (column) to 1.0. 3343 3344 Note the polynomials are normal Legendre polynomials that are not exactly 3345 orthogonal on a discrete point set (if their degrees are equal mod 2). 3346 3347 3348 @param col: Upper-left column coordinate. I{(int)} 3349 @param row: Upper-left row coordinate. I{(int)} 3350 @param width: Area width (number of columns). I{(int)} 3351 @param height: Area height (number of rows). I{(int)} 3352 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 3353 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 3354 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) to store the 3355 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 3356 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3357 with coefficients. 3358 3359 """ 3360 return None

3361 - def subtract_legendre( col_degree , row_degree , coeffs ):

3362 """ 3363 Subtracts a two-dimensional Legendre polynomial fit from a data field. 3364 3365 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 3366 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 3367 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 3368 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 3369 @return: 3370 """ 3371 return None

3372 - def area_subtract_legendre( col , row , width , height , col_degree , row_degree , coeffs ):

3373 """ 3374 Subtracts a two-dimensional Legendre polynomial fit from a rectangular part 3375 of a data field. 3376 3377 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 3378 used on an area of dimensions different than the area the coefficients were 3379 calculated for. 3380 3381 @param col: Upper-left column coordinate. I{(int)} 3382 @param row: Upper-left row coordinate. I{(int)} 3383 @param width: Area width (number of columns). I{(int)} 3384 @param height: Area height (number of rows). I{(int)} 3385 @param col_degree: Degree of polynomial to subtract column-wise (x-coordinate). I{(int)} 3386 @param row_degree: Degree of polynomial to subtract row-wise (y-coordinate). I{(int)} 3387 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+1) with coefficients, 3388 see L{DataField.area_fit_legendre}() for details. I{(const-gdouble*)} 3389 @return: 3390 """ 3391 return None

3392 - def UNIMPLEMENTED_fit_poly_max( max_degree , coeffs ):

3393 """ 3394 Fits two-dimensional polynomial with limited total degree to a data field. 3395 3396 See L{DataField.area_fit_poly_max}() for details. 3397 3398 3399 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 3400 in x^n y^m terms. I{(int)} 3401 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 3402 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 3403 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3404 with coefficients. 3405 3406 """ 3407 return None

3408 - def UNIMPLEMENTED_area_fit_poly_max( col , row , width , height , max_degree , coeffs ):

3409 """ 3410 Fits two-dimensional polynomial with limited total degree to a rectangular 3411 part of a data field. 3412 3413 See L{DataField.area_fit_legendre}() for description. This function 3414 differs by limiting the total maximum degree, while 3415 L{DataField.area_fit_legendre}() limits the maximum degrees in horizontal 3416 and vertical directions independently. 3417 3418 3419 @param col: Upper-left column coordinate. I{(int)} 3420 @param row: Upper-left row coordinate. I{(int)} 3421 @param width: Area width (number of columns). I{(int)} 3422 @param height: Area height (number of rows). I{(int)} 3423 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 3424 in x^n y^m terms. I{(int)} 3425 @param coeffs: An array of size (B{C{max_degree}}+1)*(B{C{max_degree}}+2)/2 to store the 3426 coefficients to, or B{C{NULL}} (a fresh array is allocated then). I{(gdouble*)} 3427 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3428 with coefficients. 3429 3430 """ 3431 return None

3432 - def subtract_poly_max( max_degree , coeffs ):

3433 """ 3434 Subtracts a two-dimensional polynomial with limited total degree from 3435 a data field. 3436 3437 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 3438 in x^n y^m terms. I{(int)} 3439 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 3440 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 3441 @return: 3442 """ 3443 return None

3444 - def area_subtract_poly_max( col , row , width , height , max_degree , coeffs ):

3445 """ 3446 Subtracts a two-dimensional polynomial with limited total degree from a 3447 rectangular part of a data field. 3448 3449 Due to the transform of coordinates to [-1,1] x [-1,1], this method can be 3450 used on an area of dimensions different than the area the coefficients were 3451 calculated for. 3452 3453 @param col: Upper-left column coordinate. I{(int)} 3454 @param row: Upper-left row coordinate. I{(int)} 3455 @param width: Area width (number of columns). I{(int)} 3456 @param height: Area height (number of rows). I{(int)} 3457 @param max_degree: Maximum total polynomial degree, that is the maximum of m+n 3458 in x^n y^m terms. I{(int)} 3459 @param coeffs: An array of size (B{C{row_degree}}+1)*(B{C{col_degree}}+2)/2 with 3460 coefficients, see L{DataField.area_fit_poly_max}() for details. I{(const-gdouble*)} 3461 @return: 3462 """ 3463 return None

3464 - def fit_poly( mask_field , nterms , term_powers , exclude , coeffs ):

3465 """ 3466 Fit a given set of polynomial terms to a data field. 3467 3468 Since: 2.11 3469 3470 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 3471 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 3472 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 3473 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 3474 for values inside (0.0, 1.0) is undefined (it may be specified 3475 in the future). I{(L{DataField})} 3476 @param nterms: The number of polynomial terms to take into account (half the 3477 number of items in B{C{term_powers}}). I{(int)} 3478 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 3479 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 3480 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 3481 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 3482 allocate a new array. I{(gdouble*)} 3483 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3484 with coefficients. 3485 3486 3487 """ 3488 return None

3489 - def area_fit_poly( mask_field , col , row , width , height , nterms , term_powers , exclude , coeffs ):

3490 """ 3491 Fit a given set of polynomial terms to a rectangular part of a data field. 3492 3493 The polynomial coefficients correspond to normalized coordinates that 3494 are always from the interval [-1,1] where -1 corresponds to the left/topmost 3495 pixel and 1 corresponds to the bottom/rightmost pixel of the area. 3496 3497 Since: 2.11 3498 3499 @param mask_field: Mask of values to take values into account, or B{C{NULL}} for full 3500 B{C{data_field}}. Values equal to 0.0 and below cause corresponding 3501 B{C{data_field}} samples to be ignored, values equal to 1.0 and above 3502 cause inclusion of corresponding B{C{data_field}} samples. The behaviour 3503 for values inside (0.0, 1.0) is undefined (it may be specified 3504 in the future). I{(L{DataField})} 3505 @param col: Upper-left column coordinate. I{(int)} 3506 @param row: Upper-left row coordinate. I{(int)} 3507 @param width: Area width (number of columns). I{(int)} 3508 @param height: Area height (number of rows). I{(int)} 3509 @param nterms: The number of polynomial terms to take into account (half the 3510 number of items in B{C{term_powers}}). I{(int)} 3511 @param term_powers: Array of size 2*B{C{nterms}} describing the terms to fit. Each 3512 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 3513 @param exclude: Interpret values B{C{w}} in the mask as 1.0-B{C{w}}. I{(bool)} 3514 @param coeffs: Array of size B{C{nterms}} to store the coefficients to, or B{C{NULL}} to 3515 allocate a new array. I{(gdouble*)} 3516 @return: Either B{C{coeffs}} if it was not B{C{NULL}}, or a newly allocated array 3517 with coefficients. 3518 3519 3520 """ 3521 return None

3522 - def subtract_poly( nterms , term_powers , coeffs ):

3523 """ 3524 Subtract a given set of polynomial terms from a data field. 3525 3526 Since: 2.11 3527 3528 @param nterms: The number of polynomial terms to take into account (half the 3529 number of items in B{C{term_powers}}). I{(int)} 3530 @param term_powers: Array of size 2*B{C{nterms}} describing the fitter terms. Each 3531 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 3532 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 3533 @return: 3534 """ 3535 return None

3536 - def area_subtract_poly( col , row , width , height , nterms , term_powers , coeffs ):

3537 """ 3538 Subtract a given set of polynomial terms from a rectangular part of a data 3539 field. 3540 3541 Since: 2.11 3542 3543 @param col: Upper-left column coordinate. I{(int)} 3544 @param row: Upper-left row coordinate. I{(int)} 3545 @param width: Area width (number of columns). I{(int)} 3546 @param height: Area height (number of rows). I{(int)} 3547 @param nterms: The number of polynomial terms to take into account (half the 3548 number of items in B{C{term_powers}}). I{(int)} 3549 @param term_powers: Array of size 2*B{C{nterms}} describing the fitted terms. Each 3550 terms is described by a couple of powers (powerx, powery). I{(const-gint*)} 3551 @param coeffs: Array of size B{C{nterms}} to store with the coefficients. I{(const-gdouble*)} 3552 @return: 3553 """ 3554 return None

3555 - def UNIMPLEMENTED_area_fit_local_planes( size , col , row , width , height , nresults , types , results ):

3556 """ 3557 Fits a plane through neighbourhood of each sample in a rectangular part 3558 of a data field. 3559 3560 The sample is always in the origin of its local (x,y) coordinate system, 3561 even if the neighbourhood is not centered about it (e.g. because sample 3562 is on the edge of data field). Z-coordinate is however not centered, 3563 that is B{C{PLANE_FIT_A}} is normal mean value. 3564 3565 3566 @param size: Neighbourhood size (must be at least 2). It is centered around 3567 each pixel, unless B{C{size}} is even when it sticks to the right. I{(int)} 3568 @param col: Upper-left column coordinate. I{(int)} 3569 @param row: Upper-left row coordinate. I{(int)} 3570 @param width: Area width (number of columns). I{(int)} 3571 @param height: Area height (number of rows). I{(int)} 3572 @param nresults: The number of requested quantities. I{(int)} 3573 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 3574 @param results: An array to store quantities to, may be B{C{NULL}} to allocate a new 3575 one which must be freed by caller then. If any item is B{C{NULL}}, 3576 a new data field is allocated for it, existing data fields 3577 are resized to B{C{width}} x B{C{height}}. I{(DataField**)} 3578 @return: An array of data fields with requested quantities, that is 3579 B{C{results}} unless it was B{C{NULL}} and a new array was allocated. 3580 3581 """ 3582 return None

3583 - def area_local_plane_quantity( size , col , row , width , height , type , result ):

3584 """ 3585 Convenience function to get just one quantity from 3586 L{DataField.area_fit_local_planes}(). 3587 3588 3589 @param size: Neighbourhood size. I{(int)} 3590 @param col: Upper-left column coordinate. I{(int)} 3591 @param row: Upper-left row coordinate. I{(int)} 3592 @param width: Area width (number of columns). I{(int)} 3593 @param height: Area height (number of rows). I{(int)} 3594 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 3595 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 3596 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 3597 3598 """ 3599 return None

3600 - def UNIMPLEMENTED_fit_local_planes( size , nresults , types , results ):

3601 """ 3602 Fits a plane through neighbourhood of each sample in a data field. 3603 3604 See L{DataField.area_fit_local_planes}() for details. 3605 3606 3607 @param size: Neighbourhood size. I{(int)} 3608 @param nresults: The number of requested quantities. I{(int)} 3609 @param types: The types of requested quantities. I{(const-PlaneFitQuantity*)} 3610 @param results: An array to store quantities to. I{(DataField**)} 3611 @return: An array of data fields with requested quantities. 3612 3613 """ 3614 return None

3615 - def local_plane_quantity( size , type , result ):

3616 """ 3617 Convenience function to get just one quantity from 3618 L{DataField.fit_local_planes}(). 3619 3620 3621 @param size: Neighbourhood size. I{(int)} 3622 @param type: The type of requested quantity. I{(PlaneFitQuantity)} 3623 @param result: A data field to store result to, or B{C{NULL}} to allocate a new one. I{(L{DataField})} 3624 @return: B{C{result}} if it isn't B{C{NULL}}, otherwise a newly allocated data field. 3625 3626 """ 3627 return None

3628 - def get_max( ):

3629 """ 3630 Finds the maximum value of a data field. 3631 3632 This quantity is cached. 3633 3634 3635 @return: The maximum value. 3636 3637 """ 3638 return None

3639 - def get_min( ):

3640 """ 3641 Finds the minimum value of a data field. 3642 3643 This quantity is cached. 3644 3645 3646 @return: The minimum value. 3647 3648 """ 3649 return None

3650 - def get_min_max( min , max ):

3651 """ 3652 Finds minimum and maximum values of a data field. 3653 3654 @param min: Location to store minimum to. I{(float)} 3655 @param max: Location to store maximum to. I{(float)} 3656 @return: 3657 """ 3658 return None

3659 - def get_avg( ):

3660 """ 3661 Computes average value of a data field. 3662 3663 This quantity is cached. 3664 3665 3666 @return: The average value. 3667 3668 """ 3669 return None

3670 - def get_rms( ):

3671 """ 3672 Computes root mean square value of a data field. 3673 3674 This quantity is cached. 3675 3676 3677 @return: The root mean square value. 3678 3679 """ 3680 return None

3681 - def get_sum( ):

3682 """ 3683 Sums all values in a data field. 3684 3685 This quantity is cached. 3686 3687 3688 @return: The sum of all values. 3689 3690 """ 3691 return None

3692 - def get_median( ):

3693 """ 3694 Computes median value of a data field. 3695 3696 This quantity is cached. 3697 3698 3699 @return: The median value. 3700 3701 """ 3702 return None

3703 - def get_surface_area( ):

3704 """ 3705 Computes surface area of a data field. 3706 3707 This quantity is cached. 3708 3709 3710 @return: surface area 3711 3712 """ 3713 return None

3714 - def area_get_max( mask , col , row , width , height ):

3715 """ 3716 Finds the maximum value in a rectangular part of a data field. 3717 3718 3719 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3720 @param col: Upper-left column coordinate. I{(int)} 3721 @param row: Upper-left row coordinate. I{(int)} 3722 @param width: Area width (number of columns). I{(int)} 3723 @param height: Area height (number of rows). I{(int)} 3724 @return: The maximum value. When the number of samples to calculate 3725 maximum of is zero, -B{C{G_MAXDOUBLE}} is returned. 3726 3727 """ 3728 return None

3729 - def area_get_min( mask , col , row , width , height ):

3730 """ 3731 Finds the minimum value in a rectangular part of a data field. 3732 3733 3734 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3735 @param col: Upper-left column coordinate. I{(int)} 3736 @param row: Upper-left row coordinate. I{(int)} 3737 @param width: Area width (number of columns). I{(int)} 3738 @param height: Area height (number of rows). I{(int)} 3739 @return: The minimum value. When the number of samples to calculate 3740 minimum of is zero, -B{C{G_MAXDOUBLE}} is returned. 3741 3742 """ 3743 return None

3744 - def UNIMPLEMENTED_area_get_min_max( mask , col , row , width , height , min , max ):

3745 """ 3746 Finds minimum and maximum values in a rectangular part of a data field. 3747 3748 This function is equivalent to calling 3749 B{C{L{DataField.area_get_min_max_mask}}}() 3750 with masking mode B{C{MASK_INCLUDE}}. 3751 3752 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3753 @param col: Upper-left column coordinate. I{(int)} 3754 @param row: Upper-left row coordinate. I{(int)} 3755 @param width: Area width (number of columns). I{(int)} 3756 @param height: Area height (number of rows). I{(int)} 3757 @param min: Location to store minimum to. I{(gdouble*)} 3758 @param max: Location to store maximum to. I{(gdouble*)} 3759 @return: 3760 """ 3761 return None

3762 - def UNIMPLEMENTED_area_get_min_max_mask( mask , mode , col , row , width , height , min , max ):

3763 """ 3764 Finds minimum and maximum values in a rectangular part of a data field. 3765 3766 Since: 2.18 3767 3768 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3769 @param mode: Masking mode to use. See the introduction for description of 3770 masking modes. I{(MaskingType)} 3771 @param col: Upper-left column coordinate. I{(int)} 3772 @param row: Upper-left row coordinate. I{(int)} 3773 @param width: Area width (number of columns). I{(int)} 3774 @param height: Area height (number of rows). I{(int)} 3775 @param min: Location to store minimum to. I{(gdouble*)} 3776 @param max: Location to store maximum to. I{(gdouble*)} 3777 @return: 3778 """ 3779 return None

3780 - def area_get_avg( mask , col , row , width , height ):

3781 """ 3782 Computes average value of a rectangular part of a data field. 3783 3784 This function is equivalent to calling B{C{L{DataField.area_get_avg_mask}}}() 3785 with masking mode B{C{MASK_INCLUDE}}. 3786 3787 3788 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3789 @param col: Upper-left column coordinate. I{(int)} 3790 @param row: Upper-left row coordinate. I{(int)} 3791 @param width: Area width (number of columns). I{(int)} 3792 @param height: Area height (number of rows). I{(int)} 3793 @return: The average value. 3794 3795 """ 3796 return None

3797 - def area_get_avg_mask( mask , mode , col , row , width , height ):

3798 """ 3799 Computes average value of a rectangular part of a data field. 3800 3801 Since: 2.18 3802 3803 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3804 @param mode: Masking mode to use. See the introduction for description of 3805 masking modes. I{(MaskingType)} 3806 @param col: Upper-left column coordinate. I{(int)} 3807 @param row: Upper-left row coordinate. I{(int)} 3808 @param width: Area width (number of columns). I{(int)} 3809 @param height: Area height (number of rows). I{(int)} 3810 @return: The average value. 3811 3812 3813 """ 3814 return None

3815 - def area_get_rms( mask , col , row , width , height ):

3816 """ 3817 Computes root mean square value of a rectangular part of a data field. 3818 3819 3820 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3821 @param col: Upper-left column coordinate. I{(int)} 3822 @param row: Upper-left row coordinate. I{(int)} 3823 @param width: Area width (number of columns). I{(int)} 3824 @param height: Area height (number of rows). I{(int)} 3825 @return: The root mean square value. 3826 3827 This function is equivalent to calling B{C{L{DataField.area_get_rms_mask}}}() 3828 with masking mode B{C{MASK_INCLUDE}}. 3829 3830 """ 3831 return None

3832 - def area_get_rms_mask( mask , mode , col , row , width , height ):

3833 """ 3834 Computes root mean square value of deviations of a rectangular part of a 3835 data field. 3836 3837 Since: 2.18 3838 3839 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3840 @param mode: Masking mode to use. See the introduction for description of 3841 masking modes. I{(MaskingType)} 3842 @param col: Upper-left column coordinate. I{(int)} 3843 @param row: Upper-left row coordinate. I{(int)} 3844 @param width: Area width (number of columns). I{(int)} 3845 @param height: Area height (number of rows). I{(int)} 3846 @return: The root mean square value of deviations from the mean value. 3847 3848 3849 """ 3850 return None

3851 - def area_get_sum( mask , col , row , width , height ):

3852 """ 3853 Sums values of a rectangular part of a data field. 3854 3855 This function is equivalent to calling B{C{L{DataField.area_get_sum_mask}}}() 3856 with masking mode B{C{MASK_INCLUDE}}. 3857 3858 3859 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3860 @param col: Upper-left column coordinate. I{(int)} 3861 @param row: Upper-left row coordinate. I{(int)} 3862 @param width: Area width (number of columns). I{(int)} 3863 @param height: Area height (number of rows). I{(int)} 3864 @return: The sum of all values inside area. 3865 3866 """ 3867 return None

3868 - def area_get_sum_mask( mask , mode , col , row , width , height ):

3869 """ 3870 Sums values of a rectangular part of a data field. 3871 3872 Since: 2.18 3873 3874 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3875 @param mode: Masking mode to use. See the introduction for description of 3876 masking modes. I{(MaskingType)} 3877 @param col: Upper-left column coordinate. I{(int)} 3878 @param row: Upper-left row coordinate. I{(int)} 3879 @param width: Area width (number of columns). I{(int)} 3880 @param height: Area height (number of rows). I{(int)} 3881 @return: The sum of all values inside area. 3882 3883 3884 """ 3885 return None

3886 - def area_get_median( mask , col , row , width , height ):

3887 """ 3888 Computes median value of a data field area. 3889 3890 This function is equivalent to calling 3891 B{C{L{DataField.area_get_median_mask}}}() 3892 with masking mode B{C{MASK_INCLUDE}}. 3893 3894 3895 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3896 @param col: Upper-left column coordinate. I{(int)} 3897 @param row: Upper-left row coordinate. I{(int)} 3898 @param width: Area width (number of columns). I{(int)} 3899 @param height: Area height (number of rows). I{(int)} 3900 @return: The median value. 3901 3902 """ 3903 return None

3904 - def area_get_median_mask( mask , mode , col , row , width , height ):

3905 """ 3906 Computes median value of a data field area. 3907 3908 Since: 2.18 3909 3910 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3911 @param mode: Masking mode to use. See the introduction for description of 3912 masking modes. I{(MaskingType)} 3913 @param col: Upper-left column coordinate. I{(int)} 3914 @param row: Upper-left row coordinate. I{(int)} 3915 @param width: Area width (number of columns). I{(int)} 3916 @param height: Area height (number of rows). I{(int)} 3917 @return: The median value. 3918 3919 3920 """ 3921 return None

3922 - def area_get_surface_area( mask , col , row , width , height ):

3923 return None

3924 - def area_get_surface_area_mask( mask , mode , col , row , width , height ):

3925 """ 3926 Computes surface area of a rectangular part of a data field. 3927 3928 This quantity makes sense only if the lateral dimensions and values of 3929 B{C{data_field}} are the same physical quantities. 3930 3931 Since: 2.18 3932 3933 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3934 @param mode: Masking mode to use. See the introduction for description of 3935 masking modes. I{(MaskingType)} 3936 @param col: Upper-left column coordinate. I{(int)} 3937 @param row: Upper-left row coordinate. I{(int)} 3938 @param width: Area width (number of columns). I{(int)} 3939 @param height: Area height (number of rows). I{(int)} 3940 @return: The surface area. 3941 3942 3943 """ 3944 return None

3945 - def area_get_volume( basis , mask , col , row , width , height ):

3946 """ 3947 Computes volume of a rectangular part of a data field. 3948 3949 Since: 2.3 3950 3951 @param basis: The basis or background for volume calculation if not B{C{NULL}}. 3952 The height of each vertex is then the difference between 3953 B{C{data_field}} value and B{C{basis}} value. Value B{C{NULL}} is the same 3954 as passing all zeroes for the basis. I{(L{DataField})} 3955 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 3956 @param col: Upper-left column coordinate. I{(int)} 3957 @param row: Upper-left row coordinate. I{(int)} 3958 @param width: Area width (number of columns). I{(int)} 3959 @param height: Area height (number of rows). I{(int)} 3960 @return: The volume. 3961 3962 3963 """ 3964 return None

3965 - def UNIMPLEMENTED_get_autorange( _from , to ):

3966 """ 3967 Computes value range with outliers cut-off. 3968 3969 The purpose of this function is to find a range is suitable for false color 3970 mapping. The precise method how it is calculated is unspecified and may be 3971 subject to changes. 3972 3973 However, it is guaranteed minimum <= B{C{from}} <= B{C{to}} <= maximum. 3974 3975 This quantity is cached. 3976 3977 @param _from: Location to store range start. I{(gdouble*)} 3978 @param to: Location to store range end. I{(gdouble*)} 3979 @return: 3980 """ 3981 return None

3982 - def get_stats( avg , ra , rms , skew , kurtosis ):

3983 """ 3984 Computes basic statistical quantities of a data field. 3985 3986 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 3987 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 3988 @param rms: Where root mean square value of irregularities (Rq) should be stored, 3989 or B{C{NULL}}. I{(float)} 3990 @param skew: Where skew (symmetry of height distribution) should be stored, or 3991 B{C{NULL}}. I{(float)} 3992 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 3993 stored, or B{C{NULL}}. I{(float)} 3994 @return: 3995 """ 3996 return None

3997 - def area_get_stats( mask , col , row , width , height , avg , ra , rms , skew , kurtosis ):

3998 """ 3999 Computes basic statistical quantities of a rectangular part of a data field. 4000 4001 This function is equivalent to calling B{C{L{DataField.area_get_stats_mask}}}() 4002 with masking mode B{C{MASK_INCLUDE}}. 4003 4004 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4005 @param col: Upper-left column coordinate. I{(int)} 4006 @param row: Upper-left row coordinate. I{(int)} 4007 @param width: Area width (number of columns). I{(int)} 4008 @param height: Area height (number of rows). I{(int)} 4009 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(float)} 4010 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(float)} 4011 @param rms: Where root mean square value of irregularities (Rq) should be stored, 4012 or B{C{NULL}}. I{(float)} 4013 @param skew: Where skew (symmetry of height distribution) should be stored, or 4014 B{C{NULL}}. I{(float)} 4015 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 4016 stored, or B{C{NULL}}. I{(float)} 4017 @return: 4018 """ 4019 return None

4020 - def UNIMPLEMENTED_area_get_stats_mask( mask , mode , col , row , width , height , avg , ra , rms , skew , kurtosis ):

4021 """ 4022 Computes basic statistical quantities of a rectangular part of a data field. 4023 4024 Since: 2.18 4025 4026 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4027 @param mode: Masking mode to use. See the introduction for description of 4028 masking modes. I{(MaskingType)} 4029 @param col: Upper-left column coordinate. I{(int)} 4030 @param row: Upper-left row coordinate. I{(int)} 4031 @param width: Area width (number of columns). I{(int)} 4032 @param height: Area height (number of rows). I{(int)} 4033 @param avg: Where average height value of the surface should be stored, or B{C{NULL}}. I{(gdouble*)} 4034 @param ra: Where average value of irregularities should be stored, or B{C{NULL}}. I{(gdouble*)} 4035 @param rms: Where root mean square value of irregularities (Rq) should be stored, 4036 or B{C{NULL}}. I{(gdouble*)} 4037 @param skew: Where skew (symmetry of height distribution) should be stored, or 4038 B{C{NULL}}. I{(gdouble*)} 4039 @param kurtosis: Where kurtosis (peakedness of height ditribution) should be 4040 stored, or B{C{NULL}}. I{(gdouble*)} 4041 @return: 4042 """ 4043 return None

4044 - def area_count_in_range( mask , col , row , width , height , below , above , nbelow , nabove ):

4045 """ 4046 Counts data samples in given range. 4047 4048 No assertion is made about the values of B{C{above}} and B{C{below}}, in other words 4049 B{C{above}} may be larger than B{C{below}}. To count samples in an open interval 4050 instead of a closed interval, exchange B{C{below}} and B{C{above}} and then subtract 4051 the B{C{nabove}} and B{C{nbelow}} from B{C{width}}*B{C{height}} to get the complementary counts. 4052 4053 With this trick the common task of counting positive values can be 4054 realized: 4055 <informalexample><programlisting> 4056 L{DataField.area_count_in_range}(data_field, NULL, 4057 col, row, width, height, 4058 0.0, 0.0, &count, NULL); 4059 count = width*height - count; 4060 </programlisting></informalexample> 4061 4062 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4063 @param col: Upper-left column coordinate. I{(int)} 4064 @param row: Upper-left row coordinate. I{(int)} 4065 @param width: Area width (number of columns). I{(int)} 4066 @param height: Area height (number of rows). I{(int)} 4067 @param below: Upper bound to compare data to. The number of samples less 4068 than or equal to B{C{below}} is stored in B{C{nbelow}}. I{(float)} 4069 @param above: Lower bound to compare data to. The number of samples greater 4070 than or equal to B{C{above}} is stored in B{C{nabove}}. I{(float)} 4071 @param nbelow: Location to store the number of samples less than or equal 4072 to B{C{below}}, or B{C{NULL}}. I{(int)} 4073 @param nabove: Location to store the number of samples greater than or equal 4074 to B{C{above}}, or B{C{NULL}}. I{(int)} 4075 @return: 4076 """ 4077 return None

4078 - def area_dh( mask , target_line , col , row , width , height , nstats ):

4079 """ 4080 Calculates distribution of heights in a rectangular part of data field. 4081 4082 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4083 @param target_line: A data line to store the distribution to. It will be 4084 resampled to requested width. I{(L{DataLine})} 4085 @param col: Upper-left column coordinate. I{(int)} 4086 @param row: Upper-left row coordinate. I{(int)} 4087 @param width: Area width (number of columns). I{(int)} 4088 @param height: Area height (number of rows). I{(int)} 4089 @param nstats: The number of samples to take on the distribution function. If 4090 nonpositive, a suitable resolution is determined automatically. I{(int)} 4091 @return: 4092 """ 4093 return None

4094 - def dh( target_line , nstats ):

4095 """ 4096 Calculates distribution of heights in a data field. 4097 4098 @param target_line: A data line to store the distribution to. It will be 4099 resampled to requested width. I{(L{DataLine})} 4100 @param nstats: The number of samples to take on the distribution function. If 4101 nonpositive, a suitable resolution is determined automatically. I{(int)} 4102 @return: 4103 """ 4104 return None

4105 - def area_cdh( mask , target_line , col , row , width , height , nstats ):

4106 """ 4107 Calculates uncertainty of the cumulative distribution of heights in a 4108 rectangular part of the data field. 4109 4110 Since: 2.23 4111 4112 @param mask: Mask specifying which values to take into account/exclude, or B{C{NULL}}. I{(L{DataField})} 4113 @param uncz_field: Corresponding uncertainty data field. 4114 @param target_line: A data line to store the distribution to. It will be 4115 resampled to requested width. I{(L{DataLine})} 4116 @param col: Upper-left column coordinate. I{(int)} 4117 @param row: Upper-left row coordinate. I{(int)} 4118 @param width: Area width (number of columns). I{(int)} 4119 @param height: Area height (number of rows). I{(int)} 4120 @param nstats: The number of samples to take on the distribution function. If 4121 nonpositive, a suitable resolution is determined automatically. I{(int)} 4122 @return: 4123 """ 4124 return None

4125 - def cdh( target_line , nstats ):

4126 """ 4127 Calculates cumulative distribution of heights in a data field. 4128 4129 @param target_line: A data line to store the distribution to. It will be 4130 resampled to requested width. I{(L{DataLine})} 4131 @param nstats: The number of samples to take on the distribution function. If 4132 nonpositive, a suitable resolution is determined automatically. I{(int)} 4133 @return: 4134 """ 4135 return None

4136 - def area_da( target_line , col , row , width , height , orientation , nstats ):

4137 """ 4138 Calculates distribution of slopes in a rectangular part of data field. 4139 4140 @param target_line: A data line to store the distribution to. It will be 4141 resampled to requested width. I{(L{DataLine})} 4142 @param col: Upper-left column coordinate. I{(int)} 4143 @param row: Upper-left row coordinate. I{(int)} 4144 @param width: Area width (number of columns). I{(int)} 4145 @param height: Area height (number of rows). I{(int)} 4146 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 4147 @param nstats: The number of samples to take on the distribution function. If 4148 nonpositive, a suitable resolution is determined automatically. I{(int)} 4149 @return: 4150 """ 4151 return None

4152 - def da( target_line , orientation , nstats ):

4153 """ 4154 Calculates distribution of slopes in a data field. 4155 4156 @param target_line: A data line to store the distribution to. It will be 4157 resampled to requested width. I{(L{DataLine})} 4158 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 4159 @param nstats: The number of samples to take on the distribution function. If 4160 nonpositive, a suitable resolution is determined automatically. I{(int)} 4161 @return: 4162 """ 4163 return None

4164 - def area_cda( target_line , col , row , width , height , orientation , nstats ):

4165 """ 4166 Calculates cumulative distribution of slopes in a rectangular part of data 4167 field. 4168 4169 @param target_line: A data line to store the distribution to. It will be 4170 resampled to requested width. I{(L{DataLine})} 4171 @param col: Upper-left column coordinate. I{(int)} 4172 @param row: Upper-left row coordinate. I{(int)} 4173 @param width: Area width (number of columns). I{(int)} 4174 @param height: Area height (number of rows). I{(int)} 4175 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 4176 @param nstats: The number of samples to take on the distribution function. If 4177 nonpositive, a suitable resolution is determined automatically. I{(int)} 4178 @return: 4179 """ 4180 return None

4181 - def cda( target_line , orientation , nstats ):

4182 """ 4183 Calculates cumulative distribution of slopes in a data field. 4184 4185 @param target_line: A data line to store the distribution to. It will be 4186 resampled to requested width. I{(L{DataLine})} 4187 @param orientation: Orientation to compute the slope distribution in. I{(Orientation)} 4188 @param nstats: The number of samples to take on the distribution function. If 4189 nonpositive, a suitable resolution is determined automatically. I{(int)} 4190 @return: 4191 """ 4192 return None

4193 - def area_acf( target_line , col , row , width , height , orientation , interpolation , nstats ):

4194 """ 4195 Calculates one-dimensional autocorrelation function of a rectangular part of 4196 a data field. 4197 4198 @param target_line: A data line to store the distribution to. It will be 4199 resampled to requested width. I{(L{DataLine})} 4200 @param col: Upper-left column coordinate. I{(int)} 4201 @param row: Upper-left row coordinate. I{(int)} 4202 @param width: Area width (number of columns). I{(int)} 4203 @param height: Area height (number of rows). I{(int)} 4204 @param orientation: Orientation of lines (ACF is simply averaged over the 4205 other orientation). I{(Orientation)} 4206 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4207 resampling. I{(InterpolationType)} 4208 @param nstats: The number of samples to take on the distribution function. If 4209 nonpositive, B{C{width}} (B{C{height}}) is used. I{(int)} 4210 @return: 4211 """ 4212 return None

4213 - def acf( target_line , orientation , interpolation , nstats ):

4214 """ 4215 Calculates one-dimensional autocorrelation function of a data field. 4216 4217 @param target_line: A data line to store the distribution to. It will be 4218 resampled to requested width. I{(L{DataLine})} 4219 @param orientation: Orientation of lines (ACF is simply averaged over the 4220 other orientation). I{(Orientation)} 4221 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4222 resampling. I{(InterpolationType)} 4223 @param nstats: The number of samples to take on the distribution function. If 4224 nonpositive, data field width (height) is used. I{(int)} 4225 @return: 4226 """ 4227 return None

4228 - def area_hhcf( target_line , col , row , width , height , orientation , interpolation , nstats ):

4229 """ 4230 Calculates one-dimensional autocorrelation function of a rectangular part of 4231 a data field. 4232 4233 @param target_line: A data line to store the distribution to. It will be 4234 resampled to requested width. I{(L{DataLine})} 4235 @param col: Upper-left column coordinate. I{(int)} 4236 @param row: Upper-left row coordinate. I{(int)} 4237 @param width: Area width (number of columns). I{(int)} 4238 @param height: Area height (number of rows). I{(int)} 4239 @param orientation: Orientation of lines (HHCF is simply averaged over the 4240 other orientation). I{(Orientation)} 4241 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4242 resampling. I{(InterpolationType)} 4243 @param nstats: The number of samples to take on the distribution function. If 4244 nonpositive, B{C{width}} (B{C{height}}) is used. I{(int)} 4245 @return: 4246 """ 4247 return None

4248 - def hhcf( target_line , orientation , interpolation , nstats ):

4249 """ 4250 Calculates one-dimensional autocorrelation function of a data field. 4251 4252 @param target_line: A data line to store the distribution to. It will be 4253 resampled to requested width. I{(L{DataLine})} 4254 @param orientation: Orientation of lines (HHCF is simply averaged over the 4255 other orientation). I{(Orientation)} 4256 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4257 resampling. I{(InterpolationType)} 4258 @param nstats: The number of samples to take on the distribution function. If 4259 nonpositive, data field width (height) is used. I{(int)} 4260 @return: 4261 """ 4262 return None

4263 - def area_psdf( target_line , col , row , width , height , orientation , interpolation , windowing , nstats ):

4264 """ 4265 Calculates one-dimensional power spectrum density function of a rectangular 4266 part of a data field. 4267 4268 @param target_line: A data line to store the distribution to. It will be 4269 resampled to requested width. I{(L{DataLine})} 4270 @param col: Upper-left column coordinate. I{(int)} 4271 @param row: Upper-left row coordinate. I{(int)} 4272 @param width: Area width (number of columns). I{(int)} 4273 @param height: Area height (number of rows). I{(int)} 4274 @param orientation: Orientation of lines (PSDF is simply averaged over the 4275 other orientation). I{(Orientation)} 4276 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4277 resampling. I{(InterpolationType)} 4278 @param windowing: Windowing type to use. I{(WindowingType)} 4279 @param nstats: The number of samples to take on the distribution function. If 4280 nonpositive, data field width (height) is used. I{(int)} 4281 @return: 4282 """ 4283 return None

4284 - def psdf( target_line , orientation , interpolation , windowing , nstats ):

4285 """ 4286 Calculates one-dimensional power spectrum density function of a data field. 4287 4288 @param target_line: A data line to store the distribution to. It will be 4289 resampled to requested width. I{(L{DataLine})} 4290 @param orientation: Orientation of lines (PSDF is simply averaged over the 4291 other orientation). I{(Orientation)} 4292 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4293 resampling. I{(InterpolationType)} 4294 @param windowing: Windowing type to use. I{(WindowingType)} 4295 @param nstats: The number of samples to take on the distribution function. If 4296 nonpositive, data field width (height) is used. I{(int)} 4297 @return: 4298 """ 4299 return None

4300 - def area_rpsdf( target_line , col , row , width , height , interpolation , windowing , nstats ):

4301 """ 4302 Calculates radial power spectrum density function of a rectangular 4303 part of a data field. 4304 4305 Since: 2.7 4306 4307 @param target_line: A data line to store the distribution to. It will be 4308 resampled to requested width. I{(L{DataLine})} 4309 @param col: Upper-left column coordinate. I{(int)} 4310 @param row: Upper-left row coordinate. I{(int)} 4311 @param width: Area width (number of columns). I{(int)} 4312 @param height: Area height (number of rows). I{(int)} 4313 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4314 resampling. I{(InterpolationType)} 4315 @param windowing: Windowing type to use. I{(WindowingType)} 4316 @param nstats: The number of samples to take on the distribution function. If 4317 nonpositive, data field width (height) is used. I{(int)} 4318 @return: 4319 """ 4320 return None

4321 - def rpsdf( target_line , interpolation , windowing , nstats ):

4322 """ 4323 Calculates radial power spectrum density function of a data field. 4324 4325 Since: 2.7 4326 4327 @param target_line: A data line to store the distribution to. It will be 4328 resampled to requested width. I{(L{DataLine})} 4329 @param interpolation: Interpolation to use when B{C{nstats}} is given and requires 4330 resampling. I{(InterpolationType)} 4331 @param windowing: Windowing type to use. I{(WindowingType)} 4332 @param nstats: The number of samples to take on the distribution function. If 4333 nonpositive, data field width (height) is used. I{(int)} 4334 @return: 4335 """ 4336 return None

4337 - def area_2dacf( target_field , col , row , width , height , xrange , yrange ):

4338 """ 4339 Calculates two-dimensional autocorrelation function of a data field area. 4340 4341 The resulting data field has the correlation corresponding to (0,0) in the 4342 centre. 4343 4344 The maximum possible values of B{C{xrange}} and B{C{yrange}} are B{C{data_field}} 4345 width and height, respectively. However, as the values for longer 4346 distances are calculated from smaller number of data points they become 4347 increasingly bogus, therefore the default range is half of the size. 4348 4349 Since: 2.7 4350 4351 @param target_field: A data field to store the result to. It will be resampled 4352 to (2B{C{xrange}}-1)x(2B{C{yrange}}-1). I{(L{DataField})} 4353 @param col: Upper-left column coordinate. I{(int)} 4354 @param row: Upper-left row coordinate. I{(int)} 4355 @param width: Area width (number of columns). I{(int)} 4356 @param height: Area height (number of rows). I{(int)} 4357 @param xrange: Horizontal correlation range. Non-positive value means 4358 the default range of half of B{C{data_field}} width will be used. I{(int)} 4359 @param yrange: Vertical correlation range. Non-positive value means 4360 the default range of half of B{C{data_field}} height will be used. I{(int)} 4361 @return: 4362 """ 4363 return None

4364 - def a_2dacf( target_field ):

4365 """ 4366 Calculates two-dimensional autocorrelation function of a data field. 4367 4368 See L{DataField.area_2dacf}() for details. Parameters missing (not 4369 adjustable) in this function are set to their default values. 4370 4371 Since: 2.7 4372 4373 @param target_field: A data field to store the result to. I{(L{DataField})} 4374 @return: 4375 """ 4376 return None

4377 - def area_racf( target_line , col , row , width , height , nstats ):

4378 """ 4379 Calculates radially averaged autocorrelation function of a data field. 4380 4381 Since: 2.22 4382 4383 @param target_line: A data line to store the autocorrelation function to. It 4384 will be resampled to requested width. I{(L{DataLine})} 4385 @param nstats: The number of samples to take on the autocorrelation function. If 4386 nonpositive, a suitable resolution is chosen automatically. I{(int)} 4387 @return: 4388 """ 4389 return None

4390 - def racf( target_line , nstats ):

4391 return None

4392 - def area_minkowski_volume( target_line , col , row , width , height , nstats ):

4393 """ 4394 Calculates Minkowski volume functional of a rectangular part of a data 4395 field. 4396 4397 Volume functional is calculated as the number of values above each 4398 threshold value (,white pixels`) divided by the total number of samples 4399 in the area. Is it's equivalent to 1-CDH. 4400 4401 @param target_line: A data line to store the distribution to. It will be 4402 resampled to requested width. I{(L{DataLine})} 4403 @param col: Upper-left column coordinate. I{(int)} 4404 @param row: Upper-left row coordinate. I{(int)} 4405 @param width: Area width (number of columns). I{(int)} 4406 @param height: Area height (number of rows). I{(int)} 4407 @param nstats: The number of samples to take on the distribution function. If 4408 nonpositive, a suitable resolution is determined automatically. I{(int)} 4409 @return: 4410 """ 4411 return None

4412 - def minkowski_volume( target_line , nstats ):

4413 """ 4414 Calculates Minkowski volume functional of a data field. 4415 4416 See L{DataField.area_minkowski_volume}() for details. 4417 4418 @param target_line: A data line to store the distribution to. It will be 4419 resampled to requested width. I{(L{DataLine})} 4420 @param nstats: The number of samples to take on the distribution function. If 4421 nonpositive, a suitable resolution is determined automatically. I{(int)} 4422 @return: 4423 """ 4424 return None

4425 - def area_minkowski_boundary( target_line , col , row , width , height , nstats ):

4426 """ 4427 Calculates Minkowski boundary functional of a rectangular part of a data 4428 field. 4429 4430 Boundary functional is calculated as the number of boundaries for each 4431 threshold value (the number of pixel sides where of neighouring pixels is 4432 ,white` and the other ,black`) divided by the total number of samples 4433 in the area. 4434 4435 @param target_line: A data line to store the distribution to. It will be 4436 resampled to requested width. I{(L{DataLine})} 4437 @param col: Upper-left column coordinate. I{(int)} 4438 @param row: Upper-left row coordinate. I{(int)} 4439 @param width: Area width (number of columns). I{(int)} 4440 @param height: Area height (number of rows). I{(int)} 4441 @param nstats: The number of samples to take on the distribution function. If 4442 nonpositive, a suitable resolution is determined automatically. I{(int)} 4443 @return: 4444 """ 4445 return None

4446 - def minkowski_boundary( target_line , nstats ):

4447 """ 4448 Calculates Minkowski boundary functional of a data field. 4449 4450 See L{DataField.area_minkowski_boundary}() for details. 4451 4452 @param target_line: A data line to store the distribution to. It will be 4453 resampled to requested width. I{(L{DataLine})} 4454 @param nstats: The number of samples to take on the distribution function. If 4455 nonpositive, a suitable resolution is determined automatically. I{(int)} 4456 @return: 4457 """ 4458 return None

4459 - def area_minkowski_euler( target_line , col , row , width , height , nstats ):

4460 """ 4461 Calculates Minkowski connectivity functional (Euler characteristics) of 4462 a rectangular part of a data field. 4463 4464 Connectivity functional is calculated as the number connected areas of 4465 pixels above threhsold (,white`) minus the number of connected areas of 4466 pixels below threhsold (,black`) for each threshold value, divided by the 4467 total number of samples in the area. 4468 4469 @param target_line: A data line to store the distribution to. It will be 4470 resampled to requested width. I{(L{DataLine})} 4471 @param col: Upper-left column coordinate. I{(int)} 4472 @param row: Upper-left row coordinate. I{(int)} 4473 @param width: Area width (number of columns). I{(int)} 4474 @param height: Area height (number of rows). I{(int)} 4475 @param nstats: The number of samples to take on the distribution function. If 4476 nonpositive, a suitable resolution is determined automatically. I{(int)} 4477 @return: 4478 """ 4479 return None

4480 - def minkowski_euler( target_line , nstats ):

4481 """ 4482 Calculates Minkowski connectivity functional (Euler characteristics) of 4483 a data field. 4484 4485 See L{DataField.area_minkowski_euler}() for details. 4486 4487 @param target_line: A data line to store the distribution to. It will be 4488 resampled to requested width. I{(L{DataLine})} 4489 @param nstats: The number of samples to take on the distribution function. If 4490 nonpositive, a suitable resolution is determined automatically. I{(int)} 4491 @return: 4492 """ 4493 return None

4494 - def slope_distribution( derdist , kernel_size ):

4495 """ 4496 Computes angular slope distribution. 4497 4498 @param derdist: A data line to fill with angular slope distribution. Its 4499 resolution determines resolution of the distribution. I{(L{DataLine})} 4500 @param kernel_size: If positive, local plane fitting will be used for slope 4501 computation; if nonpositive, plain central derivations 4502 will be used. I{(int)} 4503 @return: 4504 """ 4505 return None

4506 - def get_normal_coeffs( nx , ny , nz , normalize1 ):

4507 """ 4508 Computes average normal vector of a data field. 4509 4510 @param nx: Where x-component of average normal vector should be stored, or B{C{NULL}}. I{(float)} 4511 @param ny: Where y-component of average normal vector should be stored, or B{C{NULL}}. I{(float)} 4512 @param nz: Where z-component of average normal vector should be stored, or B{C{NULL}}. I{(float)} 4513 @param normalize1: true to normalize the normal vector to 1, false to normalize 4514 the vector so that z-component is 1. I{(bool)} 4515 @return: 4516 """ 4517 return None

4518 - def UNIMPLEMENTED_area_get_normal_coeffs( col , row , width , height , nx , ny , nz , normalize1 ):

4519 """ 4520 Computes average normal vector of an area of a data field. 4521 4522 @param col: Upper-left column coordinate. I{(int)} 4523 @param row: Upper-left row coordinate. I{(int)} 4524 @param width: Area width (number of columns). I{(int)} 4525 @param height: Area height (number of rows). I{(int)} 4526 @param nx: Where x-component of average normal vector should be stored, or B{C{NULL}}. I{(gdouble*)} 4527 @param ny: Where y-component of average normal vector should be stored, or B{C{NULL}}. I{(gdouble*)} 4528 @param nz: Where z-component of average normal vector should be stored, or B{C{NULL}}. I{(gdouble*)} 4529 @param normalize1: true to normalize the normal vector to 1, false to normalize 4530 the vector so that z-component is 1. I{(bool)} 4531 @return: 4532 """ 4533 return None

4534 - def area_get_inclination( col , row , width , height , theta , phi ):

4535 """ 4536 Calculates the inclination of the image (polar and azimuth angle). 4537 4538 @param col: Upper-left column coordinate. I{(int)} 4539 @param row: Upper-left row coordinate. I{(int)} 4540 @param width: Area width (number of columns). I{(int)} 4541 @param height: Area height (number of rows). I{(int)} 4542 @param theta: Where theta angle (in radians) should be stored, or B{C{NULL}}. I{(float)} 4543 @param phi: Where phi angle (in radians) should be stored, or B{C{NULL}}. I{(float)} 4544 @return: 4545 """ 4546 return None

4547 - def UNIMPLEMENTED_get_inclination( theta , phi ):

4548 """ 4549 Calculates the inclination of the image (polar and azimuth angle). 4550 4551 @param theta: Where theta angle (in radians) should be stored, or B{C{NULL}}. I{(gdouble*)} 4552 @param phi: Where phi angle (in radians) should be stored, or B{C{NULL}}. I{(gdouble*)} 4553 @return: 4554 """ 4555 return None

4556 - def area_get_line_stats( mask , target_line , col , row , width , height , quantity , orientation ):

4557 """ 4558 Calculates a line quantity for each row or column in a data field area. 4559 4560 Since: 2.2 4561 4562 @param mask: Mask of values to take values into account, or B{C{NULL}} for full 4563 B{C{data_field}}. Masking is currently unimplemented. I{(L{DataField})} 4564 @param target_line: A data line to store the distribution to. It will be 4565 resampled to the number of rows (columns). I{(L{DataLine})} 4566 @param col: Upper-left column coordinate. I{(int)} 4567 @param row: Upper-left row coordinate. I{(int)} 4568 @param width: Area width (number of columns). I{(int)} 4569 @param height: Area height (number of rows). I{(int)} 4570 @param quantity: The line quantity to calulate for each row (column). I{(LineStatQuantity)} 4571 @param orientation: Line orientation. For B{C{ORIENTATION_HORIZONTAL}} each 4572 B{C{target_line}} point corresponds to a row of the area, 4573 for B{C{ORIENTATION_VERTICAL}} each B{C{target_line}} point 4574 corresponds to a column of the area. I{(Orientation)} 4575 @return: 4576 """ 4577 return None

4578 - def get_line_stats( target_line , quantity , orientation ):

4579 """ 4580 Calculates a line quantity for each row or column of a data field. 4581 4582 Since: 2.2 4583 4584 @param target_line: A data line to store the distribution to. It will be 4585 resampled to B{C{data_field}} height (width). I{(L{DataLine})} 4586 @param quantity: The line quantity to calulate for each row (column). I{(LineStatQuantity)} 4587 @param orientation: Line orientation. See L{DataField.area_get_line_stats}(). I{(Orientation)} 4588 @return: 4589 """ 4590 return None

4591 - def get_profile( scol , srow , ecol , erow , res , thickness , interpolation ):

4592 """ 4593 Extracts a possibly averaged profile from data field to a data line. 4594 4595 4596 @param scol: The column the line starts at (inclusive). I{(int)} 4597 @param srow: The row the line starts at (inclusive). I{(int)} 4598 @param ecol: The column the line ends at (inclusive). I{(int)} 4599 @param erow: The row the line ends at (inclusive). I{(int)} 4600 @param res: Requested resolution of data line (the number of samples to take). 4601 If nonpositive, data line resolution is chosen to match B{C{data_field}}'s. I{(int)} 4602 @param thickness: Thickness of line to be averaged. I{(int)} 4603 @param interpolation: Interpolation type to use. I{(InterpolationType)} 4604 @return: B{C{data_line}} itself if it was not B{C{NULL}}, otherwise a newly created 4605 data line. 4606 4607 """ 4608 return None

4609 - def fit_polynom( col_degree , row_degree ):

4610 """ 4611 Fits a two-dimensional polynomial to a data field. 4612 4613 4614 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4615 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4616 @return: a newly allocated array with coefficients. 4617 4618 """ 4619 return None

4620 - def area_fit_polynom( col , row , width , height , col_degree , row_degree ):

4621 """ 4622 Fits a two-dimensional polynomial to a rectangular part of a data field. 4623 4624 The coefficients are stored by row into B{C{coeffs}}, like data in a datafield. 4625 Row index is y-degree, column index is x-degree. 4626 4627 Note naive x^n y^m polynomial fitting is numerically unstable, therefore 4628 this method works only up to B{C{col_degree}} = B{C{row_degree}} = 6. 4629 4630 4631 @param col: Upper-left column coordinate. I{(int)} 4632 @param row: Upper-left row coordinate. I{(int)} 4633 @param width: Area width (number of columns). I{(int)} 4634 @param height: Area height (number of rows). I{(int)} 4635 @param col_degree: Degree of polynomial to fit column-wise (x-coordinate). I{(int)} 4636 @param row_degree: Degree of polynomial to fit row-wise (y-coordinate). I{(int)} 4637 @return: a newly allocated array with coefficients. 4638 4639 4640 """ 4641 return None

4642 - def elliptic_area_extract( col , row , width , height ):

4643 """ 4644 Extracts values from an elliptic region of a data field. 4645 4646 The elliptic region is defined by its bounding box which must be completely 4647 contained in the data field. 4648 4649 4650 @param col: Upper-left bounding box column coordinate. I{(int)} 4651 @param row: Upper-left bounding box row coordinate. I{(int)} 4652 @param width: Bounding box width (number of columns). I{(int)} 4653 @param height: Bounding box height (number of rows). I{(int)} 4654 @return: The number of extracted values. 4655 4656 """ 4657 return None

4658 - def circular_area_extract( col , row , radius ):

4659 """ 4660 Extracts values from a circular region of a data field. 4661 4662 4663 @param col: Row index of circular area centre. I{(int)} 4664 @param row: Column index of circular area centre. I{(int)} 4665 @param radius: Circular area radius (in pixels). See 4666 L{DataField.circular_area_extract_with_pos}() for caveats. I{(float)} 4667 @return: Array of values. 4668 4669 """ 4670 return None

4671 - def create_full_mask( ):

4672 return None

4673 - def UNIMPLEMENTED_mark_scars( data_field , scar_field , threshold_high , threshold_low , min_scar_len , max_scar_width , negative ):

4674 return None

4675 - def duplicate( ):

4676 """ 4677 Duplicate datafield 4678 4679 4680 @return: duplicated datafield 4681 4682 """ 4683 return None

4684 - def get_data( ):

4685 """ 4686 Create a tuple of data which the datafield contains. Content of the tuple is NOT reference to original datafield but its copy. 4687 4688 4689 @return: tuple of raw numeric data from DataField 4690 4691 """ 4692 return None

4693 - def UNIMPLEMENTED_normalize_rows( dfield ):

4694 return None

4695 - def get_data_pointer( ):

4696 """ 4697 Get Pointer to data which the datafield contains. 4698 4699 4700 @return: integer pointing to the raw data of the datafield 4701 4702 """ 4703 return None

4704 -class DataLine:

4705 - def __init__( res , real , nullme ):

4706 """ 4707 Creates a new data line. 4708 4709 4710 @param real: Real physical dimension. I{(float)} 4711 @param nullme: Whether the data line should be initialized to zeroes. If B{C{False}}, 4712 the data will not be initialized. I{(bool)} 4713 @return: A newly created data line. 4714 4715 """ 4716 return None

4717 - def check_compatibility( data_line2 , check ):

4718 """ 4719 Checks whether two data lines are compatible. 4720 4721 4722 @param data_line2: Another data line. I{(L{DataLine})} 4723 @param check: The compatibility tests to perform. I{(DataCompatibilityFlags)} 4724 @return: Zero if all tested properties are compatible. Flags corresponding 4725 to failed tests if data lines are not compatible. 4726 4727 """ 4728 return None

4729 - def copy_units_to_data_field( data_field ):

4730 """ 4731 Sets lateral and value units of a data field to match a data line. 4732 4733 @param data_field: A data field to set units of. I{(L{DataField})} 4734 @return: 4735 """ 4736 return None

4737 - def new_alike( nullme ):

4738 """ 4739 Creates a new data line similar to an existing one. 4740 4741 Use L{DataLine.duplicate}() if you want to copy a data line including 4742 data. 4743 4744 4745 @param nullme: Whether the data line should be initialized to zeroes. If B{C{False}}, 4746 the data will not be initialized. I{(bool)} 4747 @return: A newly created data line. 4748 4749 """ 4750 return None

4751 - def data_changed( ):

4752 """ 4753 Emits signal "data_changed" on a data line. 4754 4755 @return: 4756 """ 4757 return None

4758 - def new_resampled( res , interpolation ):

4759 """ 4760 Creates a new data line by resampling an existing one. 4761 4762 This method is equivalent to L{DataLine.duplicate}() followed by 4763 L{DataLine.resample}(), but it is more efficient. 4764 4765 Since: 2.1 4766 4767 @param res: Desired resolution. I{(int)} 4768 @param interpolation: Interpolation method to use. I{(InterpolationType)} 4769 @return: A newly created data line. 4770 4771 4772 """ 4773 return None

4774 - def resample( res , interpolation ):

4775 """ 4776 Resamples a data line. 4777 4778 In other words changes the size of one dimensional field related with data 4779 line. The original values are used for resampling using a requested 4780 interpolation alorithm. 4781 4782 @param res: Desired resolution. I{(int)} 4783 @param interpolation: Interpolation method to use. I{(InterpolationType)} 4784 @return: 4785 """ 4786 return None

4787 - def resize( _from , to ):

4788 """ 4789 Resizes (crops) a data line. 4790 4791 Extracts a part of data line in range B{C{from}}..(B{C{to}}-1), recomputing real 4792 sizes. 4793 4794 @param _from: Where to start. I{(int)} 4795 @param to: Where to finish + 1. I{(int)} 4796 @return: 4797 """ 4798 return None

4799 - def part_extract( _from , len ):

4800 """ 4801 Extracts a part of a data line to a new data line. 4802 4803 4804 @param _from: Where to start. I{(int)} 4805 @param len: Length of extracted segment. I{(int)} 4806 @return: The extracted area as a newly created data line. 4807 4808 """ 4809 return None

4810 - def copy( b ):

4811 """ 4812 Copies the contents of a data line to another already allocated data line 4813 of the same size. 4814 4815 <warning>Semantic of method differs from L{DataField.copy}(), it copies 4816 only data. It will be probably changed.</warning> 4817 4818 @param b: Destination data line. I{(L{DataLine})} 4819 @return: 4820 """ 4821 return None

4822 - def get_data( ):

4823 """ 4824 Gets the raw data buffer of a data line. 4825 4826 The returned buffer is not guaranteed to be valid through whole data 4827 line life time. Some function may change it, most notably 4828 L{DataLine.resize}() and L{DataLine.resample}(). 4829 4830 This function invalidates any cached information, use 4831 L{DataLine.get_data_const}() if you are not going to change the data. 4832 4833 4834 @return: The data as an array of doubles of length L{DataLine.get_res}(). 4835 4836 """ 4837 return None

4838 - def get_res( ):

4839 """ 4840 Gets the number of data points in a data line. 4841 4842 4843 @return: Resolution (number of data points). 4844 4845 """ 4846 return None

4847 - def get_real( ):

4848 """ 4849 Gets the physical size of a data line. 4850 4851 4852 @return: Real size of data line. 4853 4854 """ 4855 return None

4856 - def set_real( real ):

4857 """ 4858 Sets the real data line size. 4859 4860 @param real: value to be set I{(float)} 4861 @return: 4862 """ 4863 return None

4864 - def get_offset( ):

4865 """ 4866 Gets the offset of data line origin. 4867 4868 4869 @return: Offset value. 4870 4871 """ 4872 return None

4873 - def set_offset( offset ):

4874 """ 4875 Sets the offset of a data line origin. 4876 4877 Note offsets don't affect any calculation, nor functions like 4878 L{DataLine.rtoi}(). 4879 4880 @param offset: New offset value. I{(float)} 4881 @return: 4882 """ 4883 return None

4884 - def get_si_unit_x( ):

4885 """ 4886 Returns lateral SI unit of a data line. 4887 4888 4889 @return: SI unit corresponding to the lateral (X) dimension of the data 4890 line. Its reference count is not incremented. 4891 4892 """ 4893 return None

4894 - def get_si_unit_y( ):

4895 """ 4896 Returns value SI unit of a data line. 4897 4898 4899 @return: SI unit corresponding to the "height" (Z) dimension of the data 4900 line. Its reference count is not incremented. 4901 4902 """ 4903 return None

4904 - def set_si_unit_x( si_unit ):

4905 """ 4906 Sets the SI unit corresponding to the lateral (X) dimension of a data 4907 line. 4908 4909 It does not assume a reference on B{C{si_unit}}, instead it adds its own 4910 reference. 4911 4912 @param si_unit: SI unit to be set. I{(L{SIUnit})} 4913 @return: 4914 """ 4915 return None

4916 - def set_si_unit_y( si_unit ):

4917 """ 4918 Sets the SI unit corresponding to the "height" (Z) dimension of a data 4919 line. 4920 4921 It does not assume a reference on B{C{si_unit}}, instead it adds its own 4922 reference. 4923 4924 @param si_unit: SI unit to be set. I{(L{SIUnit})} 4925 @return: 4926 """ 4927 return None

4928 - def UNIMPLEMENTED_get_value_format_x( style , format ):

4929 """ 4930 Finds value format good for displaying coordinates of a data line. 4931 4932 4933 @param style: Unit format style. I{(SIUnitFormatStyle)} 4934 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 4935 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 4936 is returned, otherwise (modified) B{C{format}} itself is returned. 4937 4938 """ 4939 return None

4940 - def UNIMPLEMENTED_get_value_format_y( style , format ):

4941 """ 4942 Finds value format good for displaying values of a data line. 4943 4944 Note this functions searches for minimum and maximum value in B{C{data_line}}, 4945 therefore it's relatively slow. 4946 4947 4948 @param style: Unit format style. I{(SIUnitFormatStyle)} 4949 @param format: A SI value format to modify, or B{C{NULL}} to allocate a new one. I{(SIValueFormat*)} 4950 @return: The value format. If B{C{format}} is B{C{NULL}}, a newly allocated format 4951 is returned, otherwise (modified) B{C{format}} itself is returned. 4952 4953 """ 4954 return None

4955 - def itor( pixpos ):

4956 """ 4957 Transforms pixel coordinate to real (physical) coordinate. 4958 4959 That is it maps range [0..resolution] to range [0..real-size]. It is not 4960 suitable for conversion of matrix indices to physical coordinates, you 4961 have to use L{DataLine.itor}(B{C{data_line}}, B{C{pixpos}} + 0.5) for that. 4962 4963 4964 @param pixpos: Pixel coordinate. I{(float)} 4965 @return: B{C{pixpos}} in real coordinates. 4966 4967 """ 4968 return None

4969 - def rtoi( realpos ):

4970 """ 4971 Transforms real (physical) coordinate to pixel coordinate. 4972 4973 That is it maps range [0..real-size] to range [0..resolution]. 4974 4975 4976 @param realpos: Real coordinate. I{(float)} 4977 @return: B{C{realpos}} in pixel coordinates. 4978 4979 """ 4980 return None

4981 - def get_val( i ):

4982 """ 4983 Gets value at given position in a data line. 4984 4985 Do not access data with this function inside inner loops, it's slow. 4986 Get raw data buffer with L{DataLine.get_data_const}() and access it 4987 directly instead. 4988 4989 4990 @param i: Position in the line (index). I{(int)} 4991 @return: Value at given index. 4992 4993 """ 4994 return None

4995 - def set_val( i , value ):

4996 """ 4997 Sets the value at given position in a data line. 4998 4999 Do not set data with this function inside inner loops, it's slow. Get raw 5000 data buffer with L{DataLine.get_data}() and write to it directly instead. 5001 5002 @param i: Position in the line (index). I{(int)} 5003 @param value: Value to set. I{(float)} 5004 @return: 5005 """ 5006 return None

5007 - def get_dval( x , interpolation ):

5008 """ 5009 Gets interpolated value at arbitrary data line point indexed by pixel 5010 coordinates. 5011 5012 Note pixel values are centered in intervals [B{C{j}}, B{C{j}}+1], so to get the same 5013 value as L{DataLine.get_val}(B{C{data_line}}, B{C{j}}) returns, 5014 it's necessary to add 0.5: 5015 L{DataLine.get_dval}(B{C{data_line}}, B{C{j}}+0.5, B{C{interpolation}}). 5016 5017 See also L{DataLine.get_dval_real}() that does the same, but takes 5018 real coordinates. 5019 5020 5021 @param x: Position in data line in range [0, resolution]. If the value is outside 5022 this range, the nearest border value is returned. I{(float)} 5023 @param interpolation: Interpolation method to use. I{(int)} 5024 @return: Value interpolated in the data line. 5025 5026 """ 5027 return None

5028 - def get_dval_real( x , interpolation ):

5029 """ 5030 Gets interpolated value at arbitrary data line point indexed by real 5031 coordinates. 5032 5033 See also L{DataLine.get_dval}() for interpolation explanation. 5034 5035 5036 @param x: real coordinates position I{(float)} 5037 @param interpolation: interpolation method used I{(int)} 5038 @return: Value interpolated in the data line. 5039 5040 """ 5041 return None

5042 - def invert( x , z ):

5043 """ 5044 Reflects amd/or inverts a data line. 5045 5046 In the case of value reflection, it's inverted about mean value. 5047 5048 @param x: Whether to invert data point order. I{(bool)} 5049 @param z: Whether to invert in Z direction (i.e., invert values). I{(bool)} 5050 @return: 5051 """ 5052 return None

5053 - def clear( ):

5054 """ 5055 Fills a data line with zeroes. 5056 5057 @return: 5058 """ 5059 return None

5060 - def fill( value ):

5061 """ 5062 Fills a data line with specified value. 5063 5064 @param value: Value to fill data line with. I{(float)} 5065 @return: 5066 """ 5067 return None

5068 - def multiply( value ):

5069 """ 5070 Multiplies all values in a data line with a specified value. 5071 5072 @param value: Value to multiply data line with. I{(float)} 5073 @return: 5074 """ 5075 return None

5076 - def add( value ):

5077 """ 5078 Adds a specified value to all values in a data line. 5079 5080 @param value: Value to be added. I{(float)} 5081 @return: 5082 """ 5083 return None

5084 - def part_clear( _from , to ):

5085 """ 5086 Fills a data line part with zeroes. 5087 5088 @param _from: Index the line part starts at. I{(int)} 5089 @param to: Index the line part ends at + 1. I{(int)} 5090 @return: 5091 """ 5092 return None

5093 - def part_fill( _from , to , value ):

5094 """ 5095 Fills specified part of data line with specified number 5096 5097 @param _from: Index the line part starts at. I{(int)} 5098 @param to: Index the line part ends at + 1. I{(int)} 5099 @param value: Value to fill data line part with. I{(float)} 5100 @return: 5101 """ 5102 return None

5103 - def part_multiply( _from , to , value ):

5104 """ 5105 Multiplies all values in a part of data line by specified value. 5106 5107 @param _from: Index the line part starts at. I{(int)} 5108 @param to: Index the line part ends at + 1. I{(int)} 5109 @param value: Value multiply data line part with. I{(float)} 5110 @return: 5111 """ 5112 return None

5113 - def part_add( _from , to , value ):

5114 """ 5115 Adds specified value to all values in a part of a data line. 5116 5117 @param _from: Index the line part starts at. I{(int)} 5118 @param to: Index the line part ends at + 1. I{(int)} 5119 @param value: Value to be added I{(float)} 5120 @return: 5121 """ 5122 return None

5123 - def threshold( threshval , bottom , top ):

5124 """ 5125 Sets all the values to B{C{bottom}} or B{C{top}} value 5126 depending on whether the original values are 5127 below or above B{C{threshold}} value 5128 5129 5130 @param threshval: Threshold value. I{(float)} 5131 @param bottom: Lower replacement value. I{(float)} 5132 @param top: Upper replacement value. I{(float)} 5133 @return: total number of values above threshold 5134 5135 """ 5136 return None

5137 - def part_threshold( _from , to , threshval , bottom , top ):

5138 """ 5139 Sets all the values within interval to B{C{bottom}} or B{C{top}} value 5140 depending on whether the original values are 5141 below or above B{C{threshold}} value. 5142 5143 5144 @param _from: Index the line part starts at. I{(int)} 5145 @param to: Index the line part ends at + 1. I{(int)} 5146 @param threshval: Threshold value. I{(float)} 5147 @param bottom: Lower replacement value. I{(float)} 5148 @param top: Upper replacement value. I{(float)} 5149 @return: total number of values above threshold within interval 5150 5151 """ 5152 return None

5153 - def UNIMPLEMENTED_get_line_coeffs( av , bv ):

5154 """ 5155 Finds line leveling coefficients. 5156 5157 The coefficients can be used for line leveling using relation 5158 data[i] := data[i] - (av + bv*i); 5159 5160 @param av: Height coefficient. I{(gdouble*)} 5161 @param bv: Slope coeficient. I{(gdouble*)} 5162 @return: 5163 """ 5164 return None

5165 - def line_level( av , bv ):

5166 """ 5167 Performs line leveling. 5168 5169 See L{DataLine.get_line_coeffs}() for deails. 5170 5171 @param av: Height coefficient. I{(float)} 5172 @param bv: Slope coefficient. I{(float)} 5173 @return: 5174 """ 5175 return None

5176 - def rotate( angle , interpolation ):

5177 """ 5178 Performs line rotation. 5179 5180 This is operation similar to leveling, but it does not change the angles 5181 between line segments (on the other hand it introduces other deformations 5182 due to discretization). 5183 5184 Since: 2.7 5185 5186 @param angle: Angle of rotation (in radians), counterclockwise. I{(float)} 5187 @param interpolation: Interpolation method to use (can be only of two-point type). I{(InterpolationType)} 5188 @return: 5189 """ 5190 return None

5191 - def line_rotate( angle , interpolation ):

5192 """ 5193 Performs line rotation. 5194 5195 Use L{DataLine.rotate}() instead. 5196 5197 @param angle: Angle of rotation (in radians), counterclockwise. I{(float)} 5198 @param interpolation: Interpolation method to use (can be only of two-point type). I{(int)} 5199 @return: 5200 """ 5201 return None

5202 - def get_der( i ):

5203 """ 5204 Computes central derivaltion at given index in a data line. 5205 5206 5207 @param i: Pixel coordinate. I{(int)} 5208 @return: Derivation at given position. 5209 5210 """ 5211 return None

5212 - def UNIMPLEMENTED_part_fit_polynom( n , coeffs , _from , to ):

5213 """ 5214 Fits a polynomial through a part of a data line. 5215 5216 Please see L{DataLine.fit_polynom}() for more details. 5217 5218 5219 @param n: Polynom degree. I{(int)} 5220 @param coeffs: An array of size B{C{n}}+1 to store the coefficients to, or B{C{NULL}} 5221 (a fresh array is allocated then). I{(gdouble*)} 5222 @param _from: Index the line part starts at. I{(int)} 5223 @param to: Index the line part ends at + 1. I{(int)} 5224 @return: The coefficients of the polynomial (B{C{coeffs}} when it was not B{C{NULL}}, 5225 otherwise a newly allocated array). 5226 5227 """ 5228 return None

5229 - def UNIMPLEMENTED_fit_polynom( n , coeffs ):

5230 """ 5231 Fits a polynomial through a data line. 5232 5233 Note B{C{n}} is polynomial degree, so the size of B{C{coeffs}} is B{C{n}}+1. X-values 5234 are indices in the data line. 5235 5236 For polynomials of degree 0 and 1 it's better to use L{DataLine.get_avg}() 5237 and L{DataLine.line_coeffs}() because they are faster. 5238 5239 5240 @param n: Polynom degree. I{(int)} 5241 @param coeffs: An array of size B{C{n}}+1 to store the coefficients to, or B{C{NULL}} 5242 (a fresh array is allocated then). I{(gdouble*)} 5243 @return: The coefficients of the polynomial (B{C{coeffs}} when it was not B{C{NULL}}, 5244 otherwise a newly allocated array). 5245 5246 """ 5247 return None

5248 - def part_subtract_polynom( n , coeffs , _from , to ):

5249 """ 5250 Subtracts a polynomial from a part of a data line. 5251 5252 @param n: Polynom degree. I{(int)} 5253 @param coeffs: An array of size B{C{n}}+1 with polynomial coefficients to. I{(const-gdouble*)} 5254 @param _from: Index the line part starts at. I{(int)} 5255 @param to: Index the line part ends at + 1. I{(int)} 5256 @return: 5257 """ 5258 return None

5259 - def subtract_polynom( n , coeffs ):

5260 """ 5261 Subtracts a polynomial from a data line. 5262 5263 @param n: Polynom degree. I{(int)} 5264 @param coeffs: An array of size B{C{n}}+1 with polynomial coefficients to. I{(const-gdouble*)} 5265 @return: 5266 """ 5267 return None

5268 - def cumulate( ):

5269 """ 5270 Transforms a distribution in a data line to cummulative distribution. 5271 5272 Each element becomes sum of all previous elements in the line, including 5273 self. 5274 5275 @return: 5276 """ 5277 return None

5278 - def sqrt( ):

5279 """ 5280 Applies sqrt() to each element in a data line. 5281 5282 @return: 5283 """ 5284 return None

5285 - def dwt( wt_coefs , direction , minsize ):

5286 """ 5287 Performs steps of the wavelet decomposition. 5288 5289 The smallest low pass coefficients block is equal to B{C{minsize}}. Run with 5290 B{C{minsize}} = B{C{dline}}->res/2 to perform one step of decomposition 5291 or B{C{minsize}} = 4 to perform full decomposition (or anything between). 5292 5293 5294 @param wt_coefs: Data line where the wavelet transform coefficients are stored. I{(L{DataLine})} 5295 @param direction: Transform direction. I{(TransformDirection)} 5296 @param minsize: size of minimal transform result block I{(int)} 5297 @return: 5298 """ 5299 return None

5300 - def fft( isrc , rdest , idest , windowing , direction , interpolation , preserverms , level ):

5301 """ 5302 Calculates Fast Fourier Transform of a data line. 5303 5304 A windowing or data leveling can be applied if requested. 5305 5306 @param isrc: Imaginary input data line. I{(L{DataLine})} 5307 @param rdest: Real output data line. It will be resized to the size of the input 5308 data line. I{(L{DataLine})} 5309 @param idest: Imaginary output data line. It will be resized to the size of the 5310 input data line. I{(L{DataLine})} 5311 @param windowing: Windowing mode. I{(WindowingType)} 5312 @param direction: FFT direction. I{(TransformDirection)} 5313 @param interpolation: Interpolation type. 5314 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 5315 @param preserverms: B{C{True}} to preserve RMS value while windowing. I{(bool)} 5316 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 5317 line (the number can be interpreted as the first polynomial degree 5318 to keep, but only the enumerated three values are available). I{(int)} 5319 @return: 5320 """ 5321 return None

5322 - def part_fft( isrc , rdest , idest , _from , len , windowing , direction , interpolation , preserverms , level ):

5323 """ 5324 Calculates Fast Fourier Transform of a part of a data line. 5325 5326 A windowing or data leveling can be applied if requested. 5327 5328 @param isrc: Imaginary input data line. Since 2.7 it can be B{C{NULL}} for 5329 real-to-complex transforms. I{(L{DataLine})} 5330 @param rdest: Real output data line, it will be resized to B{C{len}}. I{(L{DataLine})} 5331 @param idest: Imaginary output data line, it will be resized to B{C{len}}. I{(L{DataLine})} 5332 @param _from: The index in input lines to start from (inclusive). I{(int)} 5333 @param len: Lenght of data line part, it must be at least 2. I{(int)} 5334 @param windowing: Windowing mode. I{(WindowingType)} 5335 @param direction: FFT direction. I{(TransformDirection)} 5336 @param interpolation: Interpolation type. 5337 Ignored since 2.8 as no resampling is performed. I{(InterpolationType)} 5338 @param preserverms: B{C{True}} to preserve RMS value while windowing. I{(bool)} 5339 @param level: 0 to perform no leveling, 1 to subtract mean value, 2 to subtract 5340 line (the number can be interpreted as the first polynomial degree 5341 to keep, but only the enumerated three values are available). I{(int)} 5342 @return: 5343 """ 5344 return None

5345 - def fft_raw( isrc , rdest , idest , direction ):

5346 """ 5347 Calculates Fast Fourier Transform of a data line. 5348 5349 No leveling, windowing nor scaling is performed. 5350 5351 Since 2.8 the dimensions need not to be from the set of sizes returned 5352 by L{gwy_fft_find_nice_size}(). 5353 5354 Since: 2.1 5355 5356 @param isrc: Imaginary input data line. Since 2.7 it can be B{C{NULL}} for 5357 real-to-complex transform. I{(L{DataLine})} 5358 @param rdest: Real output data line. It will be resized to the size of the input 5359 data line. I{(L{DataLine})} 5360 @param idest: Imaginary output data line. It will be resized to the size of the 5361 input data line. I{(L{DataLine})} 5362 @param direction: FFT direction. I{(TransformDirection)} 5363 @return: 5364 """ 5365 return None

5366 - def get_max( ):

5367 """ 5368 Finds the maximum value of a data line. 5369 5370 5371 @return: The maximum value. 5372 5373 """ 5374 return None

5375 - def get_min( ):

5376 """ 5377 Finds the minimum value of a data line. 5378 5379 5380 @return: The minimum value. 5381 5382 """ 5383 return None

5384 - def get_avg( ):

5385 """ 5386 Computes average value of a data line. 5387 5388 5389 @return: Average value 5390 5391 """ 5392 return None

5393 - def get_rms( ):

5394 """ 5395 Computes root mean square value of a data line. 5396 5397 5398 @return: Root mean square deviation of values. 5399 5400 """ 5401 return None

5402 - def get_tan_beta0( ):

5403 """ 5404 Computes root mean square slope in a data line. 5405 5406 Since: 2.2 5407 5408 @return: Root mean square slope within a given interval. 5409 5410 5411 """ 5412 return None

5413 - def get_sum( ):

5414 """ 5415 Computes sum of all values in a data line. 5416 5417 5418 @return: sum of all the values. 5419 5420 """ 5421 return None

5422 - def part_get_max( _from , to ):

5423 """ 5424 Finds the maximum value of a part of a data line. 5425 5426 5427 @param _from: Index the line part starts at. I{(int)} 5428 @param to: Index the line part ends at + 1. I{(int)} 5429 @return: Maximum within given interval. 5430 5431 """ 5432 return None

5433 - def part_get_min( _from , to ):

5434 """ 5435 Finds the minimum value of a part of a data line. 5436 5437 5438 @param _from: Index the line part starts at. I{(int)} 5439 @param to: Index the line part ends at + 1. I{(int)} 5440 @return: Minimum within given interval. 5441 5442 """ 5443 return None

5444 - def part_get_avg( _from , to ):

5445 """ 5446 Computes mean value of all values in a part of a data line. 5447 5448 5449 @param _from: Index the line part starts at. I{(int)} 5450 @param to: Index the line part ends at + 1. I{(int)} 5451 @return: Average value within given interval. 5452 5453 """ 5454 return None

5455 - def part_get_rms( _from , to ):

5456 """ 5457 Computes root mean square value of a part of a data line. 5458 5459 5460 @param _from: Index the line part starts at. I{(int)} 5461 @param to: Index the line part ends at + 1. I{(int)} 5462 @return: Root mean square deviation of heights within a given interval 5463 5464 """ 5465 return None

5466 - def part_get_tan_beta0( _from , to ):

5467 """ 5468 Computes root mean square slope in a part of a data line. 5469 5470 This is the root mean square of value derivatives, it is also proportional 5471 to the second derivative of both HHCF and ACF at zero. 5472 5473 Since: 2.2 5474 5475 @param _from: Index the line part starts at. I{(int)} 5476 @param to: Index the line part ends at + 1. I{(int)} 5477 @return: Root mean square slope within a given interval. 5478 5479 5480 """ 5481 return None

5482 - def part_get_sum( _from , to ):

5483 """ 5484 Computes sum of all values in a part of a data line. 5485 5486 5487 @param _from: Index the line part starts at. I{(int)} 5488 @param to: Index the line part ends at + 1. I{(int)} 5489 @return: Sum of all values within the interval. 5490 5491 """ 5492 return None

5493 - def get_modus( histogram_steps ):

5494 """ 5495 Finds approximate modus of a data line. 5496 5497 See L{DataLine.part_get_modus}() for details and caveats. 5498 5499 5500 @param histogram_steps: Number of histogram steps used for modus searching, 5501 pass a nonpositive number to autosize. I{(int)} 5502 @return: The modus. 5503 5504 """ 5505 return None

5506 - def part_get_modus( _from , to , histogram_steps ):

5507 """ 5508 Finds approximate modus of a data line part. 5509 5510 As each number in the data line is usually unique, this function does not 5511 return modus of the data itself, but modus of a histogram. 5512 5513 5514 @param _from: The index in B{C{data_line}} to start from (inclusive). I{(int)} 5515 @param to: The index in B{C{data_line}} to stop (noninclusive). I{(int)} 5516 @param histogram_steps: Number of histogram steps used for modus searching, 5517 pass a nonpositive number to autosize. I{(int)} 5518 @return: The modus. 5519 5520 """ 5521 return None

5522 - def get_median( ):

5523 """ 5524 Finds median of a data line. 5525 5526 Since: 2.1 5527 5528 @return: The median. 5529 5530 5531 """ 5532 return None

5533 - def part_get_median( _from , to ):

5534 """ 5535 Finds median of a data line part. 5536 5537 Since: 2.1 5538 5539 @param _from: The index in B{C{data_line}} to start from (inclusive). I{(int)} 5540 @param to: The index in B{C{data_line}} to stop (noninclusive). I{(int)} 5541 @return: The median. 5542 5543 5544 """ 5545 return None

5546 - def get_length( ):

5547 """ 5548 Calculates physical length of a data line. 5549 5550 The length is calculated from approximation by straight segments between 5551 values. 5552 5553 5554 @return: The line length. 5555 5556 """ 5557 return None

5558 - def distribution( distribution , ymin , ymax , normalize_to_unity , nstats ):

5559 """ 5560 Calculates the distribution of data line values. 5561 5562 This function is quite similar to L{DataLine.dh}(), the differences are: 5563 output normalization (chosen to make the integral unity), output units 5564 (again set to make the integral unity), automated binning. 5565 5566 If all values are equal and B{C{ymin}}, B{C{ymax}} are not explictly specified, the 5567 range is chosen as [B{C{v}}-|B{C{v}}|/2,B{C{v}}+|B{C{v}}/2] where B{C{v}} is the unique value, 5568 except when B{C{v}}=0, in which case the range is set to [-1,1]. 5569 5570 Since: 2.8 5571 5572 @param distribution: Data line to put the distribution of B{C{data_line}} values to. 5573 It will be resampled to B{C{nstats}} samples (or the automatically 5574 chosen number of bins). I{(L{DataLine})} 5575 @param ymin: Start of value range, pass B{C{ymin}} = B{C{ymax}} = 0.0 for the full range. I{(float)} 5576 @param ymax: End of value range. I{(float)} 5577 @param normalize_to_unity: B{C{True}} to normalize the integral to unity (including 5578 setting y-units of output to the inverse of x-units), 5579 B{C{False}} to keep plain counts in the output (and set 5580 y-units to none). I{(bool)} 5581 @param nstats: The requested number of histogram bins, pass a non-positive number 5582 to automatically choose a suitable number of bins. I{(int)} 5583 @return: 5584 """ 5585 return None

5586 - def dh( target_line , ymin , ymax , nsteps ):

5587 """ 5588 Computes distribution of heights in interval [B{C{ymin}}, B{C{ymax}}). 5589 5590 If the interval is (0, 0) it computes the distribution from 5591 real data minimum and maximum value. 5592 5593 @param target_line: Data line to store height distribution function to. 5594 It will be resized to B{C{nsteps}}. I{(L{DataLine})} 5595 @param ymin: Height distribution minimum value. I{(float)} 5596 @param ymax: Height distribution maximum value. I{(float)} 5597 @param nsteps: Number of histogram steps. I{(int)} 5598 @return: 5599 """ 5600 return None

5601 - def cdh( target_line , ymin , ymax , nsteps ):

5602 """ 5603 Computes cumulative distribution of heighs in interval [B{C{ymin}}, B{C{ymax}}). 5604 5605 If the interval is (0, 0) it computes the distribution from 5606 real data minimum and maximum value. 5607 5608 @param target_line: Data line to store height distribution function to. 5609 It will be resized to B{C{nsteps}}. I{(L{DataLine})} 5610 @param ymin: Height distribution minimum value. I{(float)} 5611 @param ymax: Height distribution maximum value. I{(float)} 5612 @param nsteps: Number of histogram steps. I{(int)} 5613 @return: 5614 """ 5615 return None

5616 - def da( target_line , ymin , ymax , nsteps ):

5617 """ 5618 Computes distribution of angles in interval [B{C{ymin}}, B{C{ymax}}). 5619 5620 If the interval is (0, 0) it computes the distribution from 5621 real data minimum and maximum angle value. 5622 5623 @param target_line: Data line to store angle distribution function to. I{(L{DataLine})} 5624 @param ymin: Angle distribution minimum value. I{(float)} 5625 @param ymax: Angle distribution maximum value. I{(float)} 5626 @param nsteps: Mumber of angular histogram steps. I{(int)} 5627 @return: 5628 """ 5629 return None

5630 - def cda( target_line , ymin , ymax , nsteps ):

5631 """ 5632 Computes cumulative distribution of angles in interval [B{C{ymin}}, B{C{ymax}}). 5633 5634 If the interval is (0, 0) it computes the distribution from 5635 real data minimum and maximum angle value. 5636 5637 @param target_line: Data line to store angle distribution function to. 5638 It will be resized to B{C{nsteps}}. I{(L{DataLine})} 5639 @param ymin: Angle distribution minimum value. I{(float)} 5640 @param ymax: Angle distribution maximum value. I{(float)} 5641 @param nsteps: Number of angular histogram steps. I{(int)} 5642 @return: 5643 """ 5644 return None

5645 - def acf( target_line ):

5646 """ 5647 Coputes autocorrelation function and stores the values in 5648 B{C{target_line}} 5649 5650 @param target_line: Data line to store autocorrelation function to. It will be 5651 resized to B{C{data_line}} size. I{(L{DataLine})} 5652 @return: 5653 """ 5654 return None

5655 - def hhcf( target_line ):

5656 """ 5657 Computes height-height correlation function and stores results in 5658 B{C{target_line}}. 5659 5660 @param target_line: Data line to store height-height function to. It will be 5661 resized to B{C{data_line}} size. I{(L{DataLine})} 5662 @return: 5663 """ 5664 return None

5665 - def psdf( target_line , windowing , interpolation ):

5666 """ 5667 Calculates the power spectral density function of a data line. 5668 5669 Up to version 2.7 it destroyed the input data and did not set the output 5670 units properly. 5671 5672 @param target_line: Data line to store power spectral density function to. 5673 It will be resized to B{C{data_line}} size. I{(L{DataLine})} 5674 @param windowing: Windowing method to use. I{(int)} 5675 @param interpolation: Interpolation type. 5676 Ignored since 2.8 as no reampling is performed. I{(int)} 5677 @return: 5678 """ 5679 return None

5680 -class DataView:

5681 - def __init__( data ):

5682 """ 5683 Creates a new data-displaying widget for B{C{data}}. 5684 5685 A newly created B{C{DataView}} doesn't display anything. You have to add 5686 some layers to it, at least a base layer with 5687 L{DataView.set_base_layer}(), and possibly others with 5688 L{DataView.set_alpha_layer}() and L{DataView.set_top_layer}(). 5689 5690 The top layer is special. It must be a vector layer and can receive 5691 mouse and keyboard events. 5692 5693 The base layer it also special. It must be always present, and must not be 5694 transparent or vector. 5695 5696 5697 @return: A newly created data view as a B{C{GtkWidget}}. 5698 5699 """ 5700 return None

5701 - def get_base_layer( ):

5702 """ 5703 Returns the base layer this data view currently uses. 5704 5705 A base layer should be always present. 5706 5707 5708 @return: The currently used base layer. 5709 5710 """ 5711 return None

5712 - def set_base_layer( layer ):

5713 """ 5714 Plugs B{C{layer}} to B{C{data_view}} as the base layer. 5715 5716 If another base layer is present, it's unplugged. 5717 5718 The layer must not be a vector layer. Theoretically, it can be B{C{NULL}} to 5719 use no base layer, but then B{C{data_view}} will probably display garbage. 5720 5721 @param layer: A layer to be used as the base layer for B{C{data_view}}. I{(PixmapLayer*)} 5722 @return: 5723 """ 5724 return None

5725 - def get_alpha_layer( ):

5726 """ 5727 Returns the alpha layer this data view currently uses, or B{C{NULL}} if none 5728 is present. 5729 5730 5731 @return: The currently used alpha layer. 5732 5733 """ 5734 return None

5735 - def set_alpha_layer( layer ):

5736 """ 5737 Plugs B{C{layer}} to B{C{data_view}} as the alpha layer. 5738 5739 If another alpha layer is present, it's unplugged. 5740 5741 The layer must not be a vector layer. It can be B{C{NULL}}, meaning no alpha 5742 layer is to be used. 5743 5744 @param layer: A layer to be used as the alpha layer for B{C{data_view}}. I{(PixmapLayer*)} 5745 @return: 5746 """ 5747 return None

5748 - def get_top_layer( ):

5749 """ 5750 Returns the top layer this data view currently uses, or B{C{NULL}} if none 5751 is present. 5752 5753 5754 @return: The currently used top layer. 5755 5756 """ 5757 return None

5758 - def set_top_layer( layer ):

5759 """ 5760 Plugs B{C{layer}} to B{C{data_view}} as the top layer. 5761 5762 If another top layer is present, it's unplugged. 5763 5764 The layer must be a vector layer. It can be B{C{NULL}}, meaning no top 5765 layer is to be used. 5766 5767 @param layer: A layer to be used as the top layer for B{C{data_view}}. I{(VectorLayer*)} 5768 @return: 5769 """ 5770 return None

5771 - def get_data_prefix( ):

5772 """ 5773 Gets the prefix for the container data channel that the data view is 5774 currently set to display. 5775 5776 5777 @return: The container data prefix (eg. "/0/data"). 5778 5779 """ 5780 return None

5781 - def set_data_prefix( prefix ):

5782 """ 5783 Sets the prefix for the container data channel to display in a data view. 5784 5785 This function only affects where the data view itself takes parameters 5786 from, it does not affect layer keys. 5787 5788 @param prefix: Container prefix for data (eg. "/0/data"). I{(string)} 5789 @return: 5790 """ 5791 return None

5792 - def get_hexcess( ):

5793 """ 5794 Return the horizontal excess of widget size to data size. 5795 5796 Do not use. Only useful for B{C{DataWindow}} implementation. 5797 5798 5799 @return: The execess. 5800 5801 """ 5802 return None

5803 - def get_vexcess( ):

5804 """ 5805 Return the vertical excess of widget size to data size. 5806 5807 Do not use. Only useful for B{C{DataWindow}} implementation. 5808 5809 5810 @return: The execess. 5811 5812 """ 5813 return None

5814 - def set_zoom( zoom ):

5815 """ 5816 Sets zoom of B{C{data_view}} to B{C{zoom}}. 5817 5818 Zoom greater than 1 means larger image on screen and vice versa. 5819 5820 Note window manager can prevent the window from resize and thus the zoom 5821 from change. 5822 5823 @param zoom: A new zoom value. I{(float)} 5824 @return: 5825 """ 5826 return None

5827 - def get_zoom( ):

5828 """ 5829 Returns current ideal zoom of a data view. 5830 5831 More precisely the zoom value requested by L{DataView.set_zoom}(), if 5832 it's in use (real zoom may differ a bit due to pixel rounding). If zoom 5833 was set by explicite widget size change, real and requested zoom are 5834 considered to be the same. 5835 5836 When a resize is queued, the new zoom value is returned. 5837 5838 In other words, this is the zoom B{C{data_view}} would like to have. Use 5839 L{DataView.get_real_zoom}() to get the real zoom. 5840 5841 5842 @return: The zoom as a ratio between ideal displayed size and base data 5843 field size. 5844 5845 """ 5846 return None

5847 - def get_real_zoom( ):

5848 """ 5849 Returns current real zoom of a data view. 5850 5851 This is the zoom value a data view may not wish to have, but was imposed 5852 by window manager or other constraints. Unlike ideal zoom set by 5853 L{DataView.set_zoom}(), this value cannot be set. 5854 5855 When a resize is queued, the current (old) value is returned. 5856 5857 5858 @return: The zoom as a ratio between real displayed size and base data 5859 field size. 5860 5861 """ 5862 return None

5863 - def get_data( ):

5864 """ 5865 Returns the data container used by B{C{data_view}}. 5866 5867 5868 @return: The data as a B{C{Container}}. 5869 5870 """ 5871 return None

5872 - def UNIMPLEMENTED_coords_xy_clamp( xscr , yscr ):

5873 """ 5874 Fixes screen coordinates B{C{xscr}} and B{C{yscr}} to be inside the data-displaying 5875 area (which can be smaller than widget size). 5876 5877 @param xscr: A screen x-coordinate relative to widget origin. I{(gint*)} 5878 @param yscr: A screen y-coordinate relative to widget origin. I{(gint*)} 5879 @return: 5880 """ 5881 return None

5882 - def UNIMPLEMENTED_coords_xy_cut_line( x0scr , y0scr , x1scr , y1scr ):

5883 """ 5884 Fixes screen coordinates of line endpoints to be inside the data-displaying 5885 area (which can be smaller than widget size). 5886 5887 Since: 2.11 5888 5889 @param x0scr: First point screen x-coordinate relative to widget origin. I{(gint*)} 5890 @param y0scr: First point screen y-coordinate relative to widget origin. I{(gint*)} 5891 @param x1scr: Second point screen x-coordinate relative to widget origin. I{(gint*)} 5892 @param y1scr: Second point screen y-coordinate relative to widget origin. I{(gint*)} 5893 @return: 5894 """ 5895 return None

5896 - def coords_xy_to_real( xscr , yscr , xreal , yreal ):

5897 """ 5898 Recomputes screen coordinates relative to widget origin to physical 5899 coordinates in the sample. 5900 5901 @param xscr: A screen x-coordinate relative to widget origin. I{(int)} 5902 @param yscr: A screen y-coordinate relative to widget origin. I{(int)} 5903 @param xreal: Where the physical x-coordinate in the data sample should be stored. I{(float)} 5904 @param yreal: Where the physical y-coordinate in the data sample should be stored. I{(float)} 5905 @return: 5906 """ 5907 return None

5908 - def UNIMPLEMENTED_coords_real_to_xy( xreal , yreal , xscr , yscr ):

5909 """ 5910 Recomputes physical coordinate in the sample to screen coordinate relative 5911 to widget origin. 5912 5913 @param xreal: A physical x-coordinate in the data sample.. I{(float)} 5914 @param yreal: A physical y-coordinate in the data sample. I{(float)} 5915 @param xscr: Where the screen x-coordinate relative to widget origin should be 5916 stored. I{(gint*)} 5917 @param yscr: Where the screen y-coordinate relative to widget origin should be 5918 stored. I{(gint*)} 5919 @return: 5920 """ 5921 return None

5922 - def get_xmeasure( ):

5923 """ 5924 Returns the ratio between horizontal physical lengths and horizontal 5925 screen lengths in pixels. 5926 5927 5928 @return: The horizontal measure. 5929 5930 """ 5931 return None

5932 - def get_ymeasure( ):

5933 """ 5934 Returns the ratio between vertical physical lengths and horizontal 5935 screen lengths in pixels. 5936 5937 5938 @return: The vertical measure. 5939 5940 """ 5941 return None

5942 - def get_pixel_data_sizes( xres , yres ):

5943 """ 5944 Obtains pixel dimensions of data displayed by a data view. 5945 5946 This is a convenience method, the same values could be obtained 5947 by L{DataField.get_xres}() and L{DataField.get_yres}() of the data 5948 field displayed by the base layer. 5949 5950 @param xres: Location to store x-resolution of displayed data (or B{C{NULL}}). I{(int)} 5951 @param yres: Location to store y-resolution of displayed data (or B{C{NULL}}). I{(int)} 5952 @return: 5953 """ 5954 return None

5955 - def get_real_data_sizes( xreal , yreal ):

5956 """ 5957 Obtains physical dimensions of data displayed by a data view. 5958 5959 Physical coordinates are always taken from data field displayed by the base 5960 layer. This is a convenience method, the same values could be obtained 5961 by L{DataField.get_xreal}() and L{DataField.get_yreal}() of the data 5962 field displayed by the base layer. 5963 5964 @param xreal: Location to store physical x-dimension of the displayed data 5965 without excess (or B{C{NULL}}). I{(float)} 5966 @param yreal: Location to store physical y-dimension of the displayed data 5967 without excess (or B{C{NULL}}). I{(float)} 5968 @return: 5969 """ 5970 return None

5971 - def UNIMPLEMENTED_get_real_data_offsets( xoffset , yoffset ):

5972 """ 5973 Obtains physical offsets of data displayed by a data view. 5974 5975 Physical coordinates are always taken from data field displayed by the base 5976 layer. This is a convenience method, the same values could be obtained 5977 by L{DataField.get_xoffset}() and L{DataField.get_yoffset}() of the data 5978 field displayed by the base layer. 5979 5980 Since: 2.16 5981 5982 @param xoffset: Location to store physical x-offset of the top corner of 5983 displayed data without excess (or B{C{NULL}}). I{(gdouble*)} 5984 @param yoffset: Location to store physical y-offset of the top corner of 5985 displayed data without excess (or B{C{NULL}}). I{(gdouble*)} 5986 @return: 5987 """ 5988 return None

5989 - def UNIMPLEMENTED_get_metric( metric ):

5990 """ 5991 Fills metric matrix for a data view. 5992 5993 The metric matrix essentially transforms distances in physical coordinates 5994 to screen distances. It is to be used with functions like 5995 L{gwy_math_find_nearest_point}() and L{gwy_math_find_nearest_line}() when the 5996 distance should be screen-Euclidean. 5997 5998 @param metric: Metric matrix 2x2 (stored in sequentially by rows: m11, m12, m12, 5999 m22). I{(gdouble*)} 6000 @return: 6001 """ 6002 return None

6003 - def get_pixbuf( max_width , max_height ):

6004 """ 6005 Creates and returns a pixbuf from the data view. 6006 6007 If the data is not square, the resulting pixbuf is also nonsquare. 6008 The returned pixbuf also never has an alpha channel. 6009 6010 6011 @param max_width: Pixbuf width that should not be exceeeded. Value smaller than 6012 1 means unlimited size. I{(int)} 6013 @param max_height: Pixbuf height that should not be exceeeded. Value smaller than 6014 1 means unlimited size. I{(int)} 6015 @return: The pixbuf as a newly created B{C{GdkPixbuf}}, it should be freed 6016 when no longer needed. It is never larger than the actual data 6017 size, as B{C{max_width}} and B{C{max_height}} are only upper limits. 6018 6019 """ 6020 return None

6021 - def export_pixbuf( zoom , draw_alpha , draw_top ):

6022 """ 6023 Exports data view to a pixbuf. 6024 6025 6026 @param zoom: Zoom to export data with (unrelated to data view zoom). I{(float)} 6027 @param draw_alpha: B{C{True}} to draw alpha layer (mask). I{(bool)} 6028 @param draw_top: B{C{True}} to draw top layer (selection). I{(bool)} 6029 @return: A newly created pixbuf, it must be freed by caller. 6030 6031 """ 6032 return None

6033 -class DataViewLayer:

6034 - def plugged( ):

6035 """ 6036 Emits a "plugged" singal on a layer. 6037 6038 Primarily intended for B{C{DataView}} implementation. 6039 6040 @return: 6041 """ 6042 return None

6043 - def unplugged( ):

6044 """ 6045 Emits a "unplugged" singal on a layer. 6046 6047 Primarily intended for B{C{DataView}} implementation. 6048 6049 @return: 6050 """ 6051 return None

6052 - def updated( ):

6053 """ 6054 Emits a "updated" singal on a layer. 6055 6056 @return: 6057 """ 6058 return None

6059 - def realize( ):

6060 """ 6061 Tells a data view layer its parent was realized and it can create 6062 display-specific resources. 6063 6064 @return: 6065 """ 6066 return None

6067 - def unrealize( ):

6068 """ 6069 Tells a data view layer its parent was unrealized and it should destroy 6070 display-specific resources. 6071 6072 @return: 6073 """ 6074 return None

6075 -class DataWindow:

6076 - def __init__( data_view ):

6077 """ 6078 Creates a new data displaying window. 6079 6080 6081 @return: A newly created widget, as B{C{GtkWidget}}. 6082 6083 """ 6084 return None

6085 - def get_data_view( ):

6086 """ 6087 Returns the data view widget a data window currently shows. 6088 6089 6090 @return: The currently shown data view. 6091 6092 """ 6093 return None

6094 - def get_color_axis( ):

6095 """ 6096 Returns the color axis widget displayed by a data window. 6097 6098 6099 @return: The color axis. 6100 6101 """ 6102 return None

6103 - def get_data( ):

6104 """ 6105 Returns the data for the data view a data window currently shows. 6106 6107 6108 @return: The data as B{C{Container}}. 6109 6110 """ 6111 return None

6112 - def set_zoom( izoom ):

6113 """ 6114 Sets the zoom of a data window to B{C{izoom}}. 6115 6116 When B{C{izoom}} is -1 it zooms out; when B{C{izoom}} is 1 it zooms out. 6117 Otherwise the new zoom value is set to B{C{izoom}}/10000. 6118 6119 @param izoom: The new zoom value (as an integer). I{(int)} 6120 @return: 6121 """ 6122 return None

6123 - def get_data_name( ):

6124 """ 6125 Gets the data name part of a data window's title. 6126 6127 6128 @return: The data name as a string owned by the window. 6129 6130 """ 6131 return None

6132 - def set_data_name( data_name ):

6133 """ 6134 Sets the data name of a data window. 6135 6136 The data name is used in the window's title. 6137 6138 @param data_name: New data name. I{(string)} 6139 @return: 6140 """ 6141 return None

6142 - def get_ul_corner_widget( ):

6143 """ 6144 Returns the upper left corner widget of B{C{data_window}}. 6145 6146 6147 @return: The upper left corner widget as a B{C{GtkWidget}}, B{C{NULL}} if there is 6148 no such widget. 6149 6150 """ 6151 return None

6152 - def set_ul_corner_widget( corner ):

6153 """ 6154 Sets the widget in upper left corner of a data window to B{C{corner}}. 6155 6156 @param corner: A widget to set as upper left corner widget, many be B{C{NULL}} to 6157 just remove any eventual existing one. I{(L{gtk.Widget})} 6158 @return: 6159 """ 6160 return None

6161 -class Graph:

6162 - def __init__( gmodel ):

6163 """ 6164 Creates graph widget based on information in model. 6165 6166 6167 @return: new graph widget. 6168 6169 """ 6170 return None

6171 - def get_axis( type ):

6172 """ 6173 Gets a graph axis. 6174 6175 6176 @param type: Axis orientation I{(GtkPositionType)} 6177 @return: The axis (of given orientation) within the graph widget. 6178 6179 """ 6180 return None

6181 - def set_axis_visible( type , is_visible ):

6182 """ 6183 Sets the visibility of graph axis of given orientation. Visibility 6184 can be set also directly using Axis API. 6185 6186 @param type: Axis orientation I{(GtkPositionType)} 6187 @param is_visible: set/unset axis visibility within graph widget I{(bool)} 6188 @return: 6189 """ 6190 return None

6191 - def get_area( ):

6192 """ 6193 Gets the area widget of a graph. 6194 6195 6196 @return: The graph area widget within the graph. 6197 6198 """ 6199 return None

6200 - def set_model( gmodel ):

6201 """ 6202 Changes the model a graph displays. 6203 6204 Everything in graph widgets will be reset to reflect the new data. 6205 6206 @param gmodel: New graph model I{(L{GraphModel})} 6207 @return: 6208 """ 6209 return None

6210 - def get_model( ):

6211 """ 6212 Gets the model of a graph. 6213 6214 6215 @return: The graph model this graph widget displays. 6216 6217 """ 6218 return None

6219 - def set_status( status ):

6220 """ 6221 Sets the status of a graph widget. 6222 6223 The status determines how the graph reacts on mouse events. 6224 This includes point or area selection and zooming. 6225 6226 @param status: graph status I{(GraphStatusType)} 6227 @return: 6228 """ 6229 return None

6230 - def get_status( ):

6231 """ 6232 Get the status of a graph widget. 6233 6234 See L{Graph.set_status}() for more. 6235 6236 6237 @return: The current graph status. 6238 6239 """ 6240 return None

6241 - def enable_user_input( enable ):

6242 """ 6243 Enables/disables all the graph/curve settings dialogs to be invoked by 6244 mouse clicks. 6245 6246 @param enable: whether to enable user input I{(bool)} 6247 @return: 6248 """ 6249 return None

6250 - def export_pixmap( export_title , export_axis , export_labels ):

6251 return None

6252 - def UNIMPLEMENTED_export_postscript( export_title , export_axis , export_labels , str ):

6253 return None

6254 - def window_new( ):

6255 """ 6256 Creates a new window showing B{C{graph}}. 6257 6258 6259 @return: A newly created graph window as B{C{GtkWidget}}. 6260 6261 """ 6262 return None

6263 -class GraphArea:

6264 - def __init__( ):

6265 """ 6266 Creates a new graph area widget. 6267 6268 6269 @return: Newly created graph area as B{C{GtkWidget}}. 6270 6271 """ 6272 return None

6273 - def get_label( ):

6274 """ 6275 Gets the label inside a graph area. 6276 6277 6278 @return: The graph label widget within the graph area. 6279 6280 """ 6281 return None

6282 - def set_model( gmodel ):

6283 """ 6284 Sets the graph model of a graph area. 6285 6286 @param gmodel: New graph model. I{(L{GraphModel})} 6287 @return: 6288 """ 6289 return None

6290 - def get_model( ):

6291 """ 6292 Gets the model of a graph area. 6293 6294 6295 @return: The graph model this graph area widget displays. 6296 6297 """ 6298 return None

6299 - def get_cursor( x_cursor , y_cursor ):

6300 """ 6301 Gets mouse cursor related values within a graph area. 6302 6303 @param x_cursor: Location to store the x value corresponding to cursor position. I{(float)} 6304 @param y_cursor: Location to store the y value corresponding to cursor position. I{(float)} 6305 @return: 6306 """ 6307 return None

6308 - def set_x_range( x_min , x_max ):

6309 """ 6310 Sets the horizontal range a graph area displays. 6311 6312 @param x_min: The minimum x value, in real coodrinates. I{(float)} 6313 @param x_max: The maximum x value, in real coodrinates. I{(float)} 6314 @return: 6315 """ 6316 return None

6317 - def set_y_range( y_min , y_max ):

6318 """ 6319 Sets the vertical range a graph area displays. 6320 6321 @param y_min: The minimum y value, in real coodrinates. I{(float)} 6322 @param y_max: The maximum y value, in real coodrinates. I{(float)} 6323 @return: 6324 """ 6325 return None

6326 - def set_x_grid_data( ndata , grid_data ):

6327 """ 6328 Sets the grid data on the x-axis of a graph area 6329 6330 @param ndata: The number of points in B{C{grid_data}}. I{(int)} 6331 @param grid_data: Array of grid line positions on the x-axis (in real values, 6332 not pixels). I{(const-gdouble*)} 6333 @return: 6334 """ 6335 return None

6336 - def set_y_grid_data( ndata , grid_data ):

6337 """ 6338 Sets the grid data on the y-axis of a graph area 6339 6340 @param grid_data: Array of grid line positions on the y-axis (in real values, 6341 not pixels). I{(const-gdouble*)} 6342 @return: 6343 """ 6344 return None

6345 - def get_x_grid_data( ndata ):

6346 """ 6347 Gets the grid data on the x-axis of a graph area. 6348 6349 6350 @param ndata: Location to store the number of returned positions. I{(int)} 6351 @return: Array of grid line positions (in real values, not pixels) owned 6352 by the graph area. 6353 6354 """ 6355 return None

6356 - def get_y_grid_data( ndata ):

6357 """ 6358 Gets the grid data on the y-axis of a graph area. 6359 6360 6361 @param ndata: Location to store the number of returned positions. I{(int)} 6362 @return: Array of grid line positions (in real values, not pixels) owned 6363 by the graph area. 6364 6365 """ 6366 return None

6367 - def get_selection( status_type ):

6368 """ 6369 Gets the selection object corresponding to a status of a graph area. 6370 6371 A selection object exists even for inactive status types (selection modes), 6372 therefore also selections for other modes than the currently active one can 6373 be requested. 6374 6375 6376 @param status_type: Graph status. Value B{C{GRAPH_STATUS_PLAIN}} mode (which has 6377 no selection associated) stands for the currentl selection 6378 mode. I{(GraphStatusType)} 6379 @return: The requested selection. It is B{C{NULL}} only if B{C{status_type}} is 6380 B{C{GRAPH_STATUS_PLAIN}} and the current selection mode is 6381 B{C{GRAPH_STATUS_PLAIN}}. 6382 6383 """ 6384 return None

6385 - def set_status( status_type ):

6386 """ 6387 Sets the status of a graph area. 6388 6389 When the area is inside a B{C{Graph}}, use L{Graph.set_status}() instead 6390 (also see this function for details). 6391 6392 @param status_type: New graph area status. I{(GraphStatusType)} 6393 @return: 6394 """ 6395 return None

6396 - def get_status( ):

6397 """ 6398 Gets the status of a grap area. 6399 6400 See L{Graph.area_set_status}(). 6401 6402 6403 @return: The current graph area status. 6404 6405 """ 6406 return None

6407 - def draw_on_drawable( drawable , gc , x , y , width , height ):

6408 """ 6409 Draws a graph area to a Gdk drawable. 6410 6411 @param drawable: a B{C{GdkDrawable}} (destination for graphics operations) I{(GdkDrawable*)} 6412 @param gc: Graphics context. 6413 It is modified by this function unpredictably. I{(GdkGC*)} 6414 @param x: X position in B{C{drawable}} where the graph area should be drawn I{(int)} 6415 @param y: Y position in B{C{drawable}} where the graph area should be drawn I{(int)} 6416 @param width: width of the graph area on the drawable I{(int)} 6417 @param height: height of the graph area on the drawable I{(int)} 6418 @return: 6419 """ 6420 return None

6421 - def UNIMPLEMENTED_export_vector( x , y , width , height ):

6422 """ 6423 Creates PostScript representation of a graph area. 6424 6425 6426 @param x: I{(int)} 6427 @param y: I{(int)} 6428 @param width: I{(int)} 6429 @param height: I{(int)} 6430 @return: A fragment of PostScript code representing the the graph area 6431 as a newly allocated B{C{GString}}. 6432 6433 """ 6434 return None

6435 - def enable_user_input( enable ):

6436 """ 6437 Enables/disables all user input dialogs (invoked by clicking the mouse). 6438 6439 @param enable: B{C{True}} to enable user interaction, B{C{False}} to disable it. I{(bool)} 6440 @return: 6441 """ 6442 return None

6443 - def edit_curve( id ):

6444 """ 6445 Invokes the curve property dialog for a curve. 6446 6447 If the dialog is already displayed, it is switched to the requested curve. 6448 6449 Since: 2.5 6450 6451 @param id: The index of the curve to edit properties of. I{(int)} 6452 @return: 6453 """ 6454 return None

6455 -class GraphCurveModel:

6456 - def __init__( ):

6457 """ 6458 Creates a new graph curve model. 6459 6460 6461 @return: New empty graph curve model as a B{C{GObject}}. 6462 6463 """ 6464 return None

6465 - def new_alike( ):

6466 """ 6467 Creates new graph curve model object that has the same settings as B{C{gcmodel}}. 6468 6469 Curve data are not duplicated. 6470 6471 6472 @return: New graph curve model. 6473 6474 """ 6475 return None

6476 - def set_data( xdata , ydata , n ):

6477 """ 6478 Sets curve model data. 6479 6480 If there were calibration data in the former B{C{gcmodel}}, they are removed. 6481 6482 @param xdata: X data points (array of size B{C{n}}). I{(const-gdouble*)} 6483 @param ydata: Y data points (array of size B{C{n}}). I{(const-gdouble*)} 6484 @param n: Number of points, i.e. items in B{C{xdata}} and B{C{ydata}}. I{(int)} 6485 @return: 6486 """ 6487 return None

6488 - def set_data_from_dataline( dline , from_index , to_index ):

6489 """ 6490 Sets the curve data from B{C{DataLine}}. The range of import can be 6491 modified using parameters B{C{from_index}} and B{C{to_index}} that are 6492 interpreted directly as data indices within the B{C{DataLine}}. 6493 In the case that B{C{from_index}} == B{C{to_index}}, the full B{C{DataLine}} is used. 6494 6495 If there were calibration data in the former B{C{gcmodel}}, they are removed. 6496 6497 @param dline: A B{C{DataLine}} I{(L{DataLine})} 6498 @param from_index: index where to start I{(int)} 6499 @param to_index: where to stop I{(int)} 6500 @return: 6501 """ 6502 return None

6503 - def get_xdata( ):

6504 """ 6505 Gets pointer to x data points. 6506 6507 Data are used within the graph and cannot be freed. 6508 6509 6510 @return: X data points, owned by the curve model. 6511 6512 """ 6513 return None

6514 - def get_ydata( ):

6515 """ 6516 Gets pointer to y data points. 6517 6518 Data are used within the graph and cannot be freed. 6519 6520 6521 @return: Y data points, owned by the curve model. 6522 6523 """ 6524 return None

6525 - def get_ndata( ):

6526 """ 6527 6528 @return: number of data points within the curve data 6529 6530 """ 6531 return None

6532 - def get_x_range( x_min , x_max ):

6533 """ 6534 Gets the abscissa range of a graph curve. 6535 6536 The values are cached in the curve model therefore repeated calls to this 6537 function (with unchanged data) are cheap. 6538 6539 If there are no data points in the curve, B{C{x_min}} and B{C{x_max}} are untouched 6540 and the function returns B{C{False}}. 6541 6542 See also L{Graph.curve_model_get_ranges}() for a more high-level function. 6543 6544 6545 @param x_min: Location to store the minimum abscissa value, or B{C{NULL}}. I{(float)} 6546 @param x_max: Location to store the maximum abscissa value, or B{C{NULL}}. I{(float)} 6547 @return: B{C{True}} if there are any data points in the curve and B{C{x_min}}, B{C{x_max}} 6548 were set. 6549 6550 """ 6551 return None

6552 - def get_y_range( y_min , y_max ):

6553 """ 6554 Gets the ordinate range of a graph curve. 6555 6556 The values are cached in the curve model therefore repeated calls to this 6557 function (with unchanged data) are cheap. 6558 6559 If there are no data points in the curve, B{C{x_min}} and B{C{x_max}} are untouched 6560 and the function returns B{C{False}}. 6561 6562 See also L{Graph.curve_model_get_ranges}() for a more high-level function. 6563 6564 6565 @param y_min: Location to store the minimum ordinate value, or B{C{NULL}}. I{(float)} 6566 @param y_max: Location to store the maximum ordinate value, or B{C{NULL}}. I{(float)} 6567 @return: B{C{True}} if there are any data points in the curve and B{C{x_min}}, B{C{x_max}} 6568 were set. 6569 6570 """ 6571 return None

6572 - def get_ranges( x_logscale , y_logscale , x_min , x_max , y_min , y_max ):

6573 return None

6574 - def UNIMPLEMENTED_get_calibration_data( ):

6575 """ 6576 Get pointer to actual calibration data for curve. 6577 6578 6579 @return: Pointer to the calibration data of present curve (NULL if none). 6580 6581 6582 """ 6583 return None

6584 - def UNIMPLEMENTED_set_calibration_data( calibration ):

6585 """ 6586 Set calibration data for curve. 6587 6588 6589 @param calibration: Curve calibration data I{(const-CurveCalibrationData*)} 6590 @return: 6591 """ 6592 return None

6593 -class GraphCurves:

6594 - def __init__( gmodel ):

6595 """ 6596 Creates graph curve list widget based on information in graph model. 6597 6598 The B{C{GtkTreeModel}} and the columns follow the graph model and must not be 6599 changed manually. 6600 6601 Since: 2.5 6602 6603 @return: A new graph curve list. 6604 6605 6606 """ 6607 return None

6608 - def set_model( gmodel ):

6609 """ 6610 Changes the graph model a graph curve list. 6611 6612 Since: 2.5 6613 6614 @param gmodel: New graph model. I{(L{GraphModel})} 6615 @return: 6616 """ 6617 return None

6618 - def get_model( ):

6619 """ 6620 Gets the graph model a graph curve list displays. 6621 6622 Since: 2.5 6623 6624 @return: The graph model associated with this B{C{GraphCurves}} widget. 6625 6626 6627 """ 6628 return None

6629 -class GraphData:

6630 - def __init__( gmodel ):

6631 """ 6632 Creates graph_data widget based on information in graph model. 6633 6634 The B{C{GtkTreeModel}} and the columns follow the graph model and must not be 6635 changed manually. 6636 6637 6638 @return: A new graph_data widget. 6639 6640 """ 6641 return None

6642 - def set_model( gmodel ):

6643 """ 6644 Changes the graph model a graph data table displays. 6645 6646 @param gmodel: New graph_data model. I{(L{GraphModel})} 6647 @return: 6648 """ 6649 return None

6650 - def get_model( ):

6651 """ 6652 Gets the graph model a graph data table displays. 6653 6654 6655 @return: The graph model associated with this B{C{GraphData}} widget. 6656 6657 """ 6658 return None

6659 -class GraphLabel:

6660 - def __init__( ):

6661 """ 6662 Creates a new graph label. 6663 6664 6665 @return: A new graph label widget as a B{C{GtkWidget}}. 6666 6667 """ 6668 return None

6669 - def set_model( gmodel ):

6670 """ 6671 Sets new model of a graph label. 6672 6673 @param gmodel: New graph model. I{(L{GraphModel})} 6674 @return: 6675 """ 6676 return None

6677 - def get_model( ):

6678 """ 6679 Gets the model of a graph key. 6680 6681 6682 @return: The graph model this graph label takes curve properties and 6683 descriptions from. 6684 6685 """ 6686 return None

6687 - def enable_user_input( enable ):

6688 """ 6689 Enables or disables user input to a graph label. 6690 6691 @param enable: Whether to enable the user input. I{(bool)} 6692 @return: 6693 """ 6694 return None

6695 - def UNIMPLEMENTED_draw_on_drawable( drawable , gc , layout , x , y , width , height ):

6696 """ 6697 draws a graph label on a drawable 6698 6699 @param drawable: the B{C{GdkDrawable}} I{(GdkDrawable*)} 6700 @param gc: Graphics context. 6701 It is modified by this function unpredictably. I{(GdkGC*)} 6702 @param layout: pango layout I{(PangoLayout*)} 6703 @param x: x position where label is to be drawn I{(int)} 6704 @param y: y position where label is to be drawn I{(int)} 6705 @param width: width of the label I{(int)} 6706 @param height: hieght of the label I{(int)} 6707 @return: 6708 """ 6709 return None

6710 - def UNIMPLEMENTED_export_vector( x , y , width , height , fontsize ):

6711 """ 6712 Creates PostScript representation of a graph label. 6713 6714 6715 @param x: x position of the graph label I{(int)} 6716 @param y: y position of the graph label I{(int)} 6717 @param width: width of the graph label I{(int)} 6718 @param height: hieght of the graph label I{(int)} 6719 @param fontsize: fontsize of the label I{(int)} 6720 @return: A fragment of PostScript code representing the the graph label 6721 as a newly allocated B{C{GString}}. 6722 6723 """ 6724 return None

6725 -class GraphModel:

6726 - def __init__( ):

6727 """ 6728 Creates a new graph model. 6729 6730 6731 @return: New graph model as a B{C{GObject}}. 6732 6733 """ 6734 return None

6735 - def new_alike( ):

6736 """ 6737 Creates new graph model object that has the same settings as B{C{gmodel}}. 6738 6739 This includes axis/label visibility, actual plotting range, etc. 6740 Curves are not duplicated or referenced. 6741 6742 6743 @return: New graph model. 6744 6745 """ 6746 return None

6747 - def get_n_curves( ):

6748 """ 6749 6750 @return: number of curves in graph model. 6751 6752 """ 6753 return None

6754 - def add_curve( curve ):

6755 """ 6756 Adds a new curve to a graph model. 6757 6758 6759 @param curve: A B{C{GraphCurveModel}} representing the curve to add. I{(GraphCurveModel*)} 6760 @return: The index of the added curve in B{C{gmodel}}. 6761 6762 """ 6763 return None

6764 - def remove_curve_by_description( description ):

6765 """ 6766 Removes all the curves having same description string as B{C{description}}. 6767 6768 6769 @param description: Curve description (label). I{(string)} 6770 @return: The number of removed curves. 6771 6772 """ 6773 return None

6774 - def remove_curve( cindex ):

6775 """ 6776 Removes the curve having given index. 6777 6778 @param cindex: Curve index in graph model. I{(int)} 6779 @return: 6780 """ 6781 return None

6782 - def get_curve_by_description( description ):

6783 """ 6784 6785 @param description: Curve description (label). I{(string)} 6786 @return: The first curve that has description (label) given by B{C{description}} 6787 (no reference is added). 6788 6789 """ 6790 return None

6791 - def get_curve( cindex ):

6792 """ 6793 Gets a graph model curve by its index. 6794 6795 6796 @param cindex: Curve index in graph model. I{(int)} 6797 @return: The curve with index B{C{cindex}} (no reference is added). 6798 6799 """ 6800 return None

6801 - def get_curve_index( curve ):

6802 """ 6803 Finds the index of a graph model curve. 6804 6805 6806 @param curve: A curve model present in B{C{gmodel}} to find. I{(GraphCurveModel*)} 6807 @return: The index of B{C{curve}} in B{C{gmodel}}, -1 if it is not present there. 6808 6809 """ 6810 return None

6811 - def remove_all_curves( ):

6812 """ 6813 Removes all the curves from graph model 6814 6815 @return: 6816 """ 6817 return None

6818 - def set_units_from_data_line( data_line ):

6819 """ 6820 Sets x and y graph model units to match a data line. 6821 6822 @param data_line: A data line to take units from. I{(L{DataLine})} 6823 @return: 6824 """ 6825 return None

6826 - def x_data_can_be_logarithmed( ):

6827 """ 6828 Checks whehter x axis can be lograrithmed. 6829 6830 6831 @return: True if all x-values are greater than zero (thus logarithmic 6832 display of x-data is feasible). 6833 6834 """ 6835 return None

6836 - def y_data_can_be_logarithmed( ):

6837 """ 6838 Checks whehter y axis can be lograrithmed. 6839 6840 6841 @return: True if all y-values are greater than zero (thus logarithmic 6842 display of y-data is feasible). 6843 6844 """ 6845 return None

6846 - def set_axis_label( pos , label ):

6847 """ 6848 Sets one axis label of a graph model. 6849 6850 @param pos: Axis position. I{(GtkPositionType)} 6851 @param label: The new label. I{(string)} 6852 @return: 6853 """ 6854 return None

6855 - def get_axis_label( pos ):

6856 """ 6857 Gets the label of a one graph model axis. 6858 6859 6860 @param pos: Axis position. I{(GtkPositionType)} 6861 @return: The label as a string owned by the model. 6862 6863 """ 6864 return None

6865 - def get_x_range( x_min , x_max ):

6866 """ 6867 Gets the abscissa range of a graph. 6868 6869 Explicitly set minimum and maximum range properties take precedence over 6870 values calculated from curve abscissa ranges. 6871 6872 6873 @param x_min: Location to store the minimum abscissa value, or B{C{NULL}}. I{(float)} 6874 @param x_max: Location to store the maximum abscissa value, or B{C{NULL}}. I{(float)} 6875 @return: B{C{True}} if the requested values were filled, B{C{False}} is there are no 6876 data points and the ranges are not explicitly set. 6877 6878 """ 6879 return None

6880 - def get_y_range( y_min , y_max ):

6881 """ 6882 Gets the ordinate range of a graph. 6883 6884 Explicitly set minimum and maximum range properties take precedence over 6885 values calculated from curve ordinate ranges. 6886 6887 6888 @param y_min: Location to store the minimum ordinate value, or B{C{NULL}}. I{(float)} 6889 @param y_max: Location to store the maximum ordinate value, or B{C{NULL}}. I{(float)} 6890 @return: B{C{True}} if the requested values were filled, B{C{False}} is there are no 6891 data points and the ranges are not explicitly set. 6892 6893 """ 6894 return None

6895 - def get_ranges( x_logscale , y_logscale , x_min , x_max , y_min , y_max ):

6896 """ 6897 Gets the log-scale suitable range minima of a graph curve. 6898 6899 See L{Graph.curve_model_get_ranges}() for discussion. 6900 6901 Since: 2.8 6902 6903 @param x_logscale: B{C{True}} if logarithmical scale is intended for the abscissa. I{(bool)} 6904 @param y_logscale: B{C{True}} if logarithmical scale is intended for the ordinate. I{(bool)} 6905 @param x_min: Location to store the minimum abscissa value, or B{C{NULL}}. I{(float)} 6906 @param x_max: Location to store the maximum abscissa value, or B{C{NULL}}. I{(float)} 6907 @param y_min: Location to store the minimum ordinate value, or B{C{NULL}}. I{(float)} 6908 @param y_max: Location to store the maximum ordinate value, or B{C{NULL}}. I{(float)} 6909 @return: B{C{True}} if all requested output arguments were filled with the 6910 ranges. 6911 6912 6913 """ 6914 return None

6915 - def UNIMPLEMENTED_export_ascii( export_units , export_labels , export_metadata , export_style , string ):

6916 """ 6917 Exports a graph model data to a file. 6918 6919 The export format is specified by parameter B{C{export_style}}. 6920 6921 6922 @param export_units: B{C{True}} to export units in the column header. I{(bool)} 6923 @param export_labels: B{C{True}} to export labels in the column header. I{(bool)} 6924 @param export_metadata: B{C{True}} to export all graph metadata within file header. I{(bool)} 6925 @param export_style: File format subtype to export to (e. g. plain, csv, gnuplot, 6926 etc.). I{(GraphModelExportStyle)} 6927 @param string: A string to append the text dump to, or B{C{NULL}} to allocate a new 6928 string. I{(GString*)} 6929 @return: Either B{C{string}} itself if it was not B{C{NULL}}, or a newly allocated 6930 B{C{GString}}. 6931 6932 """ 6933 return None

6934 -class GraphWindow:

6935 - def get_graph( ):

6936 """ 6937 Gets the graph widget a graph window currently shows. 6938 6939 6940 @return: The currently shown B{C{Graph}}. 6941 6942 """ 6943 return None

6944 - def get_graph_data( ):

6945 """ 6946 Gets the graph data widget of a graph window. 6947 6948 Since: 2.5 6949 6950 @return: The B{C{GraphData}} widget of this graph window. Its model and 6951 column layout must be considered private. 6952 6953 6954 """ 6955 return None

6956 - def get_graph_curves( ):

6957 """ 6958 Gets the graph curves widget of a graph window. 6959 6960 Since: 2.5 6961 6962 @return: The B{C{GraphCurves}} widget of this graph window. Its model and 6963 column layout must be considered private. 6964 6965 6966 """ 6967 return None

6968 -class Inventory:

6969 - def __init__( itype ):

6970 """ 6971 Creates a new inventory. 6972 6973 6974 @return: The newly created inventory. 6975 6976 """ 6977 return None

6978 - def get_n_items( ):

6979 """ 6980 Returns the number of items in an inventory. 6981 6982 6983 @return: The number of items. 6984 6985 """ 6986 return None

6987 - def can_make_copies( ):

6988 """ 6989 Returns whether an inventory can create new items itself. 6990 6991 The prerequistie is that item type is a serializable object. It enables 6992 functions like L{Inventory.new_item}(). 6993 6994 6995 @return: B{C{True}} if inventory can create new items itself. 6996 6997 """ 6998 return None

6999 - def UNIMPLEMENTED_get_item_type( ):

7000 """ 7001 Returns the type of item an inventory holds. 7002 7003 7004 @return: The item type. It is owned by inventory and must not be modified 7005 or freed. 7006 7007 """ 7008 return None

7009 - def get_item( name ):

7010 """ 7011 Looks up an item in an inventory. 7012 7013 7014 @param name: Item name. I{(string)} 7015 @return: Item called B{C{name}}, or B{C{NULL}} if there is no such item. 7016 7017 """ 7018 return None

7019 - def UNIMPLEMENTED_get_item_or_default( name ):

7020 """ 7021 Looks up an item in an inventory, eventually falling back to default. 7022 7023 The lookup order is: item of requested name, default item (if set), any 7024 inventory item, B{C{NULL}} (can happen only when inventory is empty). 7025 7026 7027 @param name: Item name. I{(string)} 7028 @return: Item called B{C{name}}, or default item. 7029 7030 """ 7031 return None

7032 - def UNIMPLEMENTED_get_nth_item( n ):

7033 """ 7034 Returns item on given position in an inventory. 7035 7036 7037 @param n: Item position. It must be between zero and the number of items in 7038 inventory, inclusive. If it is equal to the number of items, B{C{NULL}} 7039 is returned. In other words, inventory behaves like a B{C{NULL}}-terminated 7040 array, you can simply iterate over it until L{Inventory.get_nth_item}() 7041 returns B{C{NULL}}. I{(int)} 7042 @return: Item at given position. 7043 7044 """ 7045 return None

7046 - def get_item_position( name ):

7047 """ 7048 Finds position of an item in an inventory. 7049 7050 7051 @param name: Item name. I{(string)} 7052 @return: Item position, or -1 if there is no such item. 7053 7054 """ 7055 return None

7056 - def UNIMPLEMENTED_foreach( function , user_data ):

7057 """ 7058 Calls a function on each item of an inventory, in order. 7059 7060 B{C{function}}'s first argument is item position (transformed with 7061 GUINT_TO_POINTER()), second is item pointer, and the last is B{C{user_data}}. 7062 7063 @param function: A function to call on each item. It must not modify B{C{inventory}}. I{(GHFunc)} 7064 @param user_data: Data passed to B{C{function}}. I{(gpointer)} 7065 @return: 7066 """ 7067 return None

7068 - def UNIMPLEMENTED_find( predicate , user_data ):

7069 """ 7070 Finds an inventory item using user-specified predicate function. 7071 7072 B{C{predicate}} is called for each item in B{C{inventory}} (in order) until it returns 7073 B{C{True}}. Its arguments are the same as in L{Inventory.foreach}(). 7074 7075 7076 @param predicate: A function testing some item property. It must not modify 7077 B{C{inventory}}. I{(GHRFunc)} 7078 @param user_data: Data passed to B{C{predicate}}. I{(gpointer)} 7079 @return: The item for which B{C{predicate}} returned B{C{True}}. If there is no 7080 such item in the inventory, B{C{NULL}} is returned. 7081 7082 """ 7083 return None

7084 - def set_default_item_name( name ):

7085 """ 7086 Sets the default of an inventory. 7087 7088 Item B{C{name}} must already exist in the inventory. 7089 7090 @param name: Item name, pass B{C{NULL}} to unset default item. I{(string)} 7091 @return: 7092 """ 7093 return None

7094 - def get_default_item_name( ):

7095 """ 7096 Returns the name of the default item of an inventory. 7097 7098 7099 @return: The default item name, B{C{NULL}} if no default name is set. 7100 Item of this name may or may not exist in the inventory. 7101 7102 """ 7103 return None

7104 - def get_default_item( ):

7105 """ 7106 Returns the default item of an inventory. 7107 7108 7109 @return: The default item. If there is no default item, B{C{NULL}} is returned. 7110 7111 """ 7112 return None

7113 - def item_updated( name ):

7114 """ 7115 Notifies inventory an item was updated. 7116 7117 This function makes sense primarily for non-object items, as object items 7118 can notify inventory via signals. 7119 7120 @param name: Item name. I{(string)} 7121 @return: 7122 """ 7123 return None

7124 - def nth_item_updated( n ):

7125 """ 7126 Notifies inventory item on given position was updated. 7127 7128 This function makes sense primarily for non-object items, as object items 7129 can implement B{C{Watchable}} interface. 7130 7131 @param n: Item position. I{(int)} 7132 @return: 7133 """ 7134 return None

7135 - def restore_order( ):

7136 """ 7137 Assures an inventory is sorted. 7138 7139 @return: 7140 """ 7141 return None

7142 - def forget_order( ):

7143 """ 7144 Forces an inventory to be unsorted. 7145 7146 Item positions don't change, but future L{Inventory.insert_item}() won't 7147 try to insert items in order. 7148 7149 @return: 7150 """ 7151 return None

7152 - def UNIMPLEMENTED_insert_item( item ):

7153 """ 7154 Inserts an item into an inventory. 7155 7156 Item of the same name must not exist yet. 7157 7158 If the inventory is sorted, item is inserted to keep order. If the 7159 inventory is unsorted, item is simply added to the end. 7160 7161 7162 @param item: An item to insert. I{(gpointer)} 7163 @return: B{C{item}}, for convenience. 7164 7165 """ 7166 return None

7167 - def UNIMPLEMENTED_insert_nth_item( item , n ):

7168 """ 7169 Inserts an item to an explicit position in an inventory. 7170 7171 Item of the same name must not exist yet. 7172 7173 7174 @param item: An item to insert. I{(gpointer)} 7175 @param n: Position to insert B{C{item}} to. I{(int)} 7176 @return: B{C{item}}, for convenience. 7177 7178 """ 7179 return None

7180 - def delete_item( name ):

7181 """ 7182 Deletes an item from an inventory. 7183 7184 7185 @param name: Name of item to delete. I{(string)} 7186 @return: B{C{True}} if item was deleted. 7187 7188 """ 7189 return None

7190 - def delete_nth_item( n ):

7191 """ 7192 Deletes an item on given position from an inventory. 7193 7194 7195 @param n: Position of B{C{item}} to delete. I{(int)} 7196 @return: B{C{True}} if item was deleted. 7197 7198 """ 7199 return None

7200 - def UNIMPLEMENTED_rename_item( name , newname ):

7201 """ 7202 Renames an inventory item. 7203 7204 If an item of name B{C{newname}} is already present in B{C{inventory}}, the rename 7205 will fail. 7206 7207 7208 @param name: Name of item to rename. I{(string)} 7209 @param newname: New name of item. I{(string)} 7210 @return: The item, for convenience. 7211 7212 """ 7213 return None

7214 - def UNIMPLEMENTED_new_item( name , newname ):

7215 """ 7216 Creates a new item as a copy of existing one and inserts it to inventory. 7217 7218 The newly created item can be called differently than B{C{newname}} if that 7219 already exists. 7220 7221 7222 @param name: Name of item to duplicate, may be B{C{NULL}} to use default item (the 7223 same happens when B{C{name}} does not exist). I{(string)} 7224 @param newname: Name of new item, it must not exist yet. It may be B{C{NULL}}, the 7225 new name is based on B{C{name}} then. I{(string)} 7226 @return: The newly added item. 7227 7228 """ 7229 return None

7230 - def store_new( ):

7231 """ 7232 Creates a new B{C{GtkTreeModel}} wrapper around a B{C{Inventory}}. 7233 7234 7235 @return: The newly created inventory store. 7236 7237 """ 7238 return None

7239 -class InventoryStore:

7240 - def get_inventory( ):

7241 """ 7242 Gets the inventory a inventory store wraps. 7243 7244 7245 @return: The underlying inventory (its reference count is not increased). 7246 7247 """ 7248 return None

7249 - def get_column_by_name( name ):

7250 """ 7251 Gets tree model column corresponding to a trait name. 7252 7253 The underlying inventory must support trait names, except for B{C{name}} 7254 <literal>"item"</literal> which always works (and always maps to 0). 7255 7256 7257 @param name: Trait (column) name. I{(string)} 7258 @return: The underlying inventory (its reference count is not increased). 7259 7260 """ 7261 return None

7262 - def UNIMPLEMENTED_get_iter( name , iter ):

7263 """ 7264 Initializes a tree iterator to row corresponding to a inventory item. 7265 7266 7267 @param name: Item name. I{(string)} 7268 @param iter: Tree iterator to set to point to item named B{C{name}}. I{(GtkTreeIter*)} 7269 @return: B{C{True}} if B{C{iter}} is valid, that is the item exists, B{C{False}} if B{C{iter}} 7270 was not set. 7271 7272 """ 7273 return None

7274 - def UNIMPLEMENTED_iter_is_valid( iter ):

7275 """ 7276 Checks if the given iter is a valid iter for this inventory store. 7277 7278 <warning>This function is slow. Only use it for debugging and/or testing 7279 purposes.</warning> 7280 7281 7282 @param iter: A B{C{GtkTreeIter}}. I{(GtkTreeIter*)} 7283 @return: B{C{True}} if the iter is valid, B{C{False}} if the iter is invalid. 7284 7285 """ 7286 return None

7287 -class MarkerBox:

7288 - def get_selected_marker( ):

7289 """ 7290 Gets the index of the currently selected marker in a marker 7291 box. 7292 7293 7294 @return: The index of currently selected marker, -1 when none is 7295 selected. 7296 7297 """ 7298 return None

7299 - def set_selected_marker( i ):

7300 """ 7301 Selects a marker in a marker box. 7302 7303 @param i: The index of marker to select. Pass -1 to unselect. I{(int)} 7304 @return: 7305 """ 7306 return None

7307 - def get_marker_position( i ):

7308 """ 7309 Gets the position of a marker in a marker box. 7310 7311 7312 @param i: The index of marker to get position of. I{(int)} 7313 @return: The marker position, in the range [0.0, 1.0]. 7314 7315 """ 7316 return None

7317 - def set_marker_position( i , pos ):

7318 """ 7319 Moves a marker in a marker box. 7320 7321 7322 @param i: Index of marker to move. I{(int)} 7323 @param pos: The new marker position, in the range [0.0, 1.0]. I{(float)} 7324 @return: B{C{True}} on success. If the move does not validate, B{C{False}} is returned 7325 and the marker position does not change. 7326 7327 """ 7328 return None

7329 - def add_marker( i , pos ):

7330 """ 7331 Adds a marker to a marker box. 7332 7333 7334 @param i: Index to insert marker at. I{(int)} 7335 @param pos: Position to insert marker to, in the range [0.0, 1.0]. I{(float)} 7336 @return: On success, the index the marker was added at. If the insertion 7337 does not validate, -1 is returned and no marker is added. 7338 7339 """ 7340 return None

7341 - def remove_marker( i ):

7342 """ 7343 Removes a marker from a marker box. 7344 7345 7346 @param i: Index of marker to remove. I{(int)} 7347 @return: B{C{True}} on success. If the removal does not validate, B{C{False}} is 7348 returned and the marker is kept. 7349 7350 """ 7351 return None

7352 - def get_nmarkers( ):

7353 """ 7354 Gets the number of markers in a marker box. 7355 7356 7357 @return: The number of markers. 7358 7359 """ 7360 return None

7361 - def get_markers( ):

7362 """ 7363 Gets all markers in a marker box. 7364 7365 7366 @return: The markers as an array of positions, owned by B{C{mbox}}. It must 7367 not be modified nor freed by caller and it's valid only until 7368 next marker change. 7369 7370 """ 7371 return None

7372 - def set_markers( n , markers ):

7373 """ 7374 Sets positions of all markers in a marker box. 7375 7376 No validation is performed, even if validator is set. It's up to caller to 7377 set markers that do not logically conflict with the validator. 7378 7379 @param n: The number of markers to set. If it is zero, B{C{markers}} can be B{C{NULL}}. I{(int)} 7380 @param markers: Markers position. I{(const-gdouble*)} 7381 @return: 7382 """ 7383 return None

7384 - def set_flipped( flipped ):

7385 """ 7386 Sets whether a marker box is drawn upside down. 7387 7388 @param flipped: B{C{True}} to draw markers upside down. I{(bool)} 7389 @return: 7390 """ 7391 return None

7392 - def get_flipped( ):

7393 """ 7394 Returns whether a marker box is drawn upside down. 7395 7396 7397 @return: B{C{True}} if markers are drawn upside down. 7398 7399 """ 7400 return None

7401 - def set_highlight_selected( highlight ):

7402 """ 7403 Sets whether a marker box highlights selected marker. 7404 7405 @param highlight: B{C{True}} to visually differentiate selected marker, B{C{False}} to 7406 draw markers uniformly. I{(bool)} 7407 @return: 7408 """ 7409 return None

7410 - def get_highlight_selected( ):

7411 """ 7412 Returns whether a marker box highlights selected marker. 7413 7414 7415 @return: B{C{True}} if selected marker is visually differentiated, B{C{False}} if 7416 markers are drawn uniformly. 7417 7418 """ 7419 return None

7420 - def UNIMPLEMENTED_set_validator( validate ):

7421 """ 7422 Sets marker box marker validation function. 7423 7424 It is used the next time an attempt to change markers is made, no 7425 revalidation is done immediately. It's up to caller to set a validator 7426 that do not logically conflict with the distribution of markers. 7427 7428 @param validate: Marker validation function. Pass B{C{NULL}} to disable validation. I{(MarkerValidateFunc)} 7429 @return: 7430 """ 7431 return None

7432 - def UNIMPLEMENTED_get_validator( ):

7433 """ 7434 Gets the marker validation function currently in use. 7435 7436 7437 @return: The marker validation function. 7438 7439 """ 7440 return None

7441 -class NullStore:

7442 - def __init__( n ):

7443 """ 7444 Creates a new B{C{GtkTreeModel}} wrapper around nothing. 7445 7446 7447 @return: The newly created null store. 7448 7449 """ 7450 return None

7451 - def get_n_rows( ):

7452 """ 7453 Gets the number of imaginary rows in a null store. 7454 7455 This is a convenience function, the same information can be obtained with 7456 gtk_tree_model_iter_n_children(). 7457 7458 7459 @return: The number of rows. 7460 7461 """ 7462 return None

7463 - def set_n_rows( n ):

7464 """ 7465 Sets the number of imaginary rows in a null store. 7466 7467 If the new number of rows is larger than the current one, rows will be 7468 sequentially and virtually appended to the end of the store until the 7469 requested number of rows is reached. 7470 7471 Similarly, if the new number of rows is smaller then the current one, rows 7472 will be sequentially and virtually deleted from the end of the store until 7473 the requested number of rows is reached. 7474 7475 Note for radical changes it is usually more useful to disconnect the model 7476 from its view(s), change the number of rows, and then reconnect. 7477 7478 @param n: The new number of rows. I{(int)} 7479 @return: 7480 """ 7481 return None

7482 - def UNIMPLEMENTED_get_model( ):

7483 """ 7484 Gets the model pointer of a null store. 7485 7486 7487 @return: The pointer set with L{NullStore.set_model}(). 7488 7489 """ 7490 return None

7491 - def UNIMPLEMENTED_set_model( model , destroy ):

7492 """ 7493 Sets the model pointer of a null store. 7494 7495 While the virtual integers in B{C{NullStore}} can be used directly, a null 7496 store typically serves as an adaptor for array-like structures and its rows 7497 are used as indices to these structures. This helper method provides means 7498 to attach such a structure to a null store in the common case. 7499 7500 The store itself does not interpret nor access the attached data by any 7501 means. No signals are emitted in response to the model pointer change 7502 either, particularly because it is expected to be set only once upon 7503 creation (null stores are cheap). 7504 7505 You are free to keep the model pointer at B{C{NULL}} if these functions do not 7506 suit your needs. 7507 7508 @param model: Model pointer. I{(gpointer)} 7509 @param destroy: Function to call on B{C{model}} when it is replaced or the store is 7510 destroyed. I{(GDestroyNotify)} 7511 @return: 7512 """ 7513 return None

7514 - def row_changed( i ):

7515 """ 7516 Emits "GtkTreeModel::row-changed" signal on a null store. 7517 7518 This is a convenience method, with a bit more work the same effect can be 7519 achieved with gtk_tree_model_row_changed(). 7520 7521 @param i: A row to emit "row-changed" on. I{(int)} 7522 @return: 7523 """ 7524 return None

7525 - def UNIMPLEMENTED_iter_is_valid( iter ):

7526 """ 7527 Checks if the given iter is a valid iter for this null store. 7528 7529 7530 @param iter: A B{C{GtkTreeIter}}. I{(GtkTreeIter*)} 7531 @return: B{C{True}} if the iter is valid, B{C{False}} if the iter is invalid. 7532 7533 """ 7534 return None

7535 -class PixmapLayer:

7536 - def wants_repaint( ):

7537 """ 7538 Checks whether a pixmap layer wants repaint. 7539 7540 7541 @return: B{C{True}} if the the layer wants repaint itself, B{C{False}} otherwise. 7542 7543 """ 7544 return None

7545 - def paint( ):

7546 """ 7547 Returns a pixbuf with painted pixmap layer. 7548 7549 This method does not enforce repaint. If the layer doesn't think it needs 7550 to repaint the pixbuf, it simply returns the current one. To enforce 7551 update, emit "data-changed" signal on corresponding data field. 7552 7553 7554 @return: The pixbuf. It should not be modified or freed. If the data field 7555 to draw is not present in the container, B{C{NULL}} is returned. 7556 7557 """ 7558 return None

7559 - def set_data_key( key ):

7560 """ 7561 Sets the data field to display by a pixmap layer. 7562 7563 @param key: Container string key identifying the data field to display. I{(string)} 7564 @return: 7565 """ 7566 return None

7567 - def get_data_key( ):

7568 """ 7569 Gets the key identifying data field this pixmap layer displays. 7570 7571 7572 @return: The string key, or B{C{NULL}} if it isn't set. 7573 7574 """ 7575 return None

7576 - def make_pixbuf( has_alpha ):

7577 """ 7578 Creates or resizes pixmap layer B{C{GdkPixbuf}} to match its data field. 7579 7580 This method is intended for pixmap layer implementation. 7581 7582 @param has_alpha: Whether pixbuf should have alpha channel. I{(bool)} 7583 @return: 7584 """ 7585 return None

7586 -class LayerMask:

7587 - def __init__( ):

7588 """ 7589 Creates a new mask layer. 7590 7591 By default, is uses a transparent color (thus not displaying anything). 7592 7593 7594 @return: The newly created layer. 7595 7596 """ 7597 return None

7598 - def set_color_key( prefix ):

7599 """ 7600 Sets the container key of colour components of a mask layer. 7601 7602 @param prefix: Prefix of keys identifying mask color components, "/red", "/green", 7603 "/blue", and "/alpha" is appended to it to get the individual 7604 keys. I{(string)} 7605 @return: 7606 """ 7607 return None

7608 - def get_color_key( ):

7609 """ 7610 Gets prefix identifying color components. 7611 7612 7613 @return: The prefix, or B{C{NULL}} if it isn't set. 7614 7615 """ 7616 return None

7617 - def get_color( ):

7618 """ 7619 Returns the color used by a mask layer. 7620 7621 7622 @return: The color as B{C{RGBA}}. 7623 7624 """ 7625 return None

7626 -class LayerBasic:

7627 - def __init__( ):

7628 """ 7629 Creates a new basic data displaying layer. 7630 7631 7632 @return: The newly created layer. 7633 7634 """ 7635 return None

7636 - def get_range( min , max ):

7637 """ 7638 Gets the range colors are mapped from in current mode. 7639 7640 This function does not take presentations into account. It always returns 7641 ther range corresponding to the underlying data even if a presentation is 7642 shown instead. 7643 7644 @param min: Location to store range minimum to. I{(float)} 7645 @param max: Location to store range maximum to. I{(float)} 7646 @return: 7647 """ 7648 return None

7649 - def get_range_type( ):

7650 """ 7651 Gets the current color mapping mode. 7652 7653 Since: 2.7 7654 7655 @return: The current color mapping mode. 7656 7657 7658 """ 7659 return None

7660 - def set_gradient_key( key ):

7661 """ 7662 Sets the container key of the colour gradient to use to visualize data. 7663 7664 @param key: Container string key identifying the color gradient to use. I{(string)} 7665 @return: 7666 """ 7667 return None

7668 - def get_gradient_key( ):

7669 """ 7670 Gets key identifying color gradient. 7671 7672 7673 @return: The string key, or B{C{NULL}} if it isn't set. 7674 7675 """ 7676 return None

7677 - def set_presentation_key( key ):

7678 """ 7679 Sets the container key of the data field to actually display by a basic 7680 layer. 7681 7682 The data field set with L{PixmapLayer.get_data_key}() is used to obtain 7683 values, it determines physical dimensions, etc. When a data field is set 7684 with this method, it is displayed instead of the actual data. 7685 7686 @param key: Container string key identifying the data field to actually display. I{(string)} 7687 @return: 7688 """ 7689 return None

7690 - def get_presentation_key( ):

7691 """ 7692 Gets the key identifying data field this pixmap layer actually displays. 7693 7694 See L{LayerBasic.set_presentation_key}() for details. 7695 7696 7697 @return: The string key, or B{C{NULL}} if it isn't set. 7698 7699 """ 7700 return None

7701 - def get_has_presentation( ):

7702 """ 7703 Tests whether a basic layer displays a presentation instead of the data. 7704 7705 7706 @return: B{C{True}} if the layer has a presentation, B{C{False}} it it displays the 7707 data. 7708 7709 """ 7710 return None

7711 - def set_min_max_key( prefix ):

7712 """ 7713 Sets basic layer fixed range minimum and maximum. 7714 7715 @param prefix: Prefix of keys identifying minimum and maximum values for fixed 7716 range, "/min" and "/max" is appended to it to get the individual 7717 minimum and maximum keys. I{(string)} 7718 @return: 7719 """ 7720 return None

7721 - def get_min_max_key( ):

7722 """ 7723 Gets prefix identifying fixed range minimum and maximum. 7724 7725 7726 @return: The prefix, or B{C{NULL}} if it isn't set. 7727 7728 """ 7729 return None

7730 - def set_range_type_key( key ):

7731 """ 7732 Sets the container key of the color range mapping type to use to visualize 7733 data. 7734 7735 @param key: Container string key identifying the range type to use. I{(string)} 7736 @return: 7737 """ 7738 return None

7739 - def get_range_type_key( ):

7740 """ 7741 Gets key identifying color range mapping type. 7742 7743 7744 @return: The string key, or B{C{NULL}} if it isn't set. 7745 7746 """ 7747 return None

7748 -class PlainTool:

7749 - def UNIMPLEMENTED_check_layer_type( name ):

7750 """ 7751 Checks for a required layer type. 7752 7753 If the layer exists, its B{C{GType}} is returned. If it does not exist, zero 7754 is returned and a warning message is added to the tool dialog. In addition, 7755 it sets B{C{init_failed}} to B{C{True}}. 7756 7757 Therefore, this function should be called early in tool instance 7758 initialization and it should not be called again once it fails. 7759 7760 7761 @param name: Layer type name (e.g. <literal>"LayerPoint"</literal>). I{(string)} 7762 @return: The type of the layer, or 0 on failure. 7763 7764 """ 7765 return None

7766 - def UNIMPLEMENTED_connect_selection( layer_type , bname ):

7767 """ 7768 Sets up a plain tool to automatically manage layer selection. 7769 7770 When B{C{layer_type}} is 0 and B{C{bname}} B{C{NULL}}, plain tool stops automatically 7771 managing selection (hopefully). 7772 7773 This method performs L{PlainTool.ensure_layer}() and 7774 L{PlainTool.set_selection_key}(), connecting to the selection and making 7775 sure the B{C{selection}} field always points to the correct selection object 7776 (or is B{C{NULL}}). 7777 7778 The B{C{selection_changed}} method of B{C{PlainToolClass}} is only invoked for a 7779 tool instance once this method was called to set up the selection tracking. 7780 7781 @param layer_type: Layer type. Use L{PlainTool.check_layer_type}() in tool 7782 instance initialization to check for layer types. I{(GType)} 7783 @param bname: Selection key base name, for example <literal>"line"</literal>. I{(string)} 7784 @return: 7785 """ 7786 return None

7787 - def UNIMPLEMENTED_ensure_layer( layer_type ):

7788 """ 7789 Makes sure a plain tool's layer is of the correct type. 7790 7791 This is a low-level function, normally you would use 7792 L{PlainTool.connect_selection}(). 7793 7794 @param layer_type: Layer type. Use L{PlainTool.check_layer_type}() in 7795 tool instance initialization to check for layer types. I{(GType)} 7796 @return: 7797 """ 7798 return None

7799 - def UNIMPLEMENTED_set_selection_key( bname ):

7800 """ 7801 Constructs selection key from data key and sets it on the vector layer. 7802 7803 This is a low-level function, normally you would use 7804 L{PlainTool.connect_selection}(). 7805 7806 7807 @param bname: Selection key base name, for example <literal>"line"</literal>. I{(string)} 7808 @return: The full key (as a layer-owned string). 7809 7810 """ 7811 return None

7812 - def UNIMPLEMENTED_add_clear_button( ):

7813 """ 7814 Adds a `Clear' button to a plain tool. 7815 7816 This button works with automatically managed selection (see 7817 L{PlainTool.connect_selection}()). If you want to manage selection 7818 yourself add the button with gtk_dialog_add_button(). 7819 7820 7821 @return: The button widget. 7822 7823 """ 7824 return None

7825 - def UNIMPLEMENTED_enable_object_deletion( treeview ):

7826 """ 7827 Enables deletion of selection objects by presssing Delete in a tree view 7828 diplaying them. 7829 7830 Since: 2.7 7831 7832 @param treeview: A tree view that displays selection objects in order, each row 7833 corresponding to one selection object. I{(GtkTreeView*)} 7834 @return: 7835 """ 7836 return None

7837 -class Resource:

7838 - def get_name( ):

7839 """ 7840 Returns resource name. 7841 7842 7843 @return: Name of B{C{resource}}. The string is owned by B{C{resource}} and must not 7844 be modfied or freed. 7845 7846 """ 7847 return None

7848 - def get_is_modifiable( ):

7849 """ 7850 Returns whether a resource is modifiable. 7851 7852 7853 @return: B{C{True}} if resource is modifiable, B{C{False}} if it's fixed (system) 7854 resource. 7855 7856 """ 7857 return None

7858 - def get_is_preferred( ):

7859 """ 7860 Returns whether a resource is preferred. 7861 7862 7863 @return: B{C{True}} if resource is preferred, B{C{False}} otherwise. 7864 7865 """ 7866 return None

7867 - def set_is_preferred( is_preferred ):

7868 """ 7869 Sets preferability of a resource. 7870 7871 @param is_preferred: B{C{True}} to make B{C{resource}} preferred, B{C{False}} to make it not 7872 preferred. I{(bool)} 7873 @return: 7874 """ 7875 return None

7876 - def use( ):

7877 """ 7878 Starts using a resource. 7879 7880 Call to this function is necessary to use a resource properly. 7881 It makes the resource to create any auxiliary structures that consume 7882 considerable amount of memory and perform other initialization to 7883 ready-to-use form. 7884 7885 When a resource is no longer used, it should be released with 7886 L{Resource.release}(). 7887 7888 In addition, it calls g_object_ref() on the resource. 7889 7890 Resources usually exist through almost whole program lifetime from 7891 B{C{GObject}} perspective, but from the viewpoint of use this method is the 7892 constructor and L{Resource.release}() is the destructor. 7893 7894 @return: 7895 """ 7896 return None

7897 - def release( ):

7898 """ 7899 Releases a resource. 7900 7901 When the number of resource uses drops to zero, it frees all auxiliary data 7902 and returns back to `latent' form. In addition, it calls g_object_unref() 7903 on it. See L{Resource.use}() for more. 7904 7905 @return: 7906 """ 7907 return None

7908 - def is_used( ):

7909 """ 7910 Tells whether a resource is currently in use. 7911 7912 See L{Resource.use}() for details. 7913 7914 7915 @return: B{C{True}} if resource is in use, B{C{False}} otherwise. 7916 7917 """ 7918 return None

7919 - def data_changed( ):

7920 """ 7921 Emits signal "data-changed" on a resource. 7922 7923 It can be called only on non-constant resources. The default handler 7924 sets B{C{is_modified}} flag on the resource. 7925 7926 Mostly useful in resource implementation. 7927 7928 @return: 7929 """ 7930 return None

7931 - def data_saved( ):

7932 """ 7933 Clears B{C{is_modified}} flag of a resource. 7934 7935 Since: 2.8 7936 7937 @return: 7938 """ 7939 return None

7940 - def build_filename( ):

7941 """ 7942 Builds file name a resource should be saved to. 7943 7944 If the resource has not been newly created, renamed, or system it was 7945 probably loaded from file of the same name. 7946 7947 7948 @return: Resource file name as a newly allocated string that must be freed 7949 by caller. 7950 7951 """ 7952 return None

7953 - def UNIMPLEMENTED_dump( ):

7954 """ 7955 Dumps a resource to a textual (human readable) form. 7956 7957 7958 @return: Textual resource representation. 7959 7960 """ 7961 return None

7962 -class NLFitPreset:

7963 - def UNIMPLEMENTED_get_value( x , params , fres ):

7964 """ 7965 Calculates preset function value in a single point with given parameters. 7966 7967 7968 @param preset: A NL fitter function preset. 7969 @param params: Preset parameter values. I{(const-gdouble*)} 7970 @param fres: Set to B{C{True}} if succeeds, B{C{False}} on failure. I{(gboolean*)} 7971 @return: The function value. 7972 7973 """ 7974 return None

7975 - def get_formula( ):

7976 """ 7977 Gets function formula of B{C{preset}} (with Pango markup). 7978 7979 7980 @return: The preset function formula. 7981 7982 """ 7983 return None

7984 - def get_nparams( ):

7985 """ 7986 Return the number of parameters of B{C{preset}}. 7987 7988 7989 @return: The number of function parameters. 7990 7991 """ 7992 return None

7993 - def get_param_name( param ):

7994 """ 7995 Gets the name of a fitting parameter of a fitter preset. 7996 7997 The name may contain Pango markup. 7998 7999 8000 @param param: A parameter number. I{(int)} 8001 @return: The name of parameter @param. 8002 8003 """ 8004 return None

8005 - def get_param_units( param , siunit_x , siunit_y ):

8006 """ 8007 Derives the SI unit of a fitting parameter from the units of abscissa and 8008 ordinate. 8009 8010 Since: 2.5 8011 8012 @param param: A parameter number. I{(int)} 8013 @param siunit_x: SI unit of abscissa. I{(L{SIUnit})} 8014 @param siunit_y: SI unit of ordinate. I{(L{SIUnit})} 8015 @return: A newly created B{C{SIUnit}} with the units of the parameter @param. 8016 If the units of @param are not representable as B{C{SIUnit}}, 8017 the result is unitless (i.e. it will be presented as a mere 8018 number). 8019 8020 8021 """ 8022 return None

8023 - def UNIMPLEMENTED_guess( n_dat , x , y , params , fres ):

8024 """ 8025 Performs initial parameter estimate for a NL fitter. 8026 8027 The initial estimate method depends on the function used. There is no 8028 absolute guarantee of quality, however if the data points approximately 8029 match the fitted function the fit will typically converge from the returned 8030 estimate. 8031 8032 The parameters are filled also on failure, though just with some neutral 8033 values that should not give raise to NaNs and infinities. 8034 8035 @param n_dat: The number of data points (number of items in B{C{x}} and B{C{y}}). I{(int)} 8036 @param x: Abscissa points. I{(const-gdouble*)} 8037 @param y: Ordinate points. I{(const-gdouble*)} 8038 @param params: The array to fill with estimated parameter values. It has to be 8039 at least L{gwy_nlfit_preset_get_nparams}() long. I{(gdouble*)} 8040 @param fres: Set to B{C{True}} if succeeds, B{C{False}} on failure. I{(gboolean*)} 8041 @return: 8042 """ 8043 return None

8044 - def UNIMPLEMENTED_fit( fitter , n_dat , x , y , params , err , fixed_param ):

8045 """ 8046 Performs a nonlinear fit with a preset. 8047 8048 See L{gwy_math_nlfit_fit_full}() for details. 8049 8050 8051 @param fitter: A Marquardt-Levenberg nonlinear fitter already initialized for 8052 B{C{preset}}'s function, or B{C{NULL}}. I{(NLFitter*)} 8053 @param n_dat: The number of data points (number of items in B{C{x}} and B{C{y}}). I{(int)} 8054 @param x: Abscissa points. I{(const-gdouble*)} 8055 @param y: Ordinate points. I{(const-gdouble*)} 8056 @param params: Initial parameter estimate (the number of parameters depends on 8057 the fitted preset and it can be obtained with 8058 L{gwy_nlfit_preset_get_nparams}()). I{(gdouble*)} 8059 @param err: Array to store parameter errros to, may be B{C{NULL}}. I{(gdouble*)} 8060 @param fixed_param: Which parameters should be treated as fixed (set 8061 corresponding element to B{C{True}} for them). May be B{C{NULL}} if 8062 all parameters are variable. I{(const-gboolean*)} 8063 @return: Either B{C{fitter}} itself, or a newly created fitter if it was B{C{NULL}}. 8064 8065 """ 8066 return None

8067 -class Gradient:

8068 - def get_color( x , color ):

8069 """ 8070 Computes the color at a given position of a color gradient. 8071 8072 @param x: Position in gradient, in range 0..1. I{(float)} 8073 @param color: Color to fill with interpolated color at position B{C{x}}. I{(L{RGBA})} 8074 @return: 8075 """ 8076 return None

8077 - def UNIMPLEMENTED_get_samples( nsamples ):

8078 """ 8079 Returns color gradient sampled to integers in B{C{GdkPixbuf}}-like scheme. 8080 8081 The returned samples are owned by B{C{gradient}} and must not be modified or 8082 freed. They are automatically updated when the gradient changes, although 8083 their number never changes. The returned pointer is valid only as long 8084 as the gradient used, indicated by L{Resource.use}(). 8085 8086 8087 @param nsamples: A location to store the number of samples (or B{C{NULL}}). I{(int)} 8088 @return: Sampled B{C{gradient}} as a sequence of B{C{GdkPixbuf}}-like RRGGBBAA 8089 quadruplets. 8090 8091 """ 8092 return None

8093 - def sample( nsamples , samples ):

8094 """ 8095 Samples a gradient to an array B{C{GdkPixbuf}}-like samples. 8096 8097 If B{C{samples}} is not B{C{NULL}}, it's resized to 4*B{C{nsamples}} bytes, otherwise a 8098 new buffer is allocated. 8099 8100 If you don't have a reason for specific sample size (and are not going 8101 to modify the samples or otherwise dislike the automatic resampling on 8102 gradient definition change), use L{Gradient.get_samples}() instead. 8103 This function does not need the gradient to be in use, though. 8104 8105 8106 @param nsamples: Required number of samples. I{(int)} 8107 @param samples: Pointer to array to be filled. I{(guchar*)} 8108 @return: Sampled B{C{gradient}} as a sequence of B{C{GdkPixbuf}}-like RRGGBBAA 8109 quadruplets. 8110 8111 """ 8112 return None

8113 - def sample_to_pixbuf( pixbuf ):

8114 """ 8115 Samples a color gradient to a provided pixbuf. 8116 8117 Unlike L{Gradient.sample}() which simply takes samples at equidistant 8118 points this method uses supersampling and thus it gives a bit better 8119 looking gradient presentation. 8120 8121 @param pixbuf: A pixbuf to sample gradient to (in horizontal direction). I{(GdkPixbuf*)} 8122 @return: 8123 """ 8124 return None

8125 - def get_npoints( ):

8126 """ 8127 Returns the number of points in a color gradient. 8128 8129 8130 @return: The number of points in B{C{gradient}}. 8131 8132 """ 8133 return None

8134 - def UNIMPLEMENTED_get_point( index_ ):

8135 """ 8136 Returns the point at given index of a color gradient. 8137 8138 8139 @param index_: Color point index in B{C{gradient}}. I{(int)} 8140 @return: Color point at B{C{index_}}. 8141 8142 """ 8143 return None

8144 - def set_point( index_ , point ):

8145 """ 8146 Sets a single color point in a color gradient. 8147 8148 It is an error to try to move points beyond its neighbours, or to move first 8149 (or last) point from 0 (or 1). 8150 8151 @param index_: Color point index in B{C{gradient}}. I{(int)} 8152 @param point: Color point to replace current point at B{C{index_}} with. I{(const-GradientPoint*)} 8153 @return: 8154 """ 8155 return None

8156 - def set_point_color( index_ , color ):

8157 """ 8158 Sets the color of a color gradient point without moving it. 8159 8160 @param index_: Color point index in B{C{gradient}}. I{(int)} 8161 @param color: Color to set the point to. I{(const-RGBA*)} 8162 @return: 8163 """ 8164 return None

8165 - def UNIMPLEMENTED_insert_point( index_ , point ):

8166 """ 8167 Inserts a point to a color gradient. 8168 8169 It is an error to try to position a outside its future neighbours, or to 8170 move the first (or last) point from 0 (or 1). 8171 8172 @param index_: Color point index in B{C{gradient}}. I{(int)} 8173 @param point: Color point to insert at B{C{index_}}. I{(const-GradientPoint*)} 8174 @return: 8175 """ 8176 return None

8177 - def UNIMPLEMENTED_insert_point_sorted( point ):

8178 """ 8179 Inserts a point into a color gradient based on its x position. 8180 8181 8182 @param point: Color point to insert. I{(const-GradientPoint*)} 8183 @return: The index B{C{point}} was inserted at. 8184 8185 """ 8186 return None

8187 - def delete_point( index_ ):

8188 """ 8189 Deletes a point at given index in a color gradient. 8190 8191 It is not possible to delete points in gradients with less than 3 points. 8192 First and last points should not be deleted unless there's another point 8193 with B{C{x}} = 0 or B{C{x}} = 1 present. 8194 8195 @param index_: Color point index in B{C{gradient}}. I{(int)} 8196 @return: 8197 """ 8198 return None

8199 - def reset( ):

8200 """ 8201 Resets a gradient to the default two-point gray scale state. 8202 8203 @return: 8204 """ 8205 return None

8206 - def UNIMPLEMENTED_get_points( npoints ):

8207 """ 8208 Returns the complete set of color points of a gradient. 8209 8210 8211 @param npoints: A location to store the number of color points (or B{C{NULL}}). I{(int)} 8212 @return: Complete set B{C{gradient}}'s color points. The returned array is 8213 owned by B{C{gradient}} and must not be modified or freed. 8214 8215 """ 8216 return None

8217 - def UNIMPLEMENTED_set_points( npoints , points ):

8218 """ 8219 Sets the complete color gradient definition to a given set of points. 8220 8221 The point positions should be ordered, and first point should start at 0.0, 8222 last end at 1.0. There should be no redundant points. 8223 8224 @param npoints: The length of B{C{points}}. I{(int)} 8225 @param points: Color points to set as new gradient definition. I{(const-GradientPoint*)} 8226 @return: 8227 """ 8228 return None

8229 - def set_from_samples( nsamples , samples , threshold ):

8230 """ 8231 Reconstructs a color gradient definition from sampled colors. 8232 8233 The result is usually approximate. 8234 8235 @param nsamples: Number of samples, it must be at least one. I{(int)} 8236 @param samples: Sampled color gradient in B{C{GdkPixbuf}}-like RRGGBBAA form. I{(string)} 8237 @param threshold: Maximum allowed difference (for color components in range 0..1). 8238 When negative, default value 1/80 suitable for most purposes 8239 is used. I{(float)} 8240 @return: 8241 """ 8242 return None

8243 -class GLMaterial:

8244 - def get_ambient( ):

8245 """ 8246 Gets the ambient reflectance of a GL material. 8247 8248 8249 @return: Ambient reflectance (owned by GL material, must not be modified 8250 nor freed). 8251 8252 """ 8253 return None

8254 - def set_ambient( ambient ):

8255 """ 8256 Sets the ambient reflectance of a GL material. 8257 8258 @param ambient: Ambient reflectance. I{(const-RGBA*)} 8259 @return: 8260 """ 8261 return None

8262 - def get_diffuse( ):

8263 """ 8264 Gets the diffuse reflectance of a GL material. 8265 8266 8267 @return: Diffuse reflectance (owned by GL material, must not be modified 8268 nor freed). 8269 8270 """ 8271 return None

8272 - def set_diffuse( diffuse ):

8273 """ 8274 Sets the diffuse reflectance of a GL material. 8275 8276 @param diffuse: Diffuse reflectance. I{(const-RGBA*)} 8277 @return: 8278 """ 8279 return None

8280 - def get_specular( ):

8281 """ 8282 Gets the specular reflectance of a GL material. 8283 8284 8285 @return: Specular reflectance (owned by GL material, must not be modified 8286 nor freed). 8287 8288 """ 8289 return None

8290 - def set_specular( specular ):

8291 """ 8292 Sets the specular reflectance of a GL material. 8293 8294 @param specular: Specular reflectance. I{(const-RGBA*)} 8295 @return: 8296 """ 8297 return None

8298 - def get_emission( ):

8299 """ 8300 Gets the emission component of a GL material. 8301 8302 8303 @return: Emission component (owned by GL material, must not be modified 8304 nor freed). 8305 8306 """ 8307 return None

8308 - def set_emission( emission ):

8309 """ 8310 Sets the emission component of a GL material. 8311 8312 @param emission: Emission component. I{(const-RGBA*)} 8313 @return: 8314 """ 8315 return None

8316 - def get_shininess( ):

8317 """ 8318 Gets the shininess value of a GL material. 8319 8320 8321 @return: The shininess value (in range 0..1, not 0..128). 8322 8323 """ 8324 return None

8325 - def set_shininess( shininess ):

8326 """ 8327 Sets the shininess value of a GL material. 8328 8329 @param shininess: Shinniness value (in range 0..1, not 0..128). I{(float)} 8330 @return: 8331 """ 8332 return None

8333 - def sample_to_pixbuf( pixbuf ):

8334 """ 8335 Samples GL material to a provided pixbuf. 8336 8337 @param pixbuf: A pixbuf to sample gl_material to (in horizontal direction). I{(GdkPixbuf*)} 8338 @return: 8339 """ 8340 return None

8341 - def reset( ):

8342 """ 8343 Resets a GL material to default values. 8344 8345 @return: 8346 """ 8347 return None

8348 -class CDLine:

8349 - def get_name( ):

8350 """ 8351 Return cdline name (its unique identifier). 8352 8353 8354 @return: The cdline name. 8355 8356 """ 8357 return None

8358 - def get_definition( ):

8359 """ 8360 Gets the name of the image file with critical dimension evaluator 8361 description. 8362 8363 8364 @return: The cdline function definition. 8365 8366 """ 8367 return None

8368 - def get_param_name( param ):

8369 """ 8370 Returns the name of a critical dimension evaluator parameter. 8371 8372 The name may contain Pango markup. 8373 8374 8375 @param param: A parameter number. I{(int)} 8376 @return: The name of parameter @param. 8377 8378 """ 8379 return None

8380 - def get_param_default( param ):

8381 """ 8382 Returns a constant default parameter value. 8383 8384 8385 @param param: A parameter number. I{(int)} 8386 @return: The default parameter value, unrelated to the actual data fitted. 8387 It is worthless. 8388 8389 """ 8390 return None

8391 - def get_param_units( param , siunit_x , siunit_y ):

8392 """ 8393 Derives the SI unit of a critical dimension parameter from the units of 8394 abscissa and ordinate. 8395 8396 Since: 2.5 8397 8398 @param param: A parameter number. I{(int)} 8399 @param siunit_x: SI unit of abscissa. I{(L{SIUnit})} 8400 @param siunit_y: SI unit of ordinate. I{(L{SIUnit})} 8401 @return: A newly created B{C{SIUnit}} with the units of the parameter @param. 8402 If the units of @param are not representable as B{C{SIUnit}}, 8403 the result is unitless (i.e. it will be presented as a mere 8404 number). 8405 8406 8407 """ 8408 return None

8409 - def get_nparams( ):

8410 """ 8411 Return the number of parameters of B{C{cdline}}. 8412 8413 8414 @return: The number of function parameters. 8415 8416 """ 8417 return None

8418 - def UNIMPLEMENTED_fit( n_dat , x , y , n_param , params , err , fixed_param , user_data ):

8419 """ 8420 Performs a critical dimension evaulation (fit), allowing user to pass uncertainties. 8421 8422 @param n_dat: The number of data points (number of items in B{C{x}} and B{C{y}}). I{(int)} 8423 @param x: Abscissa points. I{(const-gdouble*)} 8424 @param y: Ordinate points. I{(const-gdouble*)} 8425 @param params: Array to store fitted parameter values to. I{(gdouble*)} 8426 @param err: Array to store parameter errros to, may be B{C{NULL}}. I{(gdouble*)} 8427 @param cdata: Curve calibration data, may be B{C{NULL}}. 8428 @return: 8429 """ 8430 return None

8431 - def UNIMPLEMENTED_fit_with_caldata( n_dat , x , y , params , err , cdata ):

8432 return None

8433 - def UNIMPLEMENTED_get_value( x , params , fres ):

8434 """ 8435 Calculates critical dimension function value in a single point with given 8436 parameters. 8437 8438 8439 @param x: The point to compute value at. I{(float)} 8440 @param params: Evaluator parameter values. I{(const-gdouble*)} 8441 @param fres: Set to B{C{True}} if succeeds, B{C{False}} on failure. I{(gboolean*)} 8442 @return: The function value. 8443 8444 """ 8445 return None

8446 -class ResourceEditor:

8447 - def get_edited( ):

8448 """ 8449 Gets the currently edited resource. 8450 8451 It is an error to call this method when no resource is being edited. 8452 8453 8454 @return: The currently edited resource. 8455 8456 """ 8457 return None

8458 - def queue_commit( ):

8459 """ 8460 Queues commit of resource changes, marking the currently edited resource 8461 `dirty'. 8462 8463 Call this method in particular resource editor subclass whenever user 8464 changes some editor property. 8465 8466 To flush pending commit, call L{Resource.editor_commit}(). To immediately 8467 commit a change, call this method and then L{Resource.editor_commit}(). 8468 8469 @return: 8470 """ 8471 return None

8472 - def commit( ):

8473 """ 8474 Commits pending resource changes, if there are any. 8475 8476 It calls B{C{apply_changes}} method first (if it exists), then saves resource to 8477 disk. 8478 8479 Changes are always immediately committed (if there are any pending): before 8480 the editor is destroyed, when a resource stops being edited, before a 8481 resource is deleted, before a resource is renamed. When a resource is newly 8482 created, it is immediately created on disk too. 8483 8484 8485 @return: Always B{C{False}} (to be usable as B{C{GSourceFunc}}). 8486 8487 """ 8488 return None

8489 - def setup( ):

8490 """ 8491 Sets up particular resource editor. 8492 8493 Helper method only intended for resource editor implementation. 8494 To be called in particular resource initialization methods. 8495 8496 @return: 8497 """ 8498 return None

8499 -class Ruler:

8500 - def set_range( lower , upper , position , max_size ):

8501 """ 8502 Sets range and current value of a ruler. 8503 8504 @param lower: Lower limit of the ruler. I{(float)} 8505 @param upper: Upper limit of the ruler. I{(float)} 8506 @param position: Current position of the mark on the ruler. I{(float)} 8507 @param max_size: Maximum value used for calculating size of text labels. I{(float)} 8508 @return: 8509 """ 8510 return None

8511 - def draw_pos( ):

8512 """ 8513 Draws a position marker. 8514 8515 This method is intended primarily for subclass implementation. 8516 8517 @return: 8518 """ 8519 return None

8520 - def get_range( lower , upper , position , max_size ):

8521 """ 8522 Retrieves values indicating the range and current position of a B{C{Ruler}}. 8523 See L{Ruler.set_range}(). 8524 8525 @param lower: Location to store lower limit of the ruler, or B{C{NULL}} I{(float)} 8526 @param upper: Location to store upper limit of the ruler, or B{C{NULL}} I{(float)} 8527 @param position: Location to store the current position of the mark on the ruler, 8528 or B{C{NULL}} I{(float)} 8529 @param max_size: Location to store the maximum size of the ruler used when 8530 calculating the space to leave for the text, or B{C{NULL}}. I{(float)} 8531 @return: 8532 """ 8533 return None

8534 - def set_si_unit( units ):

8535 """ 8536 Sets the base units a ruler displays. 8537 8538 Setting units to B{C{NULL}} effectively disables them. 8539 8540 @param units: The base units this ruler should display. I{(L{SIUnit})} 8541 @return: 8542 """ 8543 return None

8544 - def get_si_unit( ):

8545 """ 8546 Returns the base units a ruler uses. 8547 8548 8549 @return: The units the rules uses. 8550 8551 """ 8552 return None

8553 - def get_units_placement( ):

8554 """ 8555 Gets current units placement of ruler B{C{ruler}}. 8556 8557 8558 @return: The units placement. 8559 8560 """ 8561 return None

8562 - def set_units_placement( placement ):

8563 """ 8564 Sets whether and where units should be placed on the ruler. 8565 8566 @param placement: Units placement specification. I{(UnitsPlacement)} 8567 @return: 8568 """ 8569 return None

8570 -class SIUnit:

8571 - def set_from_string( unit_string ):

8572 """ 8573 Sets string that represents unit. 8574 8575 It must be base unit with no prefixes (e. g. "m", "N", "A", etc.). 8576 8577 @param unit_string: Unit string to set B{C{siunit}} from (it can be B{C{NULL}} for an empty 8578 unit). I{(string)} 8579 @return: 8580 """ 8581 return None

8582 - def set_from_string_parse( unit_string , power10 ):

8583 """ 8584 Changes an SI unit according to string representation. 8585 8586 This is a more powerful version of L{SiUnit.set_from_string}(), please 8587 see L{SiUnit.new_parse}() for some discussion. 8588 8589 @param unit_string: Unit string to set B{C{siunit}} from (it can be B{C{NULL}} for an empty 8590 unit). I{(string)} 8591 @param power10: Where power of 10 should be stored (or B{C{NULL}}). I{(int)} 8592 @return: 8593 """ 8594 return None

8595 - def get_string( style ):

8596 """ 8597 Obtains string representing a SI unit. 8598 8599 8600 @param style: Unit format style. I{(SIUnitFormatStyle)} 8601 @return: A newly allocated string that represents the base unit (with no 8602 prefixes). 8603 8604 """ 8605 return None

8606 - def multiply( siunit2 , result ):

8607 """ 8608 Multiplies two SI units. 8609 8610 8611 @param siunit2: An SI unit. I{(L{SIUnit})} 8612 @param result: An SI unit to set to product of B{C{siunit1}} and B{C{siunit2}}. It is 8613 safe to pass one of B{C{siunit1}}, B{C{siunit2}}. It can be B{C{NULL}} 8614 too, a new SI unit is created then and returned. I{(L{SIUnit})} 8615 @return: When B{C{result}} is B{C{NULL}}, a newly created SI unit that has to be 8616 dereferenced when no longer used later. Otherwise B{C{result}} itself 8617 is simply returned, its reference count is NOT increased. 8618 8619 """ 8620 return None

8621 - def divide( siunit2 , result ):

8622 """ 8623 Divides two SI units. 8624 8625 8626 @param siunit2: An SI unit. I{(L{SIUnit})} 8627 @param result: An SI unit to set to quotient of B{C{siunit1}} and B{C{siunit2}}. It is 8628 safe to pass one of B{C{siunit1}}, B{C{siunit2}}. It can be B{C{NULL}} 8629 too, a new SI unit is created then and returned. I{(L{SIUnit})} 8630 @return: When B{C{result}} is B{C{NULL}}, a newly created SI unit that has to be 8631 dereferenced when no longer used later. Otherwise B{C{result}} itself 8632 is simply returned, its reference count is NOT increased. 8633 8634 """ 8635 return None

8636 - def power( power , result ):

8637 """ 8638 Computes a power of an SI unit. 8639 8640 8641 @param power: Power to raise B{C{siunit}} to. I{(int)} 8642 @param result: An SI unit to set to power of B{C{siunit}}. It is safe to pass 8643 B{C{siunit}} itself. It can be B{C{NULL}} too, a new SI unit is created 8644 then and returned. I{(L{SIUnit})} 8645 @return: When B{C{result}} is B{C{NULL}}, a newly created SI unit that has to be 8646 dereferenced when no longer used later. Otherwise B{C{result}} itself 8647 is simply returned, its reference count is NOT increased. 8648 8649 """ 8650 return None

8651 - def nth_root( ipower , result ):

8652 """ 8653 Calulates n-th root of an SI unit. 8654 8655 This operation fails if the result would have fractional powers that 8656 are not representable by B{C{SIUnit}}. 8657 8658 Since: 2.5 8659 8660 @param ipower: The root to take: 2 means a quadratic root, 3 means cubic root, 8661 etc. I{(int)} 8662 @param result: An SI unit to set to power of B{C{siunit}}. It is safe to pass 8663 B{C{siunit}} itself. It can be B{C{NULL}} too, a new SI unit is created 8664 then and returned. I{(L{SIUnit})} 8665 @return: On success: When B{C{result}} is B{C{NULL}}, a newly created SI unit that 8666 has to be dereferenced when no longer used later, otherwise 8667 B{C{result}} itself is simply returned, its reference count is NOT 8668 increased. On failure B{C{NULL}} is always returned. 8669 8670 8671 """ 8672 return None

8673 - def power_multiply( power1 , siunit2 , power2 , result ):

8674 """ 8675 Computes the product of two SI units raised to arbitrary powers. 8676 8677 This is the most complex SI unit arithmetic function. It can be easily 8678 chained when more than two units are to be multiplied. 8679 8680 Since: 2.4 8681 8682 @param power1: Power to raise B{C{siunit1}} to. I{(int)} 8683 @param siunit2: An SI unit. I{(L{SIUnit})} 8684 @param power2: Power to raise B{C{siunit2}} to. I{(int)} 8685 @param result: An SI unit to set to B{C{siunit1}}^B{C{power1}}*B{C{siunit2}}^B{C{power2}}. 8686 It is safe to pass B{C{siunit1}} or B{C{siunit2}}. It can be B{C{NULL}} too, 8687 a new SI unit is created then and returned. I{(L{SIUnit})} 8688 @return: When B{C{result}} is B{C{NULL}}, a newly created SI unit that has to be 8689 dereferenced when no longer used later. Otherwise B{C{result}} itself 8690 is simply returned, its reference count is NOT increased. 8691 8692 8693 """ 8694 return None

8695 - def equal( siunit2 ):

8696 """ 8697 Checks whether two SI units are equal. 8698 8699 8700 @param siunit2: Second unit. I{(L{SIUnit})} 8701 @return: B{C{True}} if units are equal. 8702 8703 """ 8704 return None

8705 - def UNIMPLEMENTED_get_format( style , value , format ):

8706 """ 8707 Finds a good format for representing a value. 8708 8709 The values should be then printed as value/B{C{format}}->magnitude 8710 [B{C{format}}->units] with B{C{format}}->precision decimal places. 8711 8712 8713 @param style: Unit format style. I{(SIUnitFormatStyle)} 8714 @param value: Value the format should be suitable for. I{(float)} 8715 @param format: A value format to set-up, may be B{C{NULL}}, a new value format is 8716 allocated then. I{(SIValueFormat*)} 8717 @return: The value format. If B{C{format}} was B{C{NULL}}, a newly allocated format 8718 is returned, otherwise (modified) B{C{format}} itself is returned. 8719 8720 """ 8721 return None

8722 - def UNIMPLEMENTED_get_format_for_power10( style , power10 , format ):

8723 """ 8724 Finds format for representing a specific power-of-10 multiple of a unit. 8725 8726 The values should be then printed as value/B{C{format}}->magnitude 8727 [B{C{format}}->units] with B{C{format}}->precision decimal places. 8728 8729 This function does not change the precision field of B{C{format}}. 8730 8731 8732 @param style: Unit format style. I{(SIUnitFormatStyle)} 8733 @param power10: Power of 10, in the same sense as L{SiUnit.new_parse}() 8734 returns it. I{(int)} 8735 @param format: A value format to set-up, may be B{C{NULL}}, a new value format is 8736 allocated then. I{(SIValueFormat*)} 8737 @return: The value format. If B{C{format}} was B{C{NULL}}, a newly allocated format 8738 is returned, otherwise (modified) B{C{format}} itself is returned. 8739 8740 """ 8741 return None

8742 - def UNIMPLEMENTED_get_format_with_resolution( style , maximum , resolution , format ):

8743 """ 8744 Finds a good format for representing a range of values with given resolution. 8745 8746 The values should be then printed as value/B{C{format}}->magnitude 8747 [B{C{format}}->units] with B{C{format}}->precision decimal places. 8748 8749 8750 @param style: Unit format style. I{(SIUnitFormatStyle)} 8751 @param maximum: The maximum value to be represented. I{(float)} 8752 @param resolution: The smallest step (approximately) that should make a visible 8753 difference in the representation. I{(float)} 8754 @param format: A value format to set-up, may be B{C{NULL}}, a new value format is 8755 allocated then. I{(SIValueFormat*)} 8756 @return: The value format. If B{C{format}} was B{C{NULL}}, a newly allocated format 8757 is returned, otherwise (modified) B{C{format}} itself is returned. 8758 8759 """ 8760 return None

8761 - def UNIMPLEMENTED_get_format_with_digits( style , maximum , sdigits , format ):

8762 """ 8763 Finds a good format for representing a values with given number of 8764 significant digits. 8765 8766 The values should be then printed as value/B{C{format}}->magnitude 8767 [B{C{format}}->units] with B{C{format}}->precision decimal places. 8768 8769 8770 @param style: Unit format style. I{(SIUnitFormatStyle)} 8771 @param maximum: The maximum value to be represented. I{(float)} 8772 @param sdigits: The number of significant digits the value should have. I{(int)} 8773 @param format: A value format to set-up, may be B{C{NULL}}, a new value format is 8774 allocated then. I{(SIValueFormat*)} 8775 @return: The value format. If B{C{format}} was B{C{NULL}}, a newly allocated format 8776 is returned, otherwise (modified) B{C{format}} itself is returned. 8777 8778 """ 8779 return None

8780 -class SciText:

8781 - def __init__( ):

8782 """ 8783 Creates a new scientific text entry. 8784 8785 8786 @return: A newly created scientific text entry. 8787 8788 """ 8789 return None

8790 - def get_text( ):

8791 """ 8792 Gets the text in a scientific text entry. 8793 8794 The text is already in UTF-8 with all entities converted. 8795 8796 8797 @return: The text as a newly allocated string. It should be freed when no 8798 longer used. 8799 8800 """ 8801 return None

8802 - def set_text( new_text ):

8803 """ 8804 Sets the text a scientific text widget displays. 8805 8806 It can contain both UTF-8 and entities. UTF-8 characters corresponding to 8807 known entities are converted to entities, other characters are left as they 8808 are. 8809 8810 @param new_text: The text to display. I{(string)} 8811 @return: 8812 """ 8813 return None

8814 - def get_has_preview( ):

8815 """ 8816 Tests the display of a preview in a scientific text entry. 8817 8818 8819 @return: B{C{True}} if there is a preview, B{C{False}} if preview is not shown. 8820 8821 """ 8822 return None

8823 - def set_has_preview( has_preview ):

8824 """ 8825 Sets the display of a preview in a scientific text entry. 8826 8827 @param has_preview: B{C{True}} to display a preview, B{C{False}} to disable it. I{(bool)} 8828 @return: 8829 """ 8830 return None

8831 - def get_entry( ):

8832 """ 8833 Gets the entry widget of a scientific text entry. 8834 8835 8836 @return: The entry widget, no reference is added. 8837 8838 """ 8839 return None

8840 -class Selection:

8841 - def get_object_size( ):

8842 """ 8843 Gets the number of coordinates that make up a one selection object. 8844 8845 8846 @return: The number of coordinates in one selection object. 8847 8848 """ 8849 return None

8850 - def clear( ):

8851 """ 8852 Clears a selection. 8853 8854 @return: 8855 """ 8856 return None

8857 - def get_object( i , data ):

8858 """ 8859 Gets one selection object. 8860 8861 8862 @param i: Index of object to get. I{(int)} 8863 @param data: Array to store selection object data to. Object data is an 8864 array of coordinates whose precise meaning is defined by particular 8865 selection types. I{(gdouble*)} 8866 @return: B{C{True}} if there was such an object and B{C{data}} was filled. 8867 8868 """ 8869 return None

8870 - def set_object( i , data ):

8871 """ 8872 Sets one selection object. 8873 8874 This method can be also used to append objects (if the maximum number is 8875 not exceeded). Since there cannot be holes in the object list, B{C{i}} must be 8876 then equal to either the number of selected objects or special value -1 8877 meaning append to end. 8878 8879 8880 @param i: Index of object to set. I{(int)} 8881 @param data: Object selection data. It's an array of coordinates whose precise 8882 meaning is defined by particular selection types. I{(const-gdouble*)} 8883 @return: The index of actually set object (useful namely when B{C{i}} is -1). 8884 8885 """ 8886 return None

8887 - def delete_object( i ):

8888 """ 8889 Deletes a one selection object. 8890 8891 Since there cannot be holes in the object list, the rest of selection 8892 objects is moved to close the gap. 8893 8894 @param i: Index of object to delete. I{(int)} 8895 @return: 8896 """ 8897 return None

8898 - def get_data( data ):

8899 """ 8900 Gets selection data. 8901 8902 8903 @param data: Array to store selection data to. Selection data is an 8904 array of coordinates whose precise meaning is defined by particular 8905 selection types. It may be B{C{NULL}}. I{(gdouble*)} 8906 @return: The number of selected objects. This is *not* the required size 8907 of B{C{data}}, which must be at least L{Selection.get_object_size}() 8908 times larger. 8909 8910 """ 8911 return None

8912 - def set_data( nselected , data ):

8913 """ 8914 Sets selection data. 8915 8916 @param nselected: The number of selected objects. I{(int)} 8917 @param data: Selection data, that is an array B{C{nselected}} * 8918 L{Selection.get_object_size}() long with selected object 8919 coordinates. I{(const-gdouble*)} 8920 @return: 8921 """ 8922 return None

8923 - def get_max_objects( ):

8924 """ 8925 Gets the maximum number of selected objects. 8926 8927 8928 @return: The maximum number of selected objects; 8929 8930 """ 8931 return None

8932 - def set_max_objects( max_objects ):

8933 """ 8934 Sets the maximum number of objects allowed to select. 8935 8936 When selection reaches this number of selected objects, it emits 8937 "finished" signal. 8938 8939 @param max_objects: The maximum number of objects allowed to select. Note 8940 particular selection types may allow only specific values. I{(int)} 8941 @return: 8942 """ 8943 return None

8944 - def is_full( ):

8945 """ 8946 Checks whether the maximum number of objects is selected. 8947 8948 8949 @return: B{C{True}} when the maximum possible number of objects is selected, 8950 B{C{False}} otherwise. 8951 8952 """ 8953 return None

8954 - def crop( xmin , ymin , xmax , ymax ):

8955 """ 8956 Limits objects in a selection to a rectangle. 8957 8958 Objects that are fully outside specified rectangle are removed. Objects 8959 partially outside may be removed or cut, depending on what makes sense for 8960 the specific selection type. If the selection class does not implement this 8961 method then all objects are removed. 8962 8963 Since: 2.16 8964 8965 @param xmin: Minimum x-coordinate. I{(float)} 8966 @param ymin: Minimum y-coordinate. I{(float)} 8967 @param xmax: Maximum x-coordinate. I{(float)} 8968 @param ymax: Maximum y-coordinate. I{(float)} 8969 @return: 8970 """ 8971 return None

8972 - def UNIMPLEMENTED_filter( filter , data ):

8973 """ 8974 Removes selection objects matching certain criteria. 8975 8976 Since: 2.16 8977 8978 @param filter: Function returning B{C{True}} for objects that should be kept, B{C{False}} 8979 for objects that should be removed. I{(SelectionFilterFunc)} 8980 @param data: User data passed to B{C{filter}}. I{(gpointer)} 8981 @return: 8982 """ 8983 return None

8984 - def changed( i ):

8985 """ 8986 Emits "changed" signal on a selection. 8987 8988 @param i: Index of object that changed. Use -1 when not applicable, e.g., when 8989 complete selection was changed, cleared, or truncated. I{(int)} 8990 @return: 8991 """ 8992 return None

8993 - def finished( ):

8994 """ 8995 Emits "finished" signal on a selection. 8996 8997 @return: 8998 """ 8999 return None

9000 - def get_data( ):

9001 """ 9002 Return list of selected points. 9003 9004 9005 @return: a list of selected data 9006 9007 """ 9008 return None

9009 -class SensitivityGroup:

9010 - def __init__( ):

9011 """ 9012 Creates a new flag-based widget sensitivity group. 9013 9014 9015 @return: The newly created sensitivity group. It starts with zero state. 9016 9017 """ 9018 return None

9019 - def add_widget( widget , mask ):

9020 """ 9021 Adds a widget to flag sensitivity group. 9022 9023 Widget sensitivity should not be set manually after the addition as the 9024 result is likely to be a fight over sensitivity setting. 9025 9026 The added widget takes a reference on B{C{sensgroup}}. So the group is not 9027 destroyed when they are any widgets in, generally, you can release your 9028 initial reference after adding widgets to the group. 9029 9030 @param widget: Widget to add to B{C{sensgroup}}. I{(L{gtk.Widget})} 9031 @param mask: Which flags the widget is sensitive to. See 9032 L{SensitivityGroup.set_state}() for details. I{(int)} 9033 @return: 9034 """ 9035 return None

9036 - def set_state( affected_mask , state ):

9037 """ 9038 Sets the state of a widget flag sensitivity group. 9039 9040 Widget sensitivity states are then updated accordingly. 9041 9042 More precisely, widget will be made sensitive when all bits in its B{C{mask}} are 9043 set in current B{C{sensgroup}} state, insensitive otherwise. This means when 9044 B{C{mask}} is zero, widget will be always sensitive. 9045 9046 @param affected_mask: Which bits in B{C{state}} to copy to B{C{sensgroup}} state. 9047 1's in B{C{affected_mask}} causes corresponding bits in 9048 B{C{sensgroup}} state to be set to the value of corresponding 9049 bit in B{C{state}}. 9050 0's in B{C{affected_mask}} cause corresponding state bits to be 9051 kept on their current value. I{(int)} 9052 @param state: The new state of B{C{sensgroup}} (masked with B{C{affected_mask}}). I{(int)} 9053 @return: 9054 """ 9055 return None

9056 - def get_state( ):

9057 """ 9058 Gets the current state of a widget flag sensitivity group. 9059 9060 9061 @return: The current state as set with L{SensitivityGroup.set_state}(). 9062 9063 """ 9064 return None

9065 - def release_widget( widget ):

9066 """ 9067 Removes a widget from flag sensitivity group. 9068 9069 @param widget: Widget to remove from B{C{sensgroup}}. I{(L{gtk.Widget})} 9070 @return: 9071 """ 9072 return None

9073 - def get_widget_mask( widget ):

9074 """ 9075 Gets sensitivity flags of a widget in a flag sensitivity group. 9076 9077 9078 @param widget: Widget to get flags of. I{(L{gtk.Widget})} 9079 @return: The mask as passed to L{SensitivityGroup.add_widget}() 9080 or L{SensitivityGroup.set_widget_mask}(). 9081 9082 """ 9083 return None

9084 - def set_widget_mask( widget , mask ):

9085 """ 9086 Sets the flag mask of a widget in a flag sensitivity group. 9087 9088 @param widget: Widget to set flags of. I{(L{gtk.Widget})} 9089 @param mask: Which flags the widget is sensitive to. See 9090 L{SensitivityGroup.set_state}() for details. I{(int)} 9091 @return: 9092 """ 9093 return None

9094 -class Shader:

9095 - def __init__( gradient ):

9096 """ 9097 Creates a new spherical shader. 9098 9099 The widget takes up all the space allocated for it. 9100 9101 9102 @return: The new shader as a B{C{GtkWidget}}. 9103 9104 """ 9105 return None

9106 - def get_theta( ):

9107 """ 9108 Returns the theta coordinate of a shader. 9109 9110 9111 @return: The theta coordinate, in radians. Theta coordinate is angle from 9112 sphere's north pole. 9113 9114 """ 9115 return None

9116 - def get_phi( ):

9117 """ 9118 Returns the phi coordinate of a shader. 9119 9120 9121 @return: The phi coordinate, in radians. Phi coordinate is orientation 9122 in horizontal plane, measured from x axis, counterclockwise. 9123 9124 """ 9125 return None

9126 - def set_theta( theta ):

9127 """ 9128 Sets the theta coordinate of a shader. 9129 9130 @param theta: The theta coordinate to set. See L{Shader.get_theta}() for 9131 description. I{(float)} 9132 @return: 9133 """ 9134 return None

9135 - def set_phi( phi ):

9136 """ 9137 Sets the phi coordinate of a shader. 9138 9139 @param phi: The phi coordinate to set. See L{Shader.get_phi}() for description. I{(float)} 9140 @return: 9141 """ 9142 return None

9143 - def set_angle( theta , phi ):

9144 """ 9145 Sets the spherical angle of a shader. 9146 9147 @param theta: The theta coordinate to set. See L{Shader.get_theta}() for 9148 description. I{(float)} 9149 @param phi: The phi coordinate to set. See L{Shader.get_phi}() for description. I{(float)} 9150 @return: 9151 """ 9152 return None

9153 - def get_gradient( ):

9154 """ 9155 Returns the name of color gradient a shader uses. 9156 9157 9158 @return: The gradient name. It must not be modified or freed. It may 9159 differ the name that was used on initialization or set with 9160 L{Shader.set_gradient}(), if the gradient didn't exist or 9161 was renamed meanwhile. 9162 9163 """ 9164 return None

9165 - def set_gradient( gradient ):

9166 """ 9167 Sets the gradient a shader uses. 9168 9169 @param gradient: Name of gradient B{C{shader}} should use. It should exist. I{(string)} 9170 @return: 9171 """ 9172 return None

9173 - def get_update_policy( ):

9174 """ 9175 Returns the update policy of a shader. 9176 9177 9178 @return: The update policy. 9179 9180 """ 9181 return None

9182 - def set_update_policy( update_policy ):

9183 """ 9184 Sets the update policy of a shader. 9185 9186 @param update_policy: The update policy B{C{shader}} should use. I{(GtkUpdateType)} 9187 @return: 9188 """ 9189 return None

9190 -class Spectra:

9191 - def __init__( ):

9192 """ 9193 Creates a new Spectra object containing zero spectra. 9194 9195 Since: 2.7 9196 9197 @return: A newly created spectra. 9198 9199 9200 """ 9201 return None

9202 - def new_alike( ):

9203 """ 9204 Creates a new Spectra object similar to an existing one, but containing zero 9205 spectra. 9206 9207 Use L{Spectra.duplicate}() if you want to copy a spectra object including 9208 the spectra in it. 9209 9210 Since: 2.7 9211 9212 @return: A newly created Spectra object. 9213 9214 9215 """ 9216 return None

9217 - def data_changed( ):

9218 """ 9219 Emits signal "data_changed" on a spectra object. 9220 9221 Since: 2.7 9222 9223 @return: 9224 """ 9225 return None

9226 - def get_si_unit_xy( ):

9227 """ 9228 Gets SI unit used for the location co-ordinates of spectra. 9229 9230 Since: 2.7 9231 9232 @return: SI unit corresponding to the the location co-ordinates of spectra 9233 object. Its reference count is not incremented. 9234 9235 9236 """ 9237 return None

9238 - def set_si_unit_xy( si_unit ):

9239 """ 9240 Sets the SI unit corresponding to the location co-ordinates of the spectra 9241 object. 9242 9243 It does not assume a reference on B{C{si_unit}}, instead it adds its own 9244 reference. 9245 9246 Since: 2.7 9247 9248 @param si_unit: SI unit to be set. I{(L{SIUnit})} 9249 @return: 9250 """ 9251 return None

9252 - def UNIMPLEMENTED_itoxy( i , x , y ):

9253 """ 9254 Gets the coordinates of one spectrum. 9255 9256 Since: 2.7 9257 9258 @param i: Index of a spectrum. I{(int)} 9259 @param x: Location to store the physical x coordinate of the spectrum. I{(gdouble*)} 9260 @param y: Location to store the physical x coordinate of the spectrum. I{(gdouble*)} 9261 @return: 9262 """ 9263 return None

9264 - def xytoi( x , y ):

9265 """ 9266 Finds the index of the spectrum closest to the location specified by 9267 the coordinates x and y. 9268 9269 Since: 2.7 9270 9271 @param x: The x coordinate of the location of the spectrum. I{(float)} 9272 @param y: The y coordinate of the location of the spectrum. I{(float)} 9273 @return: The index of the nearest spectrum. If there are no curves in the 9274 spectra, -1 is returned. 9275 9276 9277 """ 9278 return None

9279 - def setpos( i , x , y ):

9280 """ 9281 Sets the location coordinates of a spectrum. 9282 9283 Since: 2.7 9284 9285 @param i: The index of a spectrum. I{(int)} 9286 @param x: The new x coordinate of the location of the spectrum. I{(float)} 9287 @param y: The new y coordinate of the location of the spectrum. I{(float)} 9288 @return: 9289 """ 9290 return None

9291 - def get_n_spectra( ):

9292 """ 9293 Gets the number of spectra in a spectra object. 9294 9295 Since: 2.7 9296 9297 @return: The number of spectra. 9298 9299 9300 """ 9301 return None

9302 - def get_spectrum( i ):

9303 """ 9304 Gets a dataline that contains the spectrum at index i. 9305 9306 Since: 2.7 9307 9308 @param i: Index of a spectrum I{(int)} 9309 @return: A B{C{DataLine}} containing the spectrum, owned by B{C{spectra}}. 9310 9311 9312 """ 9313 return None

9314 - def set_spectrum( i , new_spectrum ):

9315 """ 9316 Replaces the ith spectrum in the spectra object with a the 9317 supplied spectrum, new_spectrum. It takes its own reference 9318 to the New_Spectrum dataline. 9319 9320 Since: 2.7 9321 9322 @param i: Index of a spectrum to replace I{(int)} 9323 @param new_spectrum: A B{C{DataLine}} Object containing the new spectrum. I{(L{DataLine})} 9324 @return: 9325 """ 9326 return None

9327 - def set_spectrum_selected( i , selected ):

9328 """ 9329 Sets selected state of a spectrum in a spectra object. 9330 9331 Since: 2.7 9332 9333 @param i: Index of a spectrum. I{(int)} 9334 @param selected: B{C{True}} to make the spectrum selected, B{C{False}} to deselect it. I{(bool)} 9335 @return: 9336 """ 9337 return None

9338 - def get_spectrum_selected( i ):

9339 """ 9340 Gets the selected state of a spectrum in a spectra object. 9341 9342 Since: 2.7 9343 9344 @param i: Index of a spectrum. I{(int)} 9345 @return: B{C{True}} if spectrum is selected. 9346 9347 9348 """ 9349 return None

9350 - def UNIMPLEMENTED_find_nearest( x , y , n , ilist ):

9351 """ 9352 Gets the list of the indices to spectra ordered by their distance from a 9353 given point. 9354 9355 List positions 9356 9357 Since: 2.7 9358 9359 @param x: Point x-coordinate. I{(float)} 9360 @param y: Point y-coordinate. I{(float)} 9361 @param n: Number of indices to find. Array B{C{ilist}} must have at least this 9362 number of items. I{(int)} 9363 @param ilist: Array to place the spectra indices to. They will be sorted by the 9364 distance from (B{C{x}}, B{C{y}}). Positions after the number of spectra 9365 in B{C{spectra}} will be left untouched. I{(guint*)} 9366 @return: 9367 """ 9368 return None

9369 - def add_spectrum( new_spectrum , x , y ):

9370 """ 9371 Appends a new_spectrum to the spectra collection with a position of x, y. 9372 L{Spectra.add} takes a refference to the supplied spectrum. 9373 9374 Since: 2.7 9375 9376 @param new_spectrum: A DataLine containing the spectrum to append. I{(L{DataLine})} 9377 @param x: The physical x coordinate of the location of the spectrum. I{(float)} 9378 @param y: The physical y coordinate of the location of the spectrum. I{(float)} 9379 @return: 9380 """ 9381 return None

9382 - def remove_spectrum( i ):

9383 return None

9384 - def get_title( ):

9385 """ 9386 Gets the title of spectra. 9387 9388 Since: 2.7 9389 9390 @return: A pointer to the title string (owned by the spectra object). 9391 9392 9393 """ 9394 return None

9395 - def set_title( title ):

9396 """ 9397 Sets the title of the spectra collection. 9398 9399 Since: 2.7 9400 9401 @param title: The new title string. I{(string)} 9402 @return: 9403 """ 9404 return None

9405 - def clear( ):

9406 """ 9407 Removes all spectra from the collection. 9408 9409 Since: 2.7 9410 9411 @return: 9412 """ 9413 return None

9414 -class Statusbar:

9415 - def __init__( ):

9416 """ 9417 Creates a new Gwyddion statusbar. 9418 9419 Gwyddion statusbar differs from B{C{GtkStatusbar}} only in one thing: the 9420 messages can contain Pango markup. 9421 9422 9423 @return: The newly created statusbar, as a B{C{GtkWidget}}. 9424 9425 """ 9426 return None

9427 - def set_markup( markup ):

9428 """ 9429 Sets the text to display in a status bar. 9430 9431 This method is intended for simple status bars that do not have stacks and 9432 do not need contexts. It does not mix with gtk_status_bar_push(). You can 9433 use either this simple interface or the full stacks-and-contexts API with 9434 B{C{Statusbar}}, but not both in the same status bar. 9435 9436 @param markup: Text message to display in the statusbar. It can contain Pango 9437 markup. I{(string)} 9438 @return: 9439 """ 9440 return None

9441 -class StringList:

9442 - def __init__( ):

9443 """ 9444 Creates a new string list. 9445 9446 9447 @return: A new empty string list. 9448 9449 """ 9450 return None

9451 - def append( string ):

9452 """ 9453 Appends a string to the end of a string list. 9454 9455 @param string: A string to add. I{(string)} 9456 @return: 9457 """ 9458 return None

9459 - def get_length( ):

9460 """ 9461 Gets the number of strings in a string list. 9462 9463 9464 @return: The number of strings in B{C{strlist}}. 9465 9466 """ 9467 return None

9468 - def get( i ):

9469 """ 9470 Gets a string from a string list by position. 9471 9472 9473 @param i: The position of string to get. I{(int)} 9474 @return: The string, owned by B{C{strlist}}. It is valid only until B{C{strlist}} 9475 changes. 9476 9477 """ 9478 return None

9479 -class VectorLayer:

9480 - def set_selection_key( key ):

9481 """ 9482 Sets the selection object to use by a vector layer. 9483 9484 @param key: Container string key identifying the selection object. I{(string)} 9485 @return: 9486 """ 9487 return None

9488 - def get_selection_key( ):

9489 """ 9490 Gets the key identifying selection this vector layer displays. 9491 9492 9493 @return: The string key, or B{C{NULL}} if it isn't set. 9494 9495 """ 9496 return None

9497 - def ensure_selection( ):

9498 """ 9499 Ensures a vector layer's selection exist in data container. 9500 9501 This method can be called only when layer is plugged into a data view and it 9502 has a selection key set. If the data container contains a selection under 9503 the specified key the selection is returned. If there is none, 9504 a selection of appropriate type is created and put to the container first. 9505 9506 Provided the above conditions are met this method is suitable for just 9507 obtaining the selection object a vector layer uses too. 9508 9509 9510 @return: The layer's selection (no reference is added). 9511 9512 """ 9513 return None

9514 - def get_focus( ):

9515 """ 9516 Gets focused object index. 9517 9518 9519 @return: Focued object index, or -1 if no object is focused. 9520 9521 """ 9522 return None

9523 - def set_focus( focus ):

9524 """ 9525 Focues on one selection object. 9526 9527 When a selection object is focused, it becomes the only one user can 9528 interact with. More precisely, "object-chosen" signal is emitted only 9529 for this object, and if the layer is editable only this object can be 9530 modified by the user. 9531 9532 9533 @param focus: Index of object to focus on, use -1 to unfocus (allow interaction 9534 with any object). I{(int)} 9535 @return: B{C{True}} if the object was focused, B{C{False}} on failure. Failure can 9536 be caused by user currently moving another object, wrong object 9537 index, or the feature being unimplemented in B{C{layer}}. 9538 9539 """ 9540 return None

9541 - def get_editable( ):

9542 """ 9543 Gets editability of a vector layer. 9544 9545 9546 @return: B{C{True}} if layer is edtiable, B{C{False}} if it is not editable. 9547 9548 """ 9549 return None

9550 - def set_editable( editable ):

9551 """ 9552 Sets a vector layer editability. 9553 9554 It is an error to attempt to set a layer non-editabile while it is being 9555 edited. 9556 9557 When a layer is set noneditable, the user cannot change the selection. 9558 However, "object-chosen" signal is still emitted. 9559 9560 @param editable: B{C{True}} to set layer editable, B{C{False}} to set it noneditable. I{(bool)} 9561 @return: 9562 """ 9563 return None

9564 - def UNIMPLEMENTED_draw( drawable , target ):

9565 """ 9566 Draws B{C{layer}} on given drawable (which should be a B{C{DataView}} window). 9567 9568 @param drawable: A drawable to draw on. I{(GdkDrawable*)} 9569 @param target: Rendering target. I{(RenderingTarget)} 9570 @return: 9571 """ 9572 return None

9573 - def UNIMPLEMENTED_button_press( event ):

9574 """ 9575 Sends a mouse button press event to a layer. 9576 9577 This method primarily exists for B{C{DataView}} to forward events to 9578 layers. You should rarely need it. 9579 9580 9581 @param event: A Gdk mouse button event. I{(GdkEventButton*)} 9582 @return: B{C{True}} if the event was handled. In practice, it returns B{C{False}}. 9583 9584 """ 9585 return None

9586 - def UNIMPLEMENTED_button_release( event ):

9587 """ 9588 Sends a mouse button release event to a layer. 9589 9590 This method primarily exists for B{C{DataView}} to forward events to 9591 layers. You should rarely need it. 9592 9593 9594 @param event: A Gdk mouse button event. I{(GdkEventButton*)} 9595 @return: B{C{True}} if the event was handled. In practice, it returns B{C{False}}. 9596 9597 """ 9598 return None

9599 - def UNIMPLEMENTED_motion_notify( event ):

9600 """ 9601 Sends a mouse pointer motion notification event to a layer. 9602 9603 This method primarily exists for B{C{DataView}} to forward events to 9604 layers. You should rarely need it. 9605 9606 9607 @param event: A Gdk mouse pointer motion notification event. It can be a hint. I{(GdkEventMotion*)} 9608 @return: B{C{True}} if the event was handled. In practice, it returns B{C{False}}. 9609 9610 """ 9611 return None

9612 - def UNIMPLEMENTED_key_press( event ):

9613 """ 9614 Sends a key press event to a layer. 9615 9616 This method primarily exists for B{C{DataView}} to forward events to 9617 layers. You should rarely need it. 9618 9619 9620 @param event: A Gdk key event. I{(GdkEventKey*)} 9621 @return: B{C{True}} if the event was handled. In practice, it returns B{C{False}}. 9622 9623 """ 9624 return None

9625 - def UNIMPLEMENTED_key_release( event ):

9626 """ 9627 Sends a key release event to a layer. 9628 9629 This method primarily exists for B{C{DataView}} to forward events to 9630 layers. You should rarely need it. 9631 9632 9633 @param event: A Gdk key event. I{(GdkEventKey*)} 9634 @return: B{C{True}} if the event was handled. In practice, it returns B{C{False}}. 9635 9636 """ 9637 return None

9638 - def object_chosen( id ):

9639 """ 9640 Emits "object-chosen" signal on a vector layer. 9641 9642 This function is primarily intended for layer implementations. 9643 9644 @param id: Index of the chosen object. I{(int)} 9645 @return: 9646 """ 9647 return None

9648 -def z_UNIMPLEMENTED_construct_rgi_names( pluginname ):

9649 return None

9650 -def z_UNIMPLEMENTED_create_user_plugin_dirs( ):

9651 return None

9652 -def z_UNIMPLEMENTED_dump_export_data_field( dfield , name , fh ):

9653 return None

9654 -def z_UNIMPLEMENTED_file_find_plugin( name , run ):

9655 return None

9656 -def z_UNIMPLEMENTED_file_pattern_specificity( pattern ):

9657 return None

9658 -def z_UNIMPLEMENTED_file_plugin_proxy_detect( filename , only_name , name ):

9659 return None

9660 -def z_UNIMPLEMENTED_file_plugin_proxy_export( data , filename , mode , error , name ):

9661 return None

9662 -def z_UNIMPLEMENTED_file_plugin_proxy_load( ):

9663 return None

9664 -def z_UNIMPLEMENTED_file_register_plugins( plugins , file , buffer ):

9665 return None

9666 -def z_UNIMPLEMENTED_find_plugin_executables( dir , list , level ):

9667 return None

9668 -def z_UNIMPLEMENTED_gwy_2d_cwt_wavelet_type_get_enum( ):

9669 """ 9670 Returns B{C{Enum}} for B{C{2DCWTWaveletType}} enum type. 9671 9672 9673 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 9674 9675 """ 9676 return None

9677 -def z_UNIMPLEMENTED_gwy_2d_cwt_wavelet_type_get_type( ):

9678 return None

9679 -def z_UNIMPLEMENTED_gwy_3d_label_get_type( ):

9680 return None

9681 -def z_UNIMPLEMENTED_gwy_3d_movement_get_type( ):

9682 return None

9683 -def z_UNIMPLEMENTED_gwy_3d_projection_get_type( ):

9684 return None

9685 -def z_UNIMPLEMENTED_gwy_3d_setup_get_type( ):

9686 return None

9687 -def gwy_3d_view_class_disable_axis_drawing( disable ):

9688 """ 9689 Globally disables drawing of 3D view axes. 9690 9691 If axis drawing is disabled, axes are never drawn. If it is not disabled, 9692 their rendering depends on the 3D view setup. 9693 9694 This function is a hack and exists to work around various GL implementations 9695 that crash on pixmap drawing operations. 9696 9697 Since: 2.14 9698 9699 @param disable: B{C{True}} to disable 3D view axes globally, B{C{False}} to enable them. I{(bool)} 9700 @return: 9701 """ 9702 return None

9703 -def z_UNIMPLEMENTED_gwy_3d_view_get_type( ):

9704 return None

9705 -def z_UNIMPLEMENTED_gwy_3d_view_label_get_type( ):

9706 return None

9707 -def z_UNIMPLEMENTED_gwy_3d_visualization_get_type( ):

9708 return None

9709 -def gwy_3d_window_class_get_tooltips( ):

9710 """ 9711 Gets the tooltips object used for adding tooltips to 3D window parts. 9712 9713 9714 @return: The B{C{GtkTooltips}} object. 9715 9716 """ 9717 return None

9718 -def gwy_3d_window_class_set_tooltips( tips ):

9719 """ 9720 Sets the tooltips object to use for adding tooltips to 3D window parts. 9721 9722 This is a class method. It affects only newly cerated 3D windows, existing 9723 3D windows will continue to use the tooltips they were constructed with. 9724 9725 If no class tooltips object is set before first B{C{3DWindow}} is created, 9726 the class instantiates one on its own. You can normally obtain it with 9727 L{gwy_3d_window_class_get_tooltips}() then. The class takes a reference on 9728 the tooltips in either case. 9729 9730 @param tips: Tooltips object B{C{3DWindow}}'s should use for setting tooltips. 9731 A B{C{NULL}} value disables tooltips altogether. I{(L{gtk.Tooltips})} 9732 @return: 9733 """ 9734 return None

9735 -def z_UNIMPLEMENTED_gwy_3d_window_get_type( ):

9736 return None

9737 -def gwy_app_add_main_accel_group( window ):

9738 """ 9739 Adds main (global) application accelerator group to a window. 9740 9741 This includes accelerators for terminating Gwyddion, opening files, etc. 9742 9743 @param window: A window. I{(L{gtk.Window})} 9744 @return: 9745 """ 9746 return None

9747 -def z_UNIMPLEMENTED_gwy_app_build_graph_menu( accel_group ):

9748 """ 9749 Constructs the application <guimenu>Graph</guimenu> menu. 9750 9751 The menu is created from graph functions registered by modules, 9752 therefore module registeration has to be performed first for this function 9753 to make sense. 9754 9755 9756 @param accel_group: Acceleration group to be associated with the menu. I{(L{gtk.AccelGroup})} 9757 @return: A newly ceated graph menu (a B{C{GtkMenu}}). 9758 9759 """ 9760 return None

9761 -def z_UNIMPLEMENTED_gwy_app_build_process_menu( accel_group ):

9762 """ 9763 Constructs the application <guimenu>Data Process</guimenu> menu. 9764 9765 The menu is created from data processing functions registered by modules, 9766 therefore module registeration has to be performed first for this function 9767 to make sense. 9768 9769 9770 @param accel_group: Acceleration group to be associated with the menu. I{(L{gtk.AccelGroup})} 9771 @return: A newly ceated data processing menu (a B{C{GtkMenu}}). 9772 9773 """ 9774 return None

9775 -def gwy_app_channel_remove_bad_data( dfield , mfield ):

9776 """ 9777 Replaces bad data points with some neutral values. 9778 9779 Since Gwyddion has no concept of bad data points, they are usually marked 9780 with a mask and replaced with some neutral values upon import, leaving the 9781 user to decide how to proceed further. This helper function performs such 9782 replacement, using the average of all good points as the neutral replacement 9783 value (at this moment). 9784 9785 Since: 2.14 9786 9787 @param dfield: A data field. The values of bad data points are ignored and might 9788 be even left uninitialized. I{(L{DataField})} 9789 @param mfield: A mask field containing 1.0 in place of good data points, 0.0 in 9790 place of bad points. It will be inverted to become the mask of 9791 bad points. I{(L{DataField})} 9792 @return: The number of bad data points replaced. If zero is returned, all 9793 points are good and there is no need for masking. 9794 9795 9796 """ 9797 return None

9798 -def gwy_app_channel_title_fall_back( data , id ):

9799 """ 9800 Adds a channel title based on data field units. 9801 9802 The guess is very simple, but probably better than `Unknown channel' in 9803 most cases. If there already is a title it is left intact, making use of 9804 this function as a fall-back easier. 9805 9806 Since: 2.3 9807 9808 @param data: A data container. I{(L{Container})} 9809 @param id: Data channel id. I{(int)} 9810 @return: B{C{True}} if the title was set (either by this function or before). 9811 9812 9813 """ 9814 return None

9815 -def gwy_app_data_browser_add( data ):

9816 """ 9817 Adds a data container to the application data browser. 9818 9819 The data browser takes a reference on the container so you can release 9820 yours. 9821 9822 @param data: A data container. I{(L{Container})} 9823 @return: 9824 """ 9825 return None

9826 -def z_UNIMPLEMENTED_gwy_app_data_browser_add_channel_watch( function , user_data ):

9827 """ 9828 Adds a watch function called when a channel changes. 9829 9830 The function is called whenever a channel is added, removed, its data 9831 changes or its metadata such as the title changes. If a channel is removed 9832 it may longer exist when the function is called. 9833 9834 9835 @param function: Function to call when a channel changes. I{(AppDataWatchFunc)} 9836 @param user_data: User data to pass to B{C{function}}. I{(gpointer)} 9837 @return: The id of the added watch func that can be used to remove it later 9838 using L{gwy_app_data_browser_remove_channel_watch}(). 9839 9840 Since 2.21. 9841 9842 """ 9843 return None

9844 -def gwy_app_data_browser_add_data_field( dfield , data , showit ):

9845 """ 9846 Adds a data field to a data container. 9847 9848 9849 @param dfield: A data field to add. I{(L{DataField})} 9850 @param data: A data container to add B{C{dfield}} to. 9851 It can be B{C{NULL}} to add the data field to current data container. I{(L{Container})} 9852 @param showit: B{C{True}} to display it immediately, B{C{False}} to just add it. I{(bool)} 9853 @return: The id of the data field in the container. 9854 9855 """ 9856 return None

9857 -def gwy_app_data_browser_add_graph_model( gmodel , data , showit ):

9858 """ 9859 Adds a graph model to a data container. 9860 9861 9862 @param gmodel: A graph model to add. I{(L{GraphModel})} 9863 @param data: A data container to add B{C{gmodel}} to. 9864 It can be B{C{NULL}} to add the graph model to current data container. I{(L{Container})} 9865 @param showit: B{C{True}} to display it immediately, B{C{False}} to just add it. I{(bool)} 9866 @return: The id of the graph model in the container. 9867 9868 """ 9869 return None

9870 -def gwy_app_data_browser_add_spectra( spectra , data , showit ):

9871 """ 9872 Adds a spectra object to a data container. 9873 9874 Since: 2.7 9875 9876 @param spectra: A spectra object to add. I{(L{Spectra})} 9877 @param data: A data container to add B{C{gmodel}} to. 9878 It can be B{C{NULL}} to add the spectra to current data container. I{(L{Container})} 9879 @param showit: B{C{True}} to display it immediately, B{C{False}} to just add it. I{(bool)} 9880 @return: The id of the spectra object in the container. 9881 9882 9883 """ 9884 return None

9885 -def gwy_app_data_browser_copy_channel( source , id , dest ):

9886 """ 9887 Copies a channel including all auxiliary data. 9888 9889 9890 @param source: Source container. I{(L{Container})} 9891 @param id: Data channel id. I{(int)} 9892 @param dest: Target container (may be identical to source). I{(L{Container})} 9893 @return: The id of the copy. 9894 9895 """ 9896 return None

9897 -def z_UNIMPLEMENTED_gwy_app_data_browser_find_data_by_title( data , titleglob ):

9898 """ 9899 Gets the list of all channels in a data container whose titles match the 9900 specified pattern. 9901 9902 Since: 2.21 9903 9904 @param data: A data container managed by the data-browser. I{(L{Container})} 9905 @param titleglob: Pattern, as used by B{C{GPatternSpec}}, to match the channel titles 9906 against. I{(string)} 9907 @return: A newly allocated array with channel ids, -1 terminated. 9908 9909 9910 """ 9911 return None

9912 -def z_UNIMPLEMENTED_gwy_app_data_browser_find_graphs_by_title( data , titleglob ):

9913 """ 9914 Gets the list of all graphs in a data container whose titles match the 9915 specified pattern. 9916 9917 Since: 2.21 9918 9919 @param data: A data container managed by the data-browser. I{(L{Container})} 9920 @param titleglob: Pattern, as used by B{C{GPatternSpec}}, to match the graph titles 9921 against. I{(string)} 9922 @return: A newly allocated array with graph ids, -1 terminated. 9923 9924 9925 """ 9926 return None

9927 -def z_UNIMPLEMENTED_gwy_app_data_browser_find_spectra_by_title( data , titleglob ):

9928 """ 9929 Gets the list of all spectra in a data container whose titles match the 9930 specified pattern. 9931 9932 Since: 2.21 9933 9934 @param data: A data container managed by the data-browser. I{(L{Container})} 9935 @param titleglob: Pattern, as used by B{C{GPatternSpec}}, to match the spectra titles 9936 against. I{(string)} 9937 @return: A newly allocated array with spectra ids, -1 terminated. 9938 9939 9940 """ 9941 return None

9942 -def gwy_app_data_browser_foreach( function , user_data ):

9943 """ 9944 Calls a function for each data container managed by data browser. 9945 9946 @param function: Function to run on each data container. I{(AppDataForeachFunc)} 9947 @param user_data: Data to pass as second argument of B{C{function}}. I{(gpointer)} 9948 @return: 9949 """ 9950 return None

9951 -def gwy_app_data_browser_get_containers( ):

9952 """ 9953 Get list of containers of current data browser. 9954 9955 9956 @return: list of containers L{Container} object 9957 9958 """ 9959 return None

9960 -def gwy_app_data_browser_get_current( obj_type ):

9961 """ 9962 Get current object of given type. 9963 9964 9965 @param obj_type: object type, expected values: C{B{APP_DATA_FIELD_ID, APP_GRAPH_MODEL_ID, 9966 APP_SPECTRA_ID, APP_DATA_FIELD_KEY, APP_MASK_FIELD_KEY, APP_SHOW_FIELD_KEY, 9967 APP_GRAPH_MODEL_KEY, APP_SPECTRA_KEY, APP_CONTAINER, APP_DATA_VIEW, APP_GRAPH, 9968 APP_DATA_FIELD, APP_MASK_FIELD, APP_SHOW_FIELD, APP_GRAPH_MODEL, APP_SPECTRA}} I{(some_type)} 9969 @return: reference to current object or None. 9970 9971 """ 9972 return None

9973 -def gwy_app_data_browser_get_data_ids( data ):

9974 """ 9975 Gets the list of all channels in a data container. 9976 The container must be known to the data browser. 9977 9978 9979 @param container: A data container. 9980 @return: A tuple with ids 9981 9982 """ 9983 return None

9984 -def gwy_app_data_browser_get_data_ids( data ):

9985 """ 9986 Gets the list of all channels in a data container. 9987 9988 The container must be known to the data browser. 9989 9990 9991 @param data: A data container. I{(L{Container})} 9992 @return: A newly allocated array with channel ids. 9993 9994 """ 9995 return None

9996 -def gwy_app_data_browser_get_data_ids( container ):

9997 """ 9998 Gets the list of all channels in a data container. 9999 The container must be known to the data browser. 10000 10001 10002 @param container: A data container. I{(some_type)} 10003 @return: A tuple with ids 10004 10005 """ 10006 return None

10007 -def z_UNIMPLEMENTED_gwy_app_data_browser_get_graph_ids( data ):

10008 """ 10009 Gets the list of all graphs in a data container. 10010 10011 10012 @param data: A data container managed by the data-browser. I{(L{Container})} 10013 @return: A newly allocated array with graph ids, -1 terminated. 10014 10015 """ 10016 return None

10017 -def gwy_app_data_browser_get_gui_enabled( ):

10018 """ 10019 Reports whether creation of windows by the data-browser is enabled. 10020 10021 Since: 2.21 10022 10023 @return: B{C{True}} if the data-browser is permitted to create windows, B{C{False}} 10024 if it is not. 10025 10026 10027 """ 10028 return None

10029 -def gwy_app_data_browser_get_keep_invisible( data ):

10030 """ 10031 Gets data browser behaviour for inaccessible data. 10032 10033 10034 @param data: A data container. I{(L{Container})} 10035 @return: See L{gwy_app_data_browser_set_keep_invisible}(). 10036 10037 """ 10038 return None

10039 -def z_UNIMPLEMENTED_gwy_app_data_browser_get_spectra_ids( data ):

10040 """ 10041 Gets the list of all spectra in a data container. 10042 10043 Since: 2.7 10044 10045 @param data: A data container managed by the data-browser. I{(L{Container})} 10046 @return: A newly allocated array with spectrum ids, -1 terminated. 10047 10048 10049 """ 10050 return None

10051 -def gwy_app_data_browser_merge( data ):

10052 """ 10053 Merges the data from a data container to the current one. 10054 10055 Since: 2.7 10056 10057 @param data: A data container, not managed by the data browser. I{(L{Container})} 10058 @return: 10059 """ 10060 return None

10061 -def gwy_app_data_browser_remove( data ):

10062 """ 10063 Removed a data container from the application data browser. 10064 10065 @param data: A data container. I{(L{Container})} 10066 @return: 10067 """ 10068 return None

10069 -def gwy_app_data_browser_remove_channel_watch( id ):

10070 """ 10071 Removes a channel watch function. 10072 10073 Since: 2.21 10074 10075 @param id: Watch function id, as returned by 10076 L{gwy_app_data_browser_add_channel_watch}(). I{(gulong)} 10077 @return: 10078 """ 10079 return None

10080 -def gwy_app_data_browser_reset_visibility( data , reset_type ):

10081 """ 10082 Resets visibility of all data objects in a container. 10083 10084 10085 @param data: A data container. I{(L{Container})} 10086 @param reset_type: Type of visibility reset. I{(VisibilityResetType)} 10087 @return: B{C{True}} if anything is visible after the reset. 10088 10089 """ 10090 return None

10091 -def gwy_app_data_browser_restore( ):

10092 """ 10093 Restores the data browser window. 10094 10095 The data browser window is always created (if it does not exist). 10096 If it should be visible according to settings, is shown at the saved 10097 position. Otherwise it is kept hidden until L{gwy_app_data_browser_show}(). 10098 10099 @return: 10100 """ 10101 return None

10102 -def gwy_app_data_browser_select_data_field( data , id ):

10103 """ 10104 Makes a data field (channel) current in the data browser. 10105 10106 @param data: The container to select. I{(L{Container})} 10107 @param id: Number (id) of the data field in B{C{data}} to select. I{(int)} 10108 @return: 10109 """ 10110 return None

10111 -def gwy_app_data_browser_select_data_view( data_view ):

10112 """ 10113 Switches application data browser to display container of B{C{data_view}}'s data 10114 and selects B{C{data_view}}'s data in the channel list. 10115 10116 @param data_view: A data view widget. I{(L{DataView})} 10117 @return: 10118 """ 10119 return None

10120 -def gwy_app_data_browser_select_graph( graph ):

10121 """ 10122 Switches application data browser to display container of B{C{graph}}'s data 10123 and selects B{C{graph}}'s data in the graph list. 10124 10125 @param graph: A graph widget. I{(L{Graph})} 10126 @return: 10127 """ 10128 return None

10129 -def gwy_app_data_browser_select_graph_model( data , id ):

10130 """ 10131 Makes a graph model (channel) current in the data browser. 10132 10133 @param data: The container to select. I{(L{Container})} 10134 @param id: Number (id) of the graph model in B{C{data}} to select. I{(int)} 10135 @return: 10136 """ 10137 return None

10138 -def gwy_app_data_browser_select_spectra( spectra ):

10139 """ 10140 Switches application data browser to display container of B{C{spectra}}'s data 10141 and selects B{C{spectra}}'s data in the graph list. 10142 10143 However, it is not actually supposed to work with spectra from a different 10144 container than those of the currently active channel, so do not try that 10145 for now. 10146 10147 Since: 2.7 10148 10149 @param spectra: A spectra object. I{(L{Spectra})} 10150 @return: 10151 """ 10152 return None

10153 -def gwy_app_data_browser_set_gui_enabled( setting ):

10154 """ 10155 Globally enables or disables creation of widgets by the data-browser. 10156 10157 By default, the data-browser creates windows for data objects automatically, 10158 for instance when reconstructing view of a loaded file, after a module 10159 function creates a new channel or graph or when it is explicitly asked so 10160 by L{gwy_app_data_browser_show_3d}(). Non-GUI applications that run module 10161 functions usually wish to disable GUI. 10162 10163 If GUI is disabled the data browser never creates windows showing data 10164 objects and also L{gwy_app_data_browser_show}() becomes no-op. 10165 10166 Disabling GUI after widgets have been already created is a bad idea. 10167 Hence you should do so before loading files or calling module functions. 10168 10169 Since: 2.21 10170 10171 @param setting: B{C{True}} to enable creation of widgets by the data-browser, 10172 B{C{False}} to disable it. I{(bool)} 10173 @return: 10174 """ 10175 return None

10176 -def gwy_app_data_browser_set_keep_invisible( data , keep_invisible ):

10177 """ 10178 Sets data browser behaviour for inaccessible data. 10179 10180 Normally, when all visual objects belonging to a file are closed the 10181 container is removed from the data browser and dereferenced, leading to 10182 its finalization. By setting B{C{keep_invisible}} to B{C{True}} the container can be 10183 made to sit in the browser indefinitely. 10184 10185 @param data: A data container. I{(L{Container})} 10186 @param keep_invisible: B{C{True}} to retain B{C{data}} in the browser even when it becomes 10187 inaccessible, B{C{False}} to dispose of it. I{(bool)} 10188 @return: 10189 """ 10190 return None

10191 -def gwy_app_data_browser_show( ):

10192 """ 10193 Shows the data browser window. 10194 10195 If the window does not exist, it is created. 10196 10197 @return: 10198 """ 10199 return None

10200 -def gwy_app_data_browser_show_3d( data , id ):

10201 """ 10202 Shows a 3D window displaying a channel. 10203 10204 If a 3D window of the specified channel already exists, it is just presented 10205 to the user. If it does not exist, it is created. 10206 10207 The caller must ensure 3D display is available, for example by checking 10208 L{gwy_app_gl_is_ok}(). 10209 10210 @param data: A data container. I{(L{Container})} 10211 @param id: Channel id. I{(int)} 10212 @return: 10213 """ 10214 return None

10215 -def gwy_app_data_browser_shut_down( ):

10216 """ 10217 Releases data browser resources and saves its state. 10218 10219 @return: 10220 """ 10221 return None

10222 -def gwy_app_data_clear_selections( data , id ):

10223 """ 10224 Clears all selections associated with a data channel. 10225 10226 This is the preferred selection handling after changes in data geometry 10227 as they have generally unpredictable effects on selections. Selection 10228 should not be removed because this is likely to make the current tool stop 10229 working. 10230 10231 @param data: A data container. I{(L{Container})} 10232 @param id: Data channel id. I{(int)} 10233 @return: 10234 """ 10235 return None

10236 -def gwy_app_data_view_change_mask_color( data_view ):

10237 """ 10238 Runs mask color selector on a data view. 10239 10240 This is a convenience function to run L{gwy_color_selector_for_mask}(), 10241 possibly taking the initial color from settings. 10242 10243 @param data_view: A data view (of application's data window). It must have a 10244 mask. I{(L{DataView})} 10245 @return: 10246 """ 10247 return None

10248 -def gwy_app_file_confirm_overwrite( chooser ):

10249 """ 10250 Asks for file overwrite for a file save chooser. 10251 10252 10253 @param chooser: A file chooser for save action. I{(L{gtk.Widget})} 10254 @return: B{C{True}} if it is OK to overwrite the file, B{C{False}} when user cancelled 10255 it or there was other problem. 10256 10257 """ 10258 return None

10259 -def gwy_app_file_load( filename_utf8 , filename_sys , name ):

10260 """ 10261 Load specified file 10262 10263 10264 @param filename: Filename of file to open 10265 @return: A main Container of opened file 10266 10267 """ 10268 return None

10269 -def gwy_app_file_load( filename ):

10270 """ 10271 Load specified file 10272 10273 10274 @param filename: Filename of file to open I{(some_type)} 10275 @return: A main Container of opened file 10276 10277 """ 10278 return None

10279 -def gwy_app_file_merge( ):

10280 """ 10281 Merges a user-selected file (very high-level app function). 10282 10283 Since: 2.7 10284 10285 @return: 10286 """ 10287 return None

10288 -def gwy_app_file_open( ):

10289 """ 10290 Opens a user-selected file (very high-level app function). 10291 10292 @return: 10293 """ 10294 return None

10295 -def gwy_app_file_save( ):

10296 """ 10297 Saves current data to a file (very high-level app function). 10298 10299 May fall back to L{gwy_app_file_save_as}() when current data has no file name 10300 associated with it, or the format it was loaded from is not saveable. 10301 10302 @return: 10303 """ 10304 return None

10305 -def gwy_app_file_save_as( ):

10306 """ 10307 Saves current data to a user-selected file (very high-level app function). 10308 10309 @return: 10310 """ 10311 return None

10312 -def gwy_app_file_write( data , filename_utf8 , filename_sys , name ):

10313 """ 10314 Writes container to a file (a high-level function). 10315 10316 At least one of B{C{filename_utf8}}, B{C{filename_sys}} must be non-B{C{NULL}}. 10317 10318 The file is saved in interactive mode, modules can ask for user input. 10319 If the write fails, an error dialog is presented. 10320 10321 10322 @param data: Data to write. I{(L{Container})} 10323 @param filename_utf8: Name of file to write data to, in UTF-8. I{(string)} 10324 @param filename_sys: Name of file to write data to, in GLib encoding. I{(string)} 10325 @param name: File type to open file as, but normally B{C{NULL}} to automatically detect 10326 from file name. I{(string)} 10327 @return: B{C{True}} on success. 10328 10329 """ 10330 return None

10331 -def gwy_app_find_window_for_channel( data , id ):

10332 """ 10333 Finds the window displaying a data channel. 10334 10335 10336 @param data: A data container to find window for. I{(L{Container})} 10337 @param id: Data channel id. It can be -1 to find any data window displaying 10338 a channel from B{C{data}}. I{(int)} 10339 @return: The window if found, B{C{NULL}} if no data window displays the 10340 requested channel. 10341 10342 """ 10343 return None

10344 -def gwy_app_get_channel_thumbnail( data , id , max_width , max_height ):

10345 """ 10346 Creates a channel thumbnail. 10347 10348 10349 @param data: A data container. I{(L{Container})} 10350 @param id: Data channel id. I{(int)} 10351 @param max_width: Maximum width of the created pixbuf, it must be at least 2. I{(int)} 10352 @param max_height: Maximum height of the created pixbuf, it must be at least 2. I{(int)} 10353 @return: A newly created pixbuf with channel thumbnail. It keeps the aspect 10354 ratio of the data field while not exceeding B{C{max_width}} and 10355 B{C{max_height}}. 10356 10357 """ 10358 return None

10359 -def gwy_app_get_current_directory( ):

10360 """ 10361 Returns what the app uses as `current directory'. 10362 10363 Warning: This function is probably temporary. 10364 10365 10366 @return: A string in GLib file name encoding that should not be modified 10367 neither freed, valid only until next call to 10368 L{gwy_app_set_current_directory}(). It ends with a 10369 B{C{G_DIR_SEPARATOR_S}}. 10370 10371 """ 10372 return None

10373 -def gwy_app_get_data_field_title( data , id ):

10374 """ 10375 Gets a data channel title. 10376 10377 This function should return a reasoanble title for untitled channels, 10378 channels with old titles, channels with and without a file, etc. 10379 10380 10381 @param data: A data container. I{(L{Container})} 10382 @param id: Data channel id. I{(int)} 10383 @return: The channel title as a newly allocated string. 10384 10385 """ 10386 return None

10387 -def gwy_app_get_data_key_for_id( id ):

10388 """ 10389 Calculates data field quark identifier from its id. 10390 10391 10392 @param id: Data number in container. I{(int)} 10393 @return: The quark key identifying mask number B{C{id}}. 10394 10395 """ 10396 return None

10397 -def gwy_app_get_graph_key_for_id( id ):

10398 """ 10399 Calculates graph model quark identifier from its id. 10400 10401 Since: 2.7 10402 10403 @param id: Graph number in container. I{(int)} 10404 @return: The quark key identifying graph model number B{C{id}}. 10405 10406 10407 """ 10408 return None

10409 -def gwy_app_get_mask_key_for_id( id ):

10410 """ 10411 Calculates mask field quark identifier from its id. 10412 10413 10414 @param id: Data number in container. I{(int)} 10415 @return: The quark key identifying mask number B{C{id}}. 10416 10417 """ 10418 return None

10419 -def gwy_app_get_show_key_for_id( id ):

10420 """ 10421 Calculates presentation field quark identifier from its id. 10422 10423 10424 @param id: Data number in container. I{(int)} 10425 @return: The quark key identifying presentation number B{C{id}}. 10426 10427 """ 10428 return None

10429 -def gwy_app_get_spectra_key_for_id( id ):

10430 """ 10431 Calculates spectra quark identifier from its id. 10432 10433 Since: 2.7 10434 10435 @param id: Spectra number in container. I{(int)} 10436 @return: The quark key identifying spectra number B{C{id}}. 10437 10438 10439 """ 10440 return None

10441 -def gwy_app_get_tooltips( ):

10442 """ 10443 Gets the application-wide tooltips instance. 10444 10445 10446 @return: The global tooltips instance. No reference is added, you can 10447 add yours, but the returned object will exist to the end of program 10448 anyway. 10449 10450 """ 10451 return None

10452 -def z_UNIMPLEMENTED_gwy_app_gl_init( argc , argv ):

10453 """ 10454 Checks for working OpenGL and initializes it. 10455 10456 When OpenGL support is not compiled in, this function does not do anything. 10457 When OpenGL is supported, it calls gtk_gl_init_check() and 10458 L{gwy_widgets_gl_init}() (if the former succeeeds). 10459 10460 10461 @param argc: Address of the argc parameter of main(). Passed to 10462 gtk_gl_init_check(). I{(int*)} 10463 @param argv: Address of the argv parameter of main(). Passed to 10464 gtk_gl_init_check(). I{(char***)} 10465 @return: B{C{True}} if OpenGL initialization succeeeded. 10466 10467 """ 10468 return None

10469 -def gwy_app_gl_is_ok( ):

10470 """ 10471 Returns OpenGL availability. 10472 10473 10474 @return: The return value is the same as the return value of 10475 L{gwy_app_gl_init}() which needs to be called prior to this function 10476 (until then, the return value is always B{C{False}}). 10477 10478 """ 10479 return None

10480 -def gwy_app_gl_material_editor( ):

10481 """ 10482 Creates or presents OpenGL material editor. 10483 10484 Material editor is singleton, therefore if it doesn't exist, this function 10485 creates and displays it. If it already exists, it simply calls 10486 gtk_window_present() on the existing instance. It exists until it's closed 10487 by user. 10488 10489 @return: 10490 """ 10491 return None

10492 -def gwy_app_gradient_editor( ):

10493 """ 10494 Creates or presents color gradient editor. 10495 10496 Gradient editor is singleton, therefore if it doesn't exist, this function 10497 creates and displays it. If it already exists, it simply calls 10498 gtk_window_present() on the existing instance. It exists until it's closed 10499 by user. 10500 10501 @return: 10502 """ 10503 return None

10504 -def gwy_app_init_i18n( ):

10505 """ 10506 Initializes internationalization. 10507 10508 Normally not needed to call explicitly. 10509 10510 @return: 10511 """ 10512 return None

10513 -def gwy_app_init_widget_styles( ):

10514 """ 10515 Sets up style properties for special Gwyddion widgets. 10516 10517 Normally not needed to call explicitly. 10518 10519 @return: 10520 """ 10521 return None

10522 -def gwy_app_main_window_get( ):

10523 """ 10524 Returns Gwyddion main application window (toolbox). 10525 10526 10527 @return: The Gwyddion toolbox. 10528 10529 """ 10530 return None

10531 -def gwy_app_menu_recent_files_get( ):

10532 """ 10533 Gets the application recent files menu. 10534 10535 The menu is initially empty and can be updated 10536 with L{gwy_app_menu_recent_files_update}(). This function is essentially 10537 useful only for toolbox construction. 10538 10539 10540 @return: The recent files menu (a B{C{GtkMenu}}). 10541 10542 """ 10543 return None

10544 -def z_UNIMPLEMENTED_gwy_app_menu_recent_files_update( recent_files ):

10545 """ 10546 Updates recent file menu. 10547 10548 If the list of files is longer than the maximum number of recent file menu 10549 items, only the maximum number is shown. 10550 10551 @param recent_files: A list of recent file names, in UTF-8. I{(GList*)} 10552 @return: 10553 """ 10554 return None

10555 -def z_UNIMPLEMENTED_gwy_app_process_func_get_use( ):

10556 return None

10557 -def gwy_app_process_func_save_use( ):

10558 """ 10559 Saves application data processing function statistics. 10560 10561 @return: 10562 """ 10563 return None

10564 -def gwy_app_process_menu_add_run_last( menu ):

10565 """ 10566 Adds <guimenuitem>Re-show Last</guimenuitem> and 10567 <guimenuitem>Repeat Last</guimenuitem> items to application data process 10568 menu. 10569 10570 This function is essentially useful only for toolbox construction. 10571 10572 @param menu: Menu created with L{gwy_app_build_process_menu}(). I{(L{gtk.Widget})} 10573 @return: 10574 """ 10575 return None

10576 -def gwy_app_quit( ):

10577 """ 10578 Quits the application. 10579 10580 This function may present a confirmation dialog to the user and it may 10581 let the application to continue running. If it quits the application, 10582 it performs some shutdown actions and then quits the Gtk+ main loop with 10583 gtk_main_quit(). 10584 10585 10586 @return: Always B{C{True}} to be usable as an event handler. However, if the 10587 application is actually terminated, this function does not return. 10588 10589 """ 10590 return None

10591 -def gwy_app_recent_file_get_thumbnail( filename_utf8 ):

10592 """ 10593 Gets thumbnail of a recently open file. 10594 10595 10596 @param filename_utf8: Name of a recent file, in UTF-8 encoding. I{(string)} 10597 @return: The thumbnail as a new pixbuf or a pixbuf with a new reference. 10598 The caller must unreference it but not modify it. If not 10599 thumbnail can not be obtained, a fully transparent pixbuf is 10600 returned. 10601 10602 """ 10603 return None

10604 -def gwy_app_recent_file_list_free( ):

10605 """ 10606 Frees all memory taken by recent file list. 10607 10608 Should not be called while the recent file menu still exists. 10609 10610 @return: 10611 """ 10612 return None

10613 -def gwy_app_recent_file_list_load( filename ):

10614 """ 10615 Loads list of recently open files from B{C{filename}}. 10616 10617 Cannot be called more than once (at least not without doing 10618 L{gwy_app_recent_file_list_free}() first). Must be called before any other 10619 document history function can be used, even if on a nonexistent file: 10620 use B{C{NULL}} as B{C{filename}} in that case. 10621 10622 10623 @param filename: Name of file containing list of recently open files. I{(string)} 10624 @return: B{C{True}} if the file was read successfully, B{C{False}} otherwise. 10625 10626 """ 10627 return None

10628 -def gwy_app_recent_file_list_save( filename ):

10629 """ 10630 Saves list of recently open files to B{C{filename}}. 10631 10632 10633 @param filename: Name of file to save the list of recently open files to. I{(string)} 10634 @return: B{C{True}} if the file was written successfully, B{C{False}} otherwise. 10635 10636 """ 10637 return None

10638 -def gwy_app_recent_file_list_update( data , filename_utf8 , filename_sys , hint ):

10639 """ 10640 Moves B{C{filename_utf8}} to the first position in document history, possibly 10641 adding it if not present yet. 10642 10643 At least one of B{C{filename_utf8}}, B{C{filename_sys}} should be set. 10644 10645 @param data: A data container corresponding to the file. I{(L{Container})} 10646 @param filename_utf8: A recent file to insert or move to the first position in 10647 document history, in UTF-8. I{(string)} 10648 @param filename_sys: A recent file to insert or move to the first position in 10649 document history, in GLib encoding. I{(string)} 10650 @param hint: Preferred channel id to use for thumbnail, pass 0 if no channel 10651 is specificaly preferred. I{(int)} 10652 @return: 10653 """ 10654 return None

10655 -def gwy_app_restore_window_position( window , prefix , grow_only ):

10656 """ 10657 Restores a window position and/or size from settings. 10658 10659 Unlike L{gwy_app_save_window_position}(), this function has no B{C{position}} and 10660 B{C{size}} arguments, it simply restores all attributes that were saved. 10661 10662 Note to restore position (not size) it should be called twice for each 10663 window to accommodate sloppy window managers: once before the window is 10664 shown, second time immediately after showing the window. 10665 10666 Some sanity checks are included, therefore if saved window position and/or 10667 size is too suspicious, it is not restored. 10668 10669 @param window: A window to restore position of. I{(L{gtk.Window})} 10670 @param prefix: Unique prefix in settings to get the information from (the same as 10671 in L{gwy_app_save_window_position}()). I{(string)} 10672 @param grow_only: B{C{True}} to only attempt set the window default size bigger than it 10673 requests, never smaller. I{(bool)} 10674 @return: 10675 """ 10676 return None

10677 -def gwy_app_run_graph_func( name ):

10678 """ 10679 Runs a graph function on the current graph. 10680 10681 @param name: A graph function name. I{(string)} 10682 @return: 10683 """ 10684 return None

10685 -def gwy_app_run_process_func( name ):

10686 """ 10687 Runs a data processing function on the current data. 10688 10689 From the run modes function B{C{name}} supports, the most interactive one is 10690 selected. 10691 10692 10693 @param name: A data processing function name. I{(string)} 10694 @return: The actually used mode (nonzero), or 0 on failure. 10695 10696 """ 10697 return None

10698 -def gwy_app_run_process_func_in_mode( name , run ):

10699 """ 10700 Runs a data processing function on current data in specified mode. 10701 10702 @param name: A data processing function name. I{(string)} 10703 @param run: A run mode. I{(RunType)} 10704 @return: 10705 """ 10706 return None

10707 -def gwy_app_save_window_position( window , prefix , position , size ):

10708 """ 10709 Saves position and/or size of a window to settings. 10710 10711 Some sanity checks are included, therefore if window position and/or size 10712 is too suspicious, it is not saved. 10713 10714 @param window: A window to save position of. I{(L{gtk.Window})} 10715 @param prefix: Unique prefix in settings to store the information under. I{(string)} 10716 @param position: B{C{True}} to save position information. I{(bool)} 10717 @param size: B{C{True}} to save size information. I{(bool)} 10718 @return: 10719 """ 10720 return None

10721 -def gwy_app_sensitivity_add_widget( widget , mask ):

10722 """ 10723 Adds a widget to the application-wide widget sensitvity group. 10724 10725 The semantics of this function is the same as 10726 L{SensitivityGroup.add_widget}() (in fact, it's a simple wrapper around 10727 it). 10728 10729 @param widget: Widget to add. I{(L{gtk.Widget})} 10730 @param mask: Which flags the widget is sensitive to. I{(MenuSensFlags)} 10731 @return: 10732 """ 10733 return None

10734 -def gwy_app_sensitivity_get_group( ):

10735 """ 10736 Gets the application-wide widget sensitvity group. 10737 10738 The flags to be used with this sensitvity group are defined in 10739 B{C{MenuSensFlags}}. 10740 10741 10742 @return: The global sensitvity group instead. No reference is added, you 10743 can add yours, but the returned object will exist to the end of 10744 program anyway. 10745 10746 """ 10747 return None

10748 -def gwy_app_sensitivity_set_state( affected_mask , state ):

10749 """ 10750 Sets the state of application-wide widget sensitvity group. 10751 10752 The semantics of this function is the same as 10753 L{SensitivityGroup.set_state}() (in fact, it's a simple wrapper around 10754 it). 10755 10756 @param affected_mask: Which bits in B{C{state}} to copy to state. I{(MenuSensFlags)} 10757 @param state: The new state (masked with B{C{affected_mask}}). I{(MenuSensFlags)} 10758 @return: 10759 """ 10760 return None

10761 -def gwy_app_set_current_directory( directory ):

10762 """ 10763 Sets what the app should use as `current directory'. 10764 10765 Warning: This function is probably temporary. 10766 10767 @param directory: The directory to set, or a filename to take directory part 10768 from, it must be an absolute path. In GLib file name encoding. I{(string)} 10769 @return: 10770 """ 10771 return None

10772 -def gwy_app_set_data_field_title( data , id , name ):

10773 """ 10774 Sets channel title. 10775 10776 @param data: A data container. I{(L{Container})} 10777 @param id: The data channel id. I{(int)} 10778 @param name: The title to set. It can be B{C{NULL}} to use somthing like "Untitled". 10779 The id will be appended to it or (replaced in it if it already ends 10780 with digits). I{(string)} 10781 @return: 10782 """ 10783 return None

10784 -def gwy_app_settings_create_config_dir( ):

10785 """ 10786 Create gwyddion config directory. 10787 10788 10789 @return: Whether it succeeded (also returns B{C{True}} if the directory already 10790 exists). 10791 10792 """ 10793 return None

10794 -def z_UNIMPLEMENTED_gwy_app_settings_error_get_type( ):

10795 return None

10796 -def gwy_app_settings_error_quark( ):

10797 """ 10798 Returns error domain for application settings operations. 10799 10800 See and use B{C{APP_SETTINGS_ERROR}}. 10801 10802 10803 @return: The error domain. 10804 10805 """ 10806 return None

10807 -def gwy_app_settings_free( ):

10808 """ 10809 Frees Gwyddion settings. 10810 10811 Should not be called only by main application. 10812 10813 @return: 10814 """ 10815 return None

10816 -def gwy_app_settings_get( ):

10817 """ 10818 Gets the Gwyddion settings. 10819 10820 The settings are a B{C{Container}} automatically loaded at program startup 10821 and saved ad its exit. For storing persistent module data you should 10822 use <literal>"/module/YOUR_MODULE_NAME/"</literal> prefix. 10823 10824 10825 @return: The settings as a B{C{Container}}. 10826 10827 """ 10828 return None

10829 -def gwy_app_settings_get_log_filename( ):

10830 """ 10831 Returns a suitable log file name. 10832 10833 10834 @return: The file name as a newly allocated string. 10835 10836 """ 10837 return None

10838 -def z_UNIMPLEMENTED_gwy_app_settings_get_module_dirs( ):

10839 """ 10840 Returns a list of directories to search modules in. 10841 10842 10843 @return: The list of module directories as a newly allocated array of 10844 newly allocated strings, to be freed with g_str_freev() when 10845 not longer needed. 10846 10847 """ 10848 return None

10849 -def gwy_app_settings_get_recent_file_list_filename( ):

10850 """ 10851 Returns a suitable recent file list file name. 10852 10853 10854 @return: The file name as a newly allocated string. 10855 10856 """ 10857 return None

10858 -def gwy_app_settings_get_settings_filename( ):

10859 """ 10860 Returns a suitable human-readable settings file name. 10861 10862 10863 @return: The file name as a newly allocated string. 10864 10865 """ 10866 return None

10867 -def gwy_app_settings_load( filename ):

10868 """ 10869 Loads settings file. 10870 10871 10872 @param filename: A filename to read settings from. I{(string)} 10873 @return: Whether it succeeded. In either case you can call 10874 L{gwy_app_settings_get}() then to obtain either the loaded settings 10875 or the old ones (if failed), or an empty B{C{Container}}. 10876 10877 """ 10878 return None

10879 -def gwy_app_settings_save( filename ):

10880 """ 10881 Saves the settings. 10882 10883 Use L{gwy_app_settings_get_settings_filename}() to obtain a suitable default 10884 filename. 10885 10886 10887 @param filename: A filename to save the settings to. I{(string)} 10888 @return: Whether it succeeded. 10889 10890 """ 10891 return None

10892 -def gwy_app_switch_tool( toolname ):

10893 """ 10894 Switches the current tool. 10895 10896 @param toolname: Tool name, that is B{C{GType}} name of the tool type. I{(string)} 10897 @return: 10898 """ 10899 return None

10900 -def z_UNIMPLEMENTED_gwy_app_undo_checkpointv( data , n , keys ):

10901 """ 10902 Create a point in the undo history it is possible to return to. 10903 10904 In addition to what L{gwy_undo_checkpointv}() does, this function takes care 10905 of updating application controls state. 10906 10907 10908 @param data: A data container. I{(L{Container})} 10909 @param n: The number of strings in B{C{keys}}. I{(int)} 10910 @param keys: An array of container string keys to save data. 10911 It can contain holes, that is NUL's, they are ignored. However, it 10912 should contain at least one real key. I{(const-gchar**)} 10913 @return: Undo level id. Not useful (yet). 10914 10915 """ 10916 return None

10917 -def gwy_app_undo_container_remove( data , prefix ):

10918 """ 10919 Removes undo/redo information for a data container. 10920 10921 In addition to what L{gwy_undo_container_remove}() does, this function takes 10922 care of updating application controls state. 10923 10924 Since: 2.23 10925 10926 @param data: A data container managed by the data-browser. I{(L{Container})} 10927 @param prefix: Prefix to remove undo/redo information under. Pass B{C{NULL}} to remove 10928 undo/redo information altogether. I{(string)} 10929 @return: 10930 """ 10931 return None

10932 -def gwy_app_undo_qcheckpointv( data , n , keys ):

10933 """ 10934 Create a point in the undo history it is possible to return to. 10935 10936 In addition to what L{gwy_undo_checkpointv}() does, this function takes care 10937 of updating application controls state. 10938 10939 If B{C{keys}} include channel keys the corresponding channel calibration data is 10940 saved together with the data and then removed from the container. This 10941 prevents mismatch between a data field and its calibration data. Therefore, 10942 if you perform a data operation that can also meaningfully transform the 10943 corresponding calibration data take care to obtain it before saving undo. 10944 10945 10946 @param data: A data container. I{(L{Container})} 10947 @param n: The number of strings in B{C{keys}}. I{(int)} 10948 @param keys: An array of container quark keys to save data. 10949 It can contain holes, that is 0's, they are ignored. However, it 10950 should contain at least one real key. I{(const-GQuark*)} 10951 @return: Undo level id. Not useful (yet). 10952 10953 """ 10954 return None

10955 -def gwy_app_undo_redo_container( data ):

10956 """ 10957 Performs undo on a data container. 10958 10959 It must have redo available. 10960 10961 In addition to what L{gwy_undo_redo_container}() does, this function takes care 10962 of updating application controls state. 10963 10964 @param data: A data container. I{(L{Container})} 10965 @return: 10966 """ 10967 return None

10968 -def gwy_app_undo_undo_container( data ):

10969 """ 10970 Performs undo on a data container. 10971 10972 It must have undo available. 10973 10974 In addition to what L{gwy_undo_undo_container}() does, this function takes care 10975 of updating application controls state. 10976 10977 @param data: A data container. I{(L{Container})} 10978 @return: 10979 """ 10980 return None

10981 -def gwy_app_wait_cursor_finish( window ):

10982 """ 10983 Resets the cursor for a window. 10984 10985 This function lets the Gtk+ main loop to run. 10986 10987 If the window cursor was non-default before L{gwy_app_wait_cursor_start}(), 10988 it is not restored and has to be set manually. This limitation is due to 10989 the nonexistence of a method to obtain the current cursor. 10990 10991 Since: 2.3 10992 10993 @param window: A window. I{(L{gtk.Window})} 10994 @return: 10995 """ 10996 return None

10997 -def gwy_app_wait_cursor_start( window ):

10998 """ 10999 Changes the cursor for a window to indicate work. 11000 11001 This function lets the Gtk+ main loop to run. 11002 11003 Since: 2.3 11004 11005 @param window: A window. I{(L{gtk.Window})} 11006 @return: 11007 """ 11008 return None

11009 -def gwy_app_wait_finish( ):

11010 """ 11011 Finishes waiting, closing the dialog. 11012 11013 No function like L{gwy_app_wait_set_message}() should be call after that. 11014 11015 This function must be called even if user cancelled the operation. 11016 11017 @return: 11018 """ 11019 return None

11020 -def gwy_app_wait_set_fraction( fraction ):

11021 """ 11022 Sets the amount of progress the progress bar on the dialog displays. 11023 11024 11025 @param fraction: The progress of the operation, as a number from 0 to 1. I{(float)} 11026 @return: B{C{True}} if the operation can continue, B{C{False}} if user cancelled it 11027 meanwhile. 11028 11029 """ 11030 return None

11031 -def gwy_app_wait_set_message( message ):

11032 """ 11033 Sets the message shown on the progress dialog. 11034 11035 See also L{gwy_app_wait_set_message_prefix}() which makes this function more 11036 usable directly as a callback. 11037 11038 11039 @param message: A mesage to show in the progress dialog. I{(string)} 11040 @return: B{C{True}} if the operation can continue, B{C{False}} if user cancelled it 11041 meanwhile. 11042 11043 """ 11044 return None

11045 -def gwy_app_wait_set_message_prefix( prefix ):

11046 """ 11047 Sets prefix for the messages shown in the progress dialog. 11048 11049 The prefix will take effect in the next L{gwy_app_wait_set_message}() call. 11050 11051 11052 @param prefix: The prefix for new messages. I{(string)} 11053 @return: B{C{True}} if the operation can continue, B{C{False}} if user cancelled it 11054 meanwhile. 11055 11056 """ 11057 return None

11058 -def gwy_app_wait_start( window , message ):

11059 """ 11060 Starts waiting for a window B{C{window}}, creating a dialog with a progress bar. 11061 11062 Waiting is global, there can be only one at a time. 11063 11064 @param window: A window. I{(L{gtk.Window})} 11065 @param message: A message to show in the wait dialog. I{(string)} 11066 @return: 11067 """ 11068 return None

11069 -def z_UNIMPLEMENTED_gwy_app_what_get_type( ):

11070 return None

11071 -def z_UNIMPLEMENTED_gwy_ascii_strcase_equal( v1 , v2 ):

11072 """ 11073 Compares two strings for equality, ignoring case. 11074 11075 The case folding is performed only on ASCII characters. 11076 11077 This function is intended to be passed to g_hash_table_new() as 11078 B{C{key_equal_func}}, namely in conjuction with L{gwy_ascii_strcase_hash}() hashing 11079 function. 11080 11081 Since: 2.26 11082 11083 @param v1: String key. I{(gconstpointer)} 11084 @param v2: String key to compare with B{C{v1}}. I{(gconstpointer)} 11085 @return: B{C{True}} if the two string keys match, ignoring case. 11086 11087 11088 """ 11089 return None

11090 -def z_UNIMPLEMENTED_gwy_ascii_strcase_hash( v ):

11091 """ 11092 Converts a string to a hash value, ignoring case. 11093 11094 The case folding is performed only on ASCII characters. 11095 11096 This function is intended to be passed to g_hash_table_new() as B{C{hash_func}}, 11097 namely in conjuction with L{gwy_ascii_strcase_equal}() comparison function. 11098 11099 Since: 2.26 11100 11101 @param v: String key. I{(gconstpointer)} 11102 @return: The hash value corresponding to the key B{C{v}}. 11103 11104 11105 """ 11106 return None

11107 -def z_UNIMPLEMENTED_gwy_axis_get_type( ):

11108 return None

11109 -def z_UNIMPLEMENTED_gwy_axis_scale_format_get_type( ):

11110 return None

11111 -def z_UNIMPLEMENTED_gwy_byte_order_get_type( ):

11112 return None

11113 -def gwy_canonicalize_path( path ):

11114 """ 11115 Canonicalizes a filesystem path. 11116 11117 Particularly it makes the path absolute, resolves `..' and `.', and fixes 11118 slash sequences to single slashes. On Win32 it also converts all 11119 backslashes to slashes along the way. 11120 11121 Note this function does NOT resolve symlinks, use g_file_read_link() for 11122 that. 11123 11124 11125 @param path: A filesystem path. I{(string)} 11126 @return: The canonical path, as a newly created string. 11127 11128 """ 11129 return None

11130 -def z_UNIMPLEMENTED_gwy_cdline_get_type( ):

11131 return None

11132 -def gwy_cdlines( ):

11133 """ 11134 Gets inventory with all the critical dimension evaluators. 11135 11136 11137 @return: Critical dimension evaluator inventory. 11138 11139 """ 11140 return None

11141 -def z_UNIMPLEMENTED_gwy_color_axis_get_type( ):

11142 return None

11143 -def gwy_color_axis_new_with_range( orientation , min , max ):

11144 """ 11145 Creates a new color axis. 11146 11147 11148 @param orientation: The orientation of the axis. I{(GtkOrientation)} 11149 @param min: The minimum. I{(float)} 11150 @param max: The maximum. I{(float)} 11151 @return: The newly created color axis as a B{C{GtkWidget}}. 11152 11153 """ 11154 return None

11155 -def z_UNIMPLEMENTED_gwy_color_button_get_type( ):

11156 return None

11157 -def gwy_color_button_new_with_color( color ):

11158 """ 11159 Creates a new color button. 11160 11161 11162 @param color: A B{C{RGBA}} to set the current color with. I{(L{RGBA})} 11163 @return: a new color button. 11164 11165 """ 11166 return None

11167 -def gwy_color_selector_for_mask( dialog_title , color_button , container , prefix ):

11168 """ 11169 Creates and runs a color selector dialog for a mask. 11170 11171 See L{gwy_mask_color_selector_run}() for details. 11172 11173 @param dialog_title: Title of the color selection dialog (B{C{NULL}} to use default). I{(string)} 11174 @param color_button: Color button to update on color change (or B{C{NULL}}). I{(ColorButton*)} 11175 @param container: Container to initialize the color from and save it to. I{(L{Container})} 11176 @param prefix: Prefix in B{C{container}} (normally "/0/mask"). I{(string)} 11177 @return: 11178 """ 11179 return None

11180 -def gwy_combo_box_metric_unit_set_unit( combo , _from , to , unit ):

11181 """ 11182 Changes the unit selection displayed by a metric unit combo box. 11183 11184 Since: 2.5 11185 11186 @param combo: A combo box which was created with L{gwy_combo_box_metric_unit_new}(). I{(L{gtk.ComboBox})} 11187 @param _from: The exponent of 10 the menu should start at (a multiple of 3, will 11188 be rounded downward if isn't). I{(int)} 11189 @param to: The exponent of 10 the menu should end at (a multiple of 3, will be 11190 rounded upward if isn't). I{(int)} 11191 @param unit: The unit to be prefixed. I{(L{SIUnit})} 11192 @return: 11193 """ 11194 return None

11195 -def z_UNIMPLEMENTED_gwy_computation_state_type_get_type( ):

11196 return None

11197 -def gwy_container_deserialize_from_text( text ):

11198 """ 11199 Restores a container from is text representation. 11200 11201 11202 @param text: Text containing serialized container contents as dumped by 11203 L{Container.serialize_to_text}(). I{(string)} 11204 @return: The restored container, or B{C{NULL}} on failure. 11205 11206 """ 11207 return None

11208 -def z_UNIMPLEMENTED_gwy_container_get_type( ):

11209 return None

11210 -def z_UNIMPLEMENTED_gwy_convert_raw_data( data , nitems , stride , datatype , byteorder , target , scale , offset ):

11211 """ 11212 Converts a block of raw data items to doubles. 11213 11214 Note that conversion from 64bit integral types may lose information as they 11215 have more bits than the mantissa of doubles. All other conversions should 11216 be precise. 11217 11218 Since: 2.25 11219 11220 @param data: Pointer to the input raw data to be converted to doubles. The data 11221 type is given by B{C{datatype}} and B{C{byteorder}}. I{(gconstpointer)} 11222 @param nitems: Data block length, i.e. the number of consecutive items to convert. I{(gsize)} 11223 @param stride: Item stride in the raw data, measured in raw values. Pass 1 for 11224 consecutive raw data. For backward reading, pass -1 and point 11225 B{C{data}} to the last raw item instead of the first. I{(gssize)} 11226 @param datatype: Type of the raw data items. I{(RawDataType)} 11227 @param byteorder: Byte order of the raw data. I{(ByteOrder)} 11228 @param target: Array of B{C{nitems}} to store the converted input data to. I{(gdouble*)} 11229 @param scale: Factor to multiply the data with. I{(float)} 11230 @param offset: Constant to add to the data after multiplying with B{C{scale}}. I{(float)} 11231 @return: 11232 """ 11233 return None

11234 -def z_UNIMPLEMENTED_gwy_correlation_type_get_enum( ):

11235 return None

11236 -def z_UNIMPLEMENTED_gwy_correlation_type_get_type( ):

11237 return None

11238 -def z_UNIMPLEMENTED_gwy_curve_channel_get_type( ):

11239 return None

11240 -def z_UNIMPLEMENTED_gwy_curve_get_type( ):

11241 return None

11242 -def z_UNIMPLEMENTED_gwy_curve_type_get_type( ):

11243 return None

11244 -def z_UNIMPLEMENTED_gwy_cwt_wfunc_2d( scale , mval , xres , wtype ):

11245 return None

11246 -def z_UNIMPLEMENTED_gwy_data_chooser_get_type( ):

11247 return None

11248 -def gwy_data_chooser_new_channels( ):

11249 """ 11250 Creates a data chooser for data channels. 11251 11252 11253 @return: A new channel chooser. Nothing may be assumed about the type and 11254 properties of the returned widget as they can change in the future. 11255 11256 """ 11257 return None

11258 -def z_UNIMPLEMENTED_gwy_data_compatibility_flags_get_type( ):

11259 return None

11260 -def z_UNIMPLEMENTED_gwy_data_field_cached_get_type( ):

11261 return None

11262 -def z_UNIMPLEMENTED_gwy_data_field_correlate_finalize( state ):

11263 """ 11264 Destroys a correlation iterator, freeing all resources. 11265 11266 @param state: Correlation iterator. I{(ComputationState*)} 11267 @return: 11268 """ 11269 return None

11270 -def z_UNIMPLEMENTED_gwy_data_field_correlate_iteration( state ):

11271 """ 11272 Performs one iteration of correlation. 11273 11274 An iterator can be created with L{DataField.correlate_init}(). 11275 When iteration ends, either by finishing or being aborted, 11276 L{DataField.correlate_finalize}() must be called to release allocated 11277 resources. 11278 11279 @param state: Correlation iterator. I{(ComputationState*)} 11280 @return: 11281 """ 11282 return None

11283 -def z_UNIMPLEMENTED_gwy_data_field_crosscorrelate_finalize( state ):

11284 """ 11285 Destroys a cross-correlation iterator, freeing all resources. 11286 11287 @param state: Cross-correlation iterator. I{(ComputationState*)} 11288 @return: 11289 """ 11290 return None

11291 -def z_UNIMPLEMENTED_gwy_data_field_crosscorrelate_iteration( state ):

11292 """ 11293 Performs one iteration of cross-correlation. 11294 11295 Cross-correlation matches two different images of the same object under 11296 changes. 11297 11298 It does not use any special features 11299 for matching. It simply searches for all points (with their neighbourhood) 11300 of B{C{data_field1}} within B{C{data_field2}}. Parameters B{C{search_width}} and 11301 B{C{search_height}} determine maimum area where to search for points. 11302 The area is cenetered in the B{C{data_field2}} at former position of points at 11303 B{C{data_field1}}. 11304 11305 A cross-correlation iterator can be created with 11306 L{DataField.crosscorrelate_init}(). When iteration ends, either 11307 by finishing or being aborted, L{DataField.crosscorrelate_finalize}() 11308 must be called to release allocated resources. 11309 11310 @param state: Cross-correlation iterator. I{(ComputationState*)} 11311 @return: 11312 """ 11313 return None

11314 -def gwy_data_field_fractal_cubecounting_dim( xresult , yresult , a , b ):

11315 """ 11316 Computes fractal dimension by cube counting method from log-log plot data. 11317 11318 The B{C{xresult}} and B{C{yresult}} data lines are usually calculated by 11319 L{DataField.fractal_cubecounting}(). 11320 11321 11322 @param xresult: Log-log fractal data (x values). I{(L{DataLine})} 11323 @param yresult: Log-log fractal data (y values). I{(L{DataLine})} 11324 @param a: Location to store linear fit constant to. I{(float)} 11325 @param b: Location to store linear fit slope to. I{(float)} 11326 @return: The fractal dimension. 11327 11328 """ 11329 return None

11330 -def gwy_data_field_fractal_partitioning_dim( xresult , yresult , a , b ):

11331 """ 11332 Computes fractal dimension by partitioning method from log-log plot data. 11333 11334 The B{C{xresult}} and B{C{yresult}} data lines are usually calculated by 11335 L{DataField.fractal_partitioning}(). 11336 11337 11338 @param xresult: Log-log fractal data (x values). I{(L{DataLine})} 11339 @param yresult: Log-log fractal data (y values). I{(L{DataLine})} 11340 @param a: Location to store linear fit constant to. I{(float)} 11341 @param b: Location to store linear fit slope to. I{(float)} 11342 @return: The fractal dimension. 11343 11344 """ 11345 return None

11346 -def gwy_data_field_fractal_psdf_dim( xresult , yresult , a , b ):

11347 """ 11348 Computes fractal dimension by spectral density function method from 11349 log-log plot data. 11350 11351 The B{C{xresult}} and B{C{yresult}} data lines are usually calculated by 11352 L{DataField.fractal_psdf}(). 11353 11354 11355 @param xresult: Log-log fractal data (x values). I{(L{DataLine})} 11356 @param yresult: Log-log fractal data (y values). I{(L{DataLine})} 11357 @param a: Location to store linear fit constant to. I{(float)} 11358 @param b: Location to store linear fit slope to. I{(float)} 11359 @return: The fractal dimension. 11360 11361 """ 11362 return None

11363 -def gwy_data_field_fractal_triangulation_dim( xresult , yresult , a , b ):

11364 """ 11365 Computes fractal dimension by triangulation method from log-log plot data. 11366 11367 The B{C{xresult}} and B{C{yresult}} data lines are usually calculated by 11368 L{DataField.fractal_triangulation}(). 11369 11370 11371 @param xresult: Log-log fractal data (x values). I{(L{DataLine})} 11372 @param yresult: Log-log fractal data (y values). I{(L{DataLine})} 11373 @param a: Location to store linear fit constant to. I{(float)} 11374 @param b: Location to store linear fit slope to. I{(float)} 11375 @return: The fractal dimension. 11376 11377 """ 11378 return None

11379 -def gwy_data_field_get_circular_area_size( radius ):

11380 """ 11381 Calculates an upper bound of the number of samples in a circular region. 11382 11383 11384 @param radius: Circular area radius (in pixels). I{(float)} 11385 @return: The number of pixels in a circular region with given rectangular 11386 bounds (or its upper bound). 11387 11388 """ 11389 return None

11390 -def gwy_data_field_get_elliptic_area_size( width , height ):

11391 """ 11392 Calculates an upper bound of the number of samples in an elliptic region. 11393 11394 11395 @param width: Bounding box width. I{(int)} 11396 @param height: Bounding box height. I{(int)} 11397 @return: The number of pixels in an elliptic region with given rectangular 11398 bounds (or its upper bound). 11399 11400 """ 11401 return None

11402 -def z_UNIMPLEMENTED_gwy_data_field_get_type( ):

11403 return None

11404 -def z_UNIMPLEMENTED_gwy_data_field_grains_watershed_finalize( state ):

11405 """ 11406 Destroys a watershed iterator, freeing all resources. 11407 11408 @param state: Watershed iterator. I{(ComputationState*)} 11409 @return: 11410 """ 11411 return None

11412 -def z_UNIMPLEMENTED_gwy_data_field_grains_watershed_iteration( state ):

11413 """ 11414 Performs one iteration of the watershed algorithm. 11415 11416 Fields B{C{state}} and progress B{C{fraction}} of watershed state are updated 11417 (fraction is calculated for each phase individually). Once B{C{state}} 11418 becomes B{C{WATERSHED_STATE_FINISHED}}, the calculation is finised. 11419 11420 A watershed iterator can be created with 11421 L{DataField.grains_watershed_init}(). When iteration ends, either 11422 by finishing or being aborted, L{DataField.grains_watershed_finalize}() 11423 must be called to release allocated resources. 11424 11425 @param state: Watershed iterator. I{(ComputationState*)} 11426 @return: 11427 """ 11428 return None

11429 -def z_UNIMPLEMENTED_gwy_data_field_hough_datafield_line_to_polar( px1 , px2 , py1 , py2 , rho , theta ):

11430 return None

11431 -def z_UNIMPLEMENTED_gwy_data_field_unrotate_find_corrections( derdist , correction ):

11432 """ 11433 Finds rotation corrections. 11434 11435 Rotation correction is computed for for all symmetry types. 11436 In addition an estimate is made about the prevalent one. 11437 11438 11439 @param derdist: Angular derivation distribution (normally obrained from 11440 L{DataField.slope_distribution}()). I{(L{DataLine})} 11441 @param correction: Corrections for particular symmetry types will be stored 11442 here (indexed by PlaneSymmetry). B{C{correction}}[0] contains 11443 the most probable correction. All angles are in radians. I{(gdouble*)} 11444 @return: The estimate type of prevalent symmetry. 11445 11446 """ 11447 return None

11448 -def z_UNIMPLEMENTED_gwy_data_item_get_type( ):

11449 return None

11450 -def z_UNIMPLEMENTED_gwy_data_line_get_type( ):

11451 return None

11452 -def z_UNIMPLEMENTED_gwy_data_view_get_type( ):

11453 return None

11454 -def z_UNIMPLEMENTED_gwy_data_view_layer_get_type( ):

11455 return None

11456 -def z_UNIMPLEMENTED_gwy_data_view_layer_type_get_type( ):

11457 return None

11458 -def z_UNIMPLEMENTED_gwy_data_watch_event_type_get_type( ):

11459 return None

11460 -def gwy_data_window_class_get_tooltips( ):

11461 """ 11462 Gets the tooltips object used for adding tooltips to Data window parts. 11463 11464 11465 @return: The B{C{GtkTooltips}} object. 11466 11467 """ 11468 return None

11469 -def gwy_data_window_class_set_tooltips( tips ):

11470 """ 11471 Sets the tooltips object to use for adding tooltips to data window parts. 11472 11473 This is a class method. It affects only newly cerated data windows, 11474 existing data windows will continue to use the tooltips they were 11475 constructed with. 11476 11477 If no class tooltips object is set before first B{C{DataWindow}} is created, 11478 the class instantiates one on its own. You can normally obtain it with 11479 L{DataWindow.class_get_tooltips}() then. The class takes a reference on 11480 the tooltips in either case. 11481 11482 @param tips: Tooltips object B{C{DataWindow}}'s should use for setting tooltips. 11483 A B{C{NULL}} value disables tooltips altogether. I{(L{gtk.Tooltips})} 11484 @return: 11485 """ 11486 return None

11487 -def z_UNIMPLEMENTED_gwy_data_window_get_type( ):

11488 return None

11489 -def z_UNIMPLEMENTED_gwy_deserialize_object_hash( buffer , size , position , object_name , nitems ):

11490 """ 11491 Deserializes an object with arbitrary components from gwy-file format. 11492 11493 This function works like L{gwy_serialize_unpack_object_struct}(), except that 11494 it does not use any a priori knowledge of what the object contains. So 11495 instead of filling values in supplied B{C{SerializeSpec}}'s, it constructs 11496 B{C{SerializeItem}}'s completely from what is found in B{C{buffer}}. It does 11497 considerably less sanity checks and even allows several components of the 11498 same name. 11499 11500 11501 @param buffer: A block of memory of size B{C{size}} contaning object representation. I{(string)} 11502 @param size: The size of B{C{buffer}}. I{(gsize)} 11503 @param position: Current position in buffer, will be updated to point after 11504 object. I{(gsize*)} 11505 @param object_name: The type name of the object. I{(string)} 11506 @param nitems: Where the number of deserialized components should be stored. I{(gsize*)} 11507 @return: A newly allocated array of deserialized components. Note the 11508 B{C{name}} fields of B{C{SerializeSpec}}'s point to B{C{buffer}} and thus are 11509 valid only as long as B{C{buffer}} is; any arrays or strings are newly 11510 allocated and must be reused or freed by caller. 11511 11512 """ 11513 return None

11514 -def gwy_dialog_prevent_delete_cb( ):

11515 """ 11516 Returns B{C{True}}. 11517 11518 Use gtk_true() instead. 11519 11520 11521 @return: B{C{True}}. 11522 11523 """ 11524 return None

11525 -def gwy_draw_type_init( ):

11526 """ 11527 Makes libgwydraw types safe for deserialization and performs other 11528 initialization. You have to call this function before using objects 11529 from libgwydraw. 11530 11531 Calls L{gwy_process_type_init}() first to make sure libgwyprocess is 11532 initialized. 11533 11534 It is safe to call this function more than once, subsequent calls are no-op. 11535 11536 @return: 11537 """ 11538 return None

11539 -def z_UNIMPLEMENTED_gwy_dwt_denoise_type_get_enum( ):

11540 """ 11541 Returns B{C{Enum}} for B{C{DWTDenoiseType}} enum type. 11542 11543 11544 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 11545 11546 """ 11547 return None

11548 -def z_UNIMPLEMENTED_gwy_dwt_denoise_type_get_type( ):

11549 return None

11550 -def gwy_dwt_set_coefficients( dline , type ):

11551 """ 11552 Fills resampled or nely allocated data line with wavelet coefficients. 11553 11554 11555 @param dline: Data line to store wavelet coefficients to (or B{C{NULL}} to allocate 11556 a new one). I{(L{DataLine})} 11557 @param type: Wavelet type. I{(DWTType)} 11558 @return: resampled or newly allocated DataLine with wavelet coefficients. 11559 11560 """ 11561 return None

11562 -def z_UNIMPLEMENTED_gwy_dwt_type_get_enum( ):

11563 """ 11564 Returns B{C{Enum}} for B{C{DWTType}} enum type. 11565 11566 11567 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 11568 11569 """ 11570 return None

11571 -def z_UNIMPLEMENTED_gwy_dwt_type_get_type( ):

11572 return None

11573 -def gwy_entities( ):

11574 """ 11575 Returns a constant inventory with all available entities. 11576 11577 11578 @return: The entities as a B{C{Inventory}}. 11579 11580 """ 11581 return None

11582 -def gwy_entities_entity_to_utf8( entity ):

11583 """ 11584 Converts a single named entity B{C{entity}} to UTF-8 representation. 11585 11586 The string passed to this function should be a bare entity name, i.e. it 11587 should not contain the ampersand and semicolon. 11588 11589 11590 @param entity: A single entity name, as a nul-delimited string. I{(string)} 11591 @return: B{C{entity}} if the name was not recognized, or a valid UTF-8 string. 11592 If the returned string is not equal to B{C{entities}}, it's owned by 11593 entities and must not be freed nor modified. 11594 11595 """ 11596 return None

11597 -def gwy_entities_text_to_utf8( text ):

11598 """ 11599 Converts entities in a text to UTF-8. 11600 11601 11602 @param text: A nul-delimited string. I{(string)} 11603 @return: A newly allocated nul-delimited string containing the converted 11604 text. 11605 11606 """ 11607 return None

11608 -def gwy_enum_combo_box_get_active( combo ):

11609 """ 11610 Gets the enum value corresponding to currently active combo box item. 11611 11612 11613 @param combo: A combo box which was created with L{gwy_enum_combo_box_new}(). I{(L{gtk.ComboBox})} 11614 @return: The selected enum value. 11615 11616 """ 11617 return None

11618 -def gwy_enum_combo_box_set_active( combo , active ):

11619 """ 11620 Sets the active combo box item by corresponding enum value. 11621 11622 @param combo: A combo box which was created with L{gwy_enum_combo_box_new}(). I{(L{gtk.ComboBox})} 11623 @param active: The enum value to show as currently selected. I{(int)} 11624 @return: 11625 """ 11626 return None

11627 -def gwy_enum_combo_box_update_int( combo , integer ):

11628 """ 11629 Convenience callback keeping an integer synchronized with selected enum 11630 combo box value. 11631 11632 @param combo: A combo box which was created with L{gwy_enum_combo_box_new}(). I{(L{gtk.ComboBox})} 11633 @param integer: Pointer to an integer to update to selected enum value. I{(int)} 11634 @return: 11635 """ 11636 return None

11637 -def z_UNIMPLEMENTED_gwy_enum_get_type( ):

11638 return None

11639 -def gwy_enum_sanitize_value( enumval , enum_type ):

11640 """ 11641 Makes sure an enum value is valid. 11642 11643 11644 @param enumval: An enum value. I{(int)} 11645 @param enum_type: B{C{GType}} of a registered enum type. I{(GType)} 11646 @return: Either B{C{enumval}} itself if it's valid, or some valid enum value. 11647 When B{C{enumval}} is invalid and larger than all valid values the 11648 largest valid value is returned. Likewise if it's smaller the 11649 smallest valid value is returned. If it's in range but invalid, 11650 the first enum value is returned. 11651 11652 """ 11653 return None

11654 -def z_UNIMPLEMENTED_gwy_enum_to_string( enumval , enum_table , n ):

11655 """ 11656 Creates a string representation of an integer enum value B{C{enumval}}. 11657 11658 11659 @param enumval: A one integer value from B{C{enum_table}}. I{(int)} 11660 @param enum_table: A table of corresponding string-integer pairs. I{(const-Enum*)} 11661 @param n: The number of elements in B{C{enum_table}}, may be -1 when B{C{enum_table}} is 11662 terminated by a B{C{NULL}} name. I{(int)} 11663 @return: The name as a string from B{C{enum_table}}, thus it generally should 11664 not be modified or freed, unless B{C{enum_table}} is supposed to be 11665 modified too. If the value is not found, an empty string is 11666 returned. 11667 11668 """ 11669 return None

11670 -def z_UNIMPLEMENTED_gwy_expr_error_get_type( ):

11671 return None

11672 -def gwy_expr_error_quark( ):

11673 """ 11674 Returns error domain for expression parsin and evaluation. 11675 11676 See and use B{C{EXPR_ERROR}}. 11677 11678 11679 @return: The error domain. 11680 11681 """ 11682 return None

11683 -def z_UNIMPLEMENTED_gwy_exterior_type_get_type( ):

11684 return None

11685 -def z_UNIMPLEMENTED_gwy_fd_curve_preset_get_type( ):

11686 return None

11687 -def gwy_fd_curve_presets( ):

11688 """ 11689 Gets inventory with all the FD curve presets. 11690 11691 Since: 2.7 11692 11693 @return: FD curve preset inventory. 11694 11695 11696 """ 11697 return None

11698 -def gwy_fft_find_nice_size( size ):

11699 """ 11700 Finds a nice-for-FFT array size. 11701 11702 The `nice' means three properties are guaranteed: 11703 it is greater than or equal to B{C{size}}; 11704 it can be directly used with current FFT backend without scaling 11705 (since 2.8 this is true for any size); 11706 and the transform is fast, i.e. the number is highly factorable. 11707 11708 To be compatible with Gwyddion <= 2.7 one has to pass only data fields and 11709 lines with sizes returned by this function to raw integral transforms. 11710 Otherwise this function is mainly useful if you extend and pad the input 11711 data for other reasons and thus have the freedom to choose a convenient 11712 transform size. 11713 11714 11715 @param size: Transform size. I{(int)} 11716 @return: A nice FFT array size. 11717 11718 """ 11719 return None

11720 -def z_UNIMPLEMENTED_gwy_fft_simple( dir , n , istride , in_re , in_im , ostride , out_re , out_im ):

11721 """ 11722 Performs a DFT algorithm. 11723 11724 This is a low-level function used by other FFT functions when no better 11725 backend is available. 11726 11727 Strides are distances between samples in input and output arrays. Use 1 11728 for normal `dense' arrays. To use L{gwy_fft_simple}() with interleaved arrays, 11729 that is with alternating real and imaginary data, call it with 11730 B{C{istride}}=2, B{C{in_re}}=B{C{complex_array}}, B{C{in_im}}=B{C{complex_array}}+1 (and similarly 11731 for output arrays). 11732 11733 The output is symmetrically normalized by square root of B{C{n}} for both 11734 transform directions. By performing forward and then backward transform, 11735 you will obtain the original array (up to rounding errors). 11736 11737 @param dir: Transformation direction. I{(TransformDirection)} 11738 @param n: Number of data points. Note only certain transform sizes are 11739 implemented. If L{gwy_fft_simple}() is the current FFT backend, then 11740 L{gwy_fft_find_nice_size}() can provide accepted transform sizes. 11741 If L{gwy_fft_simple}() is not the current FFT backend, you should not 11742 use it. I{(int)} 11743 @param istride: Input data stride. I{(int)} 11744 @param in_re: Real part of input data. I{(const-gdouble*)} 11745 @param in_im: Imaginary part of input data. I{(const-gdouble*)} 11746 @param ostride: Output data stride. I{(int)} 11747 @param out_re: Real part of output data. I{(gdouble*)} 11748 @param out_im: Imaginary part of output data. I{(gdouble*)} 11749 @return: 11750 """ 11751 return None

11752 -def gwy_fft_window( n , data , windowing ):

11753 """ 11754 Multiplies data by given window. 11755 11756 @param n: Number of data values. I{(int)} 11757 @param data: Data values. I{(gdouble*)} 11758 @param windowing: Method used for windowing. I{(WindowingType)} 11759 @return: 11760 """ 11761 return None

11762 -def gwy_fft_window_data_field( dfield , orientation , windowing ):

11763 """ 11764 Performs windowing of a data field in given direction. 11765 11766 @param dfield: A data field. I{(L{DataField})} 11767 @param orientation: Windowing orientation (the same as corresponding FFT 11768 orientation). I{(Orientation)} 11769 @param windowing: The windowing type to use. I{(WindowingType)} 11770 @return: 11771 """ 11772 return None

11773 -def gwy_file_abandon_contents( buffer , size ):

11774 """ 11775 Frees or unmmaps memory allocated by L{gwy_file_get_contents}(). 11776 11777 11778 @param buffer: Buffer with file contents as created by L{gwy_file_get_contents}(). I{(guchar*)} 11779 @param size: Buffer size. I{(gsize)} 11780 @return: Whether it succeeded. Since 2.22 it always return B{C{True}}. 11781 11782 """ 11783 return None

11784 -def gwy_file_detect( filename , only_name , operations ):

11785 """ 11786 Detects the type of a file. 11787 11788 11789 @param filename: A file name to detect type of. I{(string)} 11790 @param only_name: Whether to use only file name for a guess, or try to actually 11791 access the file. I{(bool)} 11792 @param operations: The file operations the file type must support (it must 11793 support all of them to be considered). I{(FileOperationType)} 11794 @return: The type name (i.e., the same name as passed to 11795 e.g. L{gwy_run_file_load_func}()) of most probable type of B{C{filename}}, 11796 or B{C{NULL}} if there's no probable one. 11797 11798 """ 11799 return None

11800 -def gwy_file_detect_with_score( filename , only_name , operations , score ):

11801 """ 11802 Detects the type of a file and gives the score. 11803 11804 Since: 2.1 11805 11806 @param filename: A file name to detect type of. I{(string)} 11807 @param only_name: Whether to use only file name for a guess, or try to actually I{(bool)} 11808 @param operations: The file operations the file type must support (it must I{(FileOperationType)} 11809 @param score: Location to store the maximum score (corresponding to the returned 11810 type) to. I{(int)} 11811 @return: The type name (i.e., the same name as passed to 11812 e.g. L{gwy_run_file_load_func}()) of most probable type of B{C{filename}}, 11813 or B{C{NULL}} if there's no probable one. 11814 11815 11816 """ 11817 return None

11818 -def gwy_file_func_exists( name ):

11819 """ 11820 Checks whether a file type function exists. 11821 11822 11823 @param name: File type function name. I{(string)} 11824 @return: B{C{True}} if function B{C{name}} exists, B{C{False}} otherwise. 11825 11826 """ 11827 return None

11828 -def z_UNIMPLEMENTED_gwy_file_func_foreach( function , user_data ):

11829 """ 11830 Calls a function for each file function. 11831 11832 @param function: Function to run for each file function. It will get function 11833 name (constant string owned by module system) as its first 11834 argument, B{C{user_data}} as the second argument. I{(GFunc)} 11835 @param user_data: Data to pass to B{C{function}}. I{(gpointer)} 11836 @return: 11837 """ 11838 return None

11839 -def gwy_file_func_get_description( name ):

11840 """ 11841 Gets file function description. 11842 11843 That is, the B{C{file_desc}} field of B{C{FileFuncInfo}}. 11844 11845 11846 @param name: File type function name. I{(string)} 11847 @return: File function description, as a string owned by module loader. 11848 11849 """ 11850 return None

11851 -def gwy_file_func_get_is_detectable( name ):

11852 """ 11853 Returns if the file format is reasonably detectable. 11854 11855 This is B{C{True}} for all file types that define a detection method unless they 11856 explicitly call L{gwy_file_func_set_is_detectable}() to set the file format 11857 non-detectable in spite of providing a detection method. 11858 11859 If files that can be actually loaded as a given type form a subset of files 11860 that are detected as this format, which is normaly the case, it makes no 11861 sense to let the user explicitly choose between these formats. Hence, 11862 detectable formats normally are not explicitly offered. 11863 11864 Since: 2.18 11865 11866 @param name: File type function name. I{(string)} 11867 @return: If the file format is detectable. 11868 11869 11870 """ 11871 return None

11872 -def gwy_file_func_get_operations( name ):

11873 """ 11874 Returns operations supported by a file type function. 11875 11876 11877 @param name: File type function name. I{(string)} 11878 @return: The file operation bit mask, zero if B{C{name}} does not exist. 11879 11880 """ 11881 return None

11882 -def z_UNIMPLEMENTED_gwy_file_func_register( name , description , detect , load , save , export_ ):

11883 """ 11884 Registered a file function. 11885 11886 At least one of B{C{load}}, B{C{save}}, and B{C{export_}} must be non-B{C{NULL}}. See 11887 B{C{FileOperationType}} for differences between save and export. 11888 11889 Note: the string arguments are not copied as modules are not expected to 11890 vanish. If they are constructed (non-constant) strings, do not free them. 11891 Should modules ever become unloadable they will get chance to clean-up. 11892 11893 11894 @param name: Name of function to register. It should be a valid identifier and 11895 if a module registers only one function, module and function names 11896 should be the same. I{(string)} 11897 @param description: File type description (will be used in file type selectors). I{(string)} 11898 @param detect: Detection function. It may be B{C{NULL}}, files of such a type can 11899 can be then loaded and saved only on explict user request. I{(FileDetectFunc)} 11900 @param load: File load/import function. I{(FileLoadFunc)} 11901 @param save: File save function. I{(FileSaveFunc)} 11902 @param export_: File export function. I{(FileSaveFunc)} 11903 @return: Normally B{C{True}}; B{C{False}} on failure. 11904 11905 """ 11906 return None

11907 -def gwy_file_func_run_detect( name , filename , only_name ):

11908 """ 11909 Runs a file type detection function identified by B{C{name}}. 11910 11911 Value of B{C{only_name}} should be B{C{True}} if the file doesn't exist (is to be 11912 written) so its contents can't be used for file type detection. 11913 11914 This is a low-level function, consider using L{gwy_file_detect}() if you 11915 simply want to detect a file type. 11916 11917 11918 @param name: A file type function name. I{(string)} 11919 @param filename: A file name to detect. I{(string)} 11920 @param only_name: Whether to use only file name for a guess, or try to actually 11921 access the file. I{(bool)} 11922 @return: An integer score expressing the likehood of the file being 11923 loadable as this type. A basic scale is 20 for a good extension, 11924 100 for good magic header, more for more thorough tests. 11925 11926 """ 11927 return None

11928 -def gwy_file_func_run_export( name , data , filename , mode ):

11929 """ 11930 Runs a file export function identified by B{C{name}}. 11931 11932 It guarantees the container lifetime spans through the actual file saving, 11933 so the module function doesn't have to care about it. 11934 11935 This is a low-level function, consider using L{gwy_file_save}() if you 11936 simply want to save a file. 11937 11938 11939 @param name: A file save function name. I{(string)} 11940 @param data: A B{C{Container}} to save. I{(L{Container})} 11941 @param filename: A file name to save B{C{data}} as. I{(string)} 11942 @param mode: Run mode. I{(RunType)} 11943 @return: B{C{True}} if file save succeeded, B{C{False}} otherwise. 11944 11945 """ 11946 return None

11947 -def gwy_file_func_run_load( name , filename , mode ):

11948 """ 11949 Runs a file load function identified by B{C{name}}. 11950 11951 This is a low-level function, consider using L{gwy_file_load}() if you 11952 simply want to load a file. 11953 11954 11955 @param name: A file load function name. I{(string)} 11956 @param filename: A file name to load data from. I{(string)} 11957 @param mode: Run mode. I{(RunType)} 11958 @return: A new B{C{Container}} with data from B{C{filename}}, or B{C{NULL}}. 11959 11960 """ 11961 return None

11962 -def gwy_file_func_run_save( name , data , filename , mode ):

11963 """ 11964 Runs a file save function identified by B{C{name}}. 11965 11966 It guarantees the container lifetime spans through the actual file saving, 11967 so the module function doesn't have to care about it. 11968 11969 This is a low-level function, consider using L{gwy_file_save}() if you 11970 simply want to save a file. 11971 11972 11973 @param name: A file save function name. I{(string)} 11974 @param data: A B{C{Container}} to save. I{(L{Container})} 11975 @param filename: A file name to save B{C{data}} as. I{(string)} 11976 @param mode: Run mode. I{(RunType)} 11977 @return: B{C{True}} if file save succeeded, B{C{False}} otherwise. 11978 11979 """ 11980 return None

11981 -def gwy_file_func_set_is_detectable( name , is_detectable ):

11982 """ 11983 Sets the detectability status of a file format. 11984 11985 See L{gwy_file_func_get_is_detectable}() for details. The only rare case when 11986 it makes sense to call this function is when a detection function is 11987 provided for some reason, however, this function is not really able to 11988 detect the format. For instance, the fallback detection method of the 11989 Gwyddion rawfile module. 11990 11991 Since: 2.18 11992 11993 @param name: File type function name. I{(string)} 11994 @param is_detectable: B{C{True}} to define format as detectable, B{C{False}} as 11995 non-detectable. I{(bool)} 11996 @return: 11997 """ 11998 return None

11999 -def z_UNIMPLEMENTED_gwy_file_get_contents( filename , buffer , size ):

12000 """ 12001 Reads or mmaps file B{C{filename}} into memory. 12002 12003 The buffer must be treated as read-only and must be freed with 12004 L{gwy_file_abandon_contents}(). It is NOT guaranteed to be NUL-terminated, 12005 use B{C{size}} to find its end. 12006 12007 12008 @param filename: A file to read contents of. I{(string)} 12009 @param buffer: Buffer to store the file contents. I{(guchar**)} 12010 @param size: Location to store buffer (file) size. I{(gsize*)} 12011 @return: Whether it succeeded. In case of failure B{C{buffer}} and B{C{size}} are 12012 reset too. 12013 12014 """ 12015 return None

12016 -def z_UNIMPLEMENTED_gwy_file_get_data_info( data , name , filename_sys ):

12017 """ 12018 Gets file information about a data. 12019 12020 The information is set on two ocasions: file load and successful file save. 12021 File export does not set it. 12022 12023 12024 @param data: A B{C{Container}}. I{(L{Container})} 12025 @param name: Location to store file type (that is file function name) of B{C{data}}, 12026 or B{C{NULL}}. The returned string is owned by module system. I{(const-gchar**)} 12027 @param filename_sys: Location to store file name of B{C{data}} (in GLib encoding), or 12028 B{C{NULL}}. The returned string is owned by module system and is 12029 valid only until the container is destroyed or saved again. I{(const-gchar**)} 12030 @return: B{C{True}} if information about B{C{data}} was found and B{C{name}} and/or 12031 B{C{filename}} was filled. 12032 12033 """ 12034 return None

12035 -def gwy_file_load( filename , mode ):

12036 """ 12037 Loads a data file, autodetecting its type. 12038 12039 Since: 2.25 12040 12041 @param filename: A file name to load data from, in GLib encoding. I{(string)} 12042 @param mode: Run mode. I{(RunType)} 12043 @param name: Location to store the name of file load function used to load the 12044 file, or B{C{NULL}}. If an error occurs outside the module, e.g. failure 12045 to recognise the file type, B{C{NULL}} is stored to B{C{name}}. 12046 @return: A new B{C{Container}} with data from B{C{filename}}, or B{C{NULL}}. 12047 12048 12049 """ 12050 return None

12051 -def z_UNIMPLEMENTED_gwy_file_load_with_func( filename , mode , name ):

12052 return None

12053 -def z_UNIMPLEMENTED_gwy_file_operation_type_get_type( ):

12054 return None

12055 -def gwy_file_save( data , filename , mode ):

12056 """ 12057 Saves a data file, deciding to save as what type from the file name. 12058 12059 It tries to find a module implementing B{C{FILE_OPERATION_SAVE}} first, when 12060 it does not succeed, it falls back to B{C{FILE_OPERATION_EXPORT}}. 12061 12062 12063 @param data: A B{C{Container}} to save. I{(L{Container})} 12064 @param filename: A file name to save the data as, in GLib encoding. I{(string)} 12065 @param mode: Run mode. I{(RunType)} 12066 @return: The save operation that was actually realized on success, zero 12067 on failure. 12068 12069 """ 12070 return None

12071 -def z_UNIMPLEMENTED_gwy_file_save_with_func( data , filename , mode , name ):

12072 """ 12073 Saves a data file, deciding to save as what type from the file name. 12074 12075 It tries to find a module implementing B{C{FILE_OPERATION_SAVE}} first, when 12076 it does not succeed, it falls back to B{C{FILE_OPERATION_EXPORT}}. 12077 12078 Since: 2.25 12079 12080 @param data: A B{C{Container}} to save. I{(L{Container})} 12081 @param filename: A file name to save the data as, in GLib encoding. I{(string)} 12082 @param mode: Run mode. I{(RunType)} 12083 @param name: Location to store the name of file load function used to save the 12084 file, or B{C{NULL}}. If an error occurs outside the module, e.g. failure 12085 to recognise the file type, B{C{NULL}} is stored to B{C{name}}. I{(const-gchar**)} 12086 @return: The save operation that was actually realized on success, zero 12087 on failure. 12088 12089 12090 """ 12091 return None

12092 -def gwy_filename_ignore( filename_sys ):

12093 """ 12094 Checks whether file should be ignored. 12095 12096 This function checks for common file names indicating files that should 12097 be normally ignored. Currently it means backup files (ending with ~ or 12098 .bak) and Unix hidden files (starting with a dot). 12099 12100 12101 @param filename_sys: File name in GLib encoding. I{(string)} 12102 @return: B{C{True}} to ignore this file, B{C{False}} otherwise. 12103 12104 """ 12105 return None

12106 -def gwy_find_self_dir( dirname ):

12107 """ 12108 Finds a system Gwyddion directory. 12109 12110 On Unix, a compiled-in path is returned, unless it's overriden with 12111 environment variables (see gwyddion manual page). 12112 12113 On Win32, the directory where the libgwyddion DLL from which this function 12114 was called resides is taken as the base and the location of other Gwyddion 12115 directories is calculated from it. 12116 12117 The returned value is not actually tested for existence, it's up to caller. 12118 12119 To obtain the Gwyddion user directory see L{gwy_get_user_dir}(). 12120 12121 12122 @param dirname: A gwyddion directory name: 12123 <literal>"modules"</literal>, 12124 <literal>"plugins"</literal>, 12125 <literal>"pixmaps"</literal>, 12126 <literal>"locale"</literal>, or 12127 <literal>"data"</literal>. I{(string)} 12128 @return: The path as a newly allocated string. 12129 12130 """ 12131 return None

12132 -def z_UNIMPLEMENTED_gwy_flags_to_string( enumval , enum_table , n , glue ):

12133 """ 12134 Creates a string representation of integer flag combination B{C{enumval}}. 12135 12136 12137 @param enumval: Some ORed integer flags from B{C{enum_table}}. I{(int)} 12138 @param enum_table: A table of corresponding string-integer pairs. I{(const-Enum*)} 12139 @param n: The number of elements in B{C{enum_table}}, may be -1 when B{C{enum_table}} is 12140 terminated by a B{C{NULL}} name. I{(int)} 12141 @param glue: A glue to join string values with, when B{C{NULL}} space is used. I{(string)} 12142 @return: The string representation as a newly allocated string. It should 12143 be freed when no longer used. 12144 12145 """ 12146 return None

12147 -def z_UNIMPLEMENTED_gwy_func_use_add( functions , name ):

12148 """ 12149 Adds an use of a function to the statistics. 12150 12151 @param functions: Function use statistics. I{(FunctionUse*)} 12152 @param name: Function name. I{(string)} 12153 @return: 12154 """ 12155 return None

12156 -def z_UNIMPLEMENTED_gwy_func_use_free( functions ):

12157 """ 12158 Destroys function use statistics, freeing all associated resourced. 12159 12160 @param functions: Function use statistics. I{(FunctionUse*)} 12161 @return: 12162 """ 12163 return None

12164 -def gwy_func_use_get( functions , i ):

12165 """ 12166 Gets the n-th most function from a function statistics. 12167 12168 12169 @param functions: Function use statistics. I{(FunctionUse*)} 12170 @param i: Position in the top used functions (starting from 0). I{(int)} 12171 @return: The function name, or B{C{NULL}} if there are not more functions with 12172 use statistics records than B{C{i}}. 12173 12174 """ 12175 return None

12176 -def gwy_func_use_get_filename( type ):

12177 """ 12178 Gets the (preferred) name for a file to store function use statistics to. 12179 12180 12181 @param type: Function type, that is an identifier of the type of statistics 12182 gathered. It must be a valid identifier. I{(string)} 12183 @return: The file name as a newly allocated string. 12184 12185 """ 12186 return None

12187 -def z_UNIMPLEMENTED_gwy_func_use_load( filename ):

12188 """ 12189 Loads function use statistics from a file. 12190 12191 12192 @param filename: A file name (in GLib encoding). I{(string)} 12193 @return: A newly created function use statistics filled with data from 12194 file B{C{filename}}. 12195 12196 """ 12197 return None

12198 -def z_UNIMPLEMENTED_gwy_func_use_save( functions , filename ):

12199 """ 12200 Saves function use statistics data to a file. 12201 12202 @param functions: Function use statistics. I{(FunctionUse*)} 12203 @param filename: A file name (in GLib encoding). I{(string)} 12204 @return: 12205 """ 12206 return None

12207 -def gwy_get_home_dir( ):

12208 """ 12209 Returns home directory, or temporary directory as a fallback. 12210 12211 Under normal circumstances the same string as g_get_home_dir() would return 12212 is returned. But on MS Windows, something like "C:\Windows\Temp" can be 12213 returned too, as it is as good as anything else (we can write there). 12214 12215 12216 @return: Something usable as user home directory. It may be silly, but 12217 never B{C{NULL}} or empty. 12218 12219 """ 12220 return None

12221 -def gwy_get_key_from_name( name ):

12222 return None

12223 -def z_UNIMPLEMENTED_gwy_get_pango_ft2_font_map( unref ):

12224 """ 12225 Returns global Pango FT2 font map, eventually creating it. 12226 12227 FT2 portability to Win32 is questionable, use PangoCairo instead. 12228 12229 12230 @param unref: If B{C{True}}, function removes the font map reference and returns B{C{NULL}}. I{(bool)} 12231 @return: Pango FT2 font map. Add your own reference if you want it to 12232 never go away. 12233 12234 """ 12235 return None

12236 -def gwy_get_user_dir( ):

12237 """ 12238 Returns the directory where Gwyddion user settings and data should be stored. 12239 12240 On Unix this is usually a dot-directory in user's home directory. On modern 12241 Win32 the returned directory resides in user's Documents and Settings. 12242 On silly platforms or silly occasions, silly locations (namely a temporary 12243 directory) can be returned as fallback. 12244 12245 To obtain a Gwyddion system directory see L{gwy_find_self_dir}(). 12246 12247 12248 @return: The directory as a constant string that should not be freed. 12249 12250 """ 12251 return None

12252 -def z_UNIMPLEMENTED_gwy_gl_material_get_type( ):

12253 return None

12254 -def gwy_gl_material_selection_get_active( selection ):

12255 """ 12256 Gets the name of currently selected GL material of a selection button. 12257 12258 12259 @param selection: GL material selection button. I{(L{gtk.Widget})} 12260 @return: Name as a string owned by the selected GL material. 12261 12262 """ 12263 return None

12264 -def gwy_gl_material_selection_set_active( selection , active ):

12265 """ 12266 Sets the currently selected GL material of a selection button. 12267 12268 @param selection: GL material selection button. I{(L{gtk.Widget})} 12269 @param active: GL material name to be shown as currently selected. I{(string)} 12270 @return: 12271 """ 12272 return None

12273 -def gwy_gl_material_tree_view_set_active( treeview , active ):

12274 """ 12275 Selects a GL material in a GL material list and scrolls to make it visible. 12276 12277 12278 @param treeview: A GL material selector tree view. I{(L{gtk.Widget})} 12279 @param active: GL material name to be shown as currently selected. I{(string)} 12280 @return: B{C{True}} if B{C{active}} was selected, B{C{False}} if there is no such 12281 GL material. 12282 12283 """ 12284 return None

12285 -def gwy_gl_materials( ):

12286 """ 12287 Gets inventory with all the GL materials. 12288 12289 12290 @return: GL material inventory. 12291 12292 """ 12293 return None

12294 -def gwy_gl_materials_get_gl_material( name ):

12295 """ 12296 Convenience function to get a GL material from L{gwy_gl_materials}() by name. 12297 12298 12299 @param name: GL material name. May be B{C{NULL}} to get the default GL material. I{(string)} 12300 @return: GL material identified by B{C{name}} or the default GL material if B{C{name}} 12301 does not exist. 12302 12303 """ 12304 return None

12305 -def z_UNIMPLEMENTED_gwy_gradient_get_type( ):

12306 return None

12307 -def gwy_gradient_selection_get_active( selection ):

12308 """ 12309 Gets the name of currently selected gradient of a selection button. 12310 12311 12312 @param selection: Gradient selection button. I{(L{gtk.Widget})} 12313 @return: Name as a string owned by the selected gradient. 12314 12315 """ 12316 return None

12317 -def gwy_gradient_selection_set_active( selection , active ):

12318 """ 12319 Sets the currently selected gradient of a selection button. 12320 12321 @param selection: Gradient selection button. I{(L{gtk.Widget})} 12322 @param active: Gradient name to be shown as currently selected. I{(string)} 12323 @return: 12324 """ 12325 return None

12326 -def gwy_gradient_tree_view_set_active( treeview , active ):

12327 """ 12328 Selects a gradient in a gradient list and scrolls to make it visible. 12329 12330 12331 @param treeview: A gradient selector tree view. I{(L{gtk.Widget})} 12332 @param active: Gradient name to be shown as currently selected. I{(string)} 12333 @return: B{C{True}} if B{C{active}} was selected, B{C{False}} if there is no such 12334 gradient. 12335 12336 """ 12337 return None

12338 -def gwy_gradients( ):

12339 """ 12340 Gets inventory with all the gradients. 12341 12342 12343 @return: Gradient inventory. 12344 12345 """ 12346 return None

12347 -def gwy_gradients_get_gradient( name ):

12348 """ 12349 Convenience function to get a gradient from L{gwy_gradients}() by name. 12350 12351 12352 @param name: Gradient name. May be B{C{NULL}} to get the default gradient. I{(string)} 12353 @return: Gradient identified by B{C{name}} or the default gradient if B{C{name}} does 12354 not exist. 12355 12356 """ 12357 return None

12358 -def z_UNIMPLEMENTED_gwy_grain_quantity_get_type( ):

12359 return None

12360 -def z_UNIMPLEMENTED_gwy_grain_value_flags_get_type( ):

12361 return None

12362 -def z_UNIMPLEMENTED_gwy_grain_value_group_get_type( ):

12363 return None

12364 -def z_UNIMPLEMENTED_gwy_grain_value_store_column_get_type( ):

12365 return None

12366 -def z_UNIMPLEMENTED_gwy_graph_area_get_type( ):

12367 return None

12368 -def z_UNIMPLEMENTED_gwy_graph_corner_get_type( ):

12369 return None

12370 -def z_UNIMPLEMENTED_gwy_graph_curve_model_get_type( ):

12371 return None

12372 -def z_UNIMPLEMENTED_gwy_graph_curve_type_get_enum( ):

12373 """ 12374 Returns B{C{Enum}} for B{C{GraphCurveType}} enum type. 12375 12376 12377 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 12378 12379 """ 12380 return None

12381 -def z_UNIMPLEMENTED_gwy_graph_curve_type_get_type( ):

12382 return None

12383 -def z_UNIMPLEMENTED_gwy_graph_curves_get_type( ):

12384 return None

12385 -def z_UNIMPLEMENTED_gwy_graph_data_get_type( ):

12386 return None

12387 -def z_UNIMPLEMENTED_gwy_graph_draw_curve( drawable , gc , specs , gcmodel ):

12388 """ 12389 Draws a single graph curve on a drawable. 12390 12391 @param drawable: A drawable. I{(GdkDrawable*)} 12392 @param gc: Graphics context. 12393 It is modified by this function unpredictably. I{(GdkGC*)} 12394 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12395 @param gcmodel: Curve model of the curve to draw. I{(GraphCurveModel*)} 12396 @return: 12397 """ 12398 return None

12399 -def z_UNIMPLEMENTED_gwy_graph_draw_grid( drawable , gc , specs , nxdata , x_grid_data , nydata , y_grid_data ):

12400 """ 12401 Draws an array of grid lines on a drawable. 12402 12403 @param drawable: A drawable. I{(GdkDrawable*)} 12404 @param gc: Graphics context. 12405 It is modified by this function unpredictably. I{(GdkGC*)} 12406 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12407 @param nxdata: Number of x grid positions. I{(int)} 12408 @param x_grid_data: Array of grid data for the x-axis, it can be B{C{NULL}} if 12409 B{C{nxdata}} is zero. I{(const-gdouble*)} 12410 @param nydata: Number of y grid positions. I{(int)} 12411 @param y_grid_data: Array of grid data for the y-axis, it can be B{C{NULL}} if 12412 B{C{nydata}} is zero. I{(const-gdouble*)} 12413 @return: 12414 """ 12415 return None

12416 -def z_UNIMPLEMENTED_gwy_graph_draw_line( drawable , gc , x_from , y_from , x_to , y_to , line_style , size , color ):

12417 """ 12418 Draws a line segment on a drawable. 12419 12420 @param drawable: A drawable. I{(GdkDrawable*)} 12421 @param gc: Graphics context. 12422 It is modified by this function unpredictably. I{(GdkGC*)} 12423 @param x_from: x coordinate of the start point of the line I{(int)} 12424 @param y_from: y coordinate of the start point of the line I{(int)} 12425 @param x_to: x coordinate of the end point of the line I{(int)} 12426 @param y_to: y coordinate of the end point of the line I{(int)} 12427 @param line_style: graph line style I{(GdkLineStyle)} 12428 @param size: point size I{(int)} 12429 @param color: point color I{(const-RGBA*)} 12430 @return: 12431 """ 12432 return None

12433 -def gwy_graph_draw_point( drawable , gc , x , y , type , size , color ):

12434 """ 12435 Draws a point on a drawable. 12436 12437 @param drawable: A drawable. I{(GdkDrawable*)} 12438 @param gc: Graphics context. 12439 It is modified by this function unpredictably. I{(GdkGC*)} 12440 @param x: X coordinate of the point. I{(int)} 12441 @param y: Y coordinate of the point. I{(int)} 12442 @param type: graph point type I{(GraphPointType)} 12443 @param size: point size I{(int)} 12444 @param color: point color I{(const-RGBA*)} 12445 @return: 12446 """ 12447 return None

12448 -def z_UNIMPLEMENTED_gwy_graph_draw_selection_areas( drawable , gc , specs , selection ):

12449 """ 12450 Draws selected area on a drawable. 12451 12452 @param drawable: A drawable. I{(GdkDrawable*)} 12453 @param gc: Graphics context. 12454 It is modified by this function unpredictably. I{(GdkGC*)} 12455 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12456 @param selection: A selection of type B{C{SelectionGraphArea}}. I{(SelectionGraphArea*)} 12457 @return: 12458 """ 12459 return None

12460 -def z_UNIMPLEMENTED_gwy_graph_draw_selection_lines( drawable , gc , specs , selection , orientation ):

12461 """ 12462 Draws selected lines on a drawable. 12463 12464 @param drawable: A drawable. I{(GdkDrawable*)} 12465 @param gc: Graphics context. 12466 It is modified by this function unpredictably. I{(GdkGC*)} 12467 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12468 @param selection: a B{C{SelectionGraphLine}} structure I{(SelectionGraphLine*)} 12469 @param orientation: horizontal or vertical orientation I{(GtkOrientation)} 12470 @return: 12471 """ 12472 return None

12473 -def z_UNIMPLEMENTED_gwy_graph_draw_selection_points( drawable , gc , specs , selection ):

12474 """ 12475 Draws selection points on a drawable. 12476 12477 @param drawable: A drawable. I{(GdkDrawable*)} 12478 @param gc: Graphics context. I{(GdkGC*)} 12479 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12480 @param selection: A selection of type B{C{SelectionGraphPoint}}. I{(SelectionGraphPoint*)} 12481 @return: 12482 """ 12483 return None

12484 -def z_UNIMPLEMENTED_gwy_graph_draw_selection_xareas( drawable , gc , specs , selection ):

12485 """ 12486 Draws selected x-area on a drawable. 12487 12488 @param drawable: A drawable. I{(GdkDrawable*)} 12489 @param gc: Graphics context. 12490 It is modified by this function unpredictably. I{(GdkGC*)} 12491 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12492 @param selection: A selection of type B{C{SelectionGraph1DArea}}. I{(SelectionGraph1DArea*)} 12493 @return: 12494 """ 12495 return None

12496 -def z_UNIMPLEMENTED_gwy_graph_draw_selection_yareas( drawable , gc , specs , selection ):

12497 """ 12498 Drawss selected y-area on a drawable. 12499 12500 @param drawable: A drawable. I{(GdkDrawable*)} 12501 @param gc: Graphics context. 12502 It is modified by this function unpredictably. I{(GdkGC*)} 12503 @param specs: Specifications (boundaries) of the active area of the graph. I{(GraphActiveAreaSpecs*)} 12504 @param selection: A selection of type B{C{SelectionGraph1DArea}}. I{(SelectionGraph1DArea*)} 12505 @return: 12506 """ 12507 return None

12508 -def gwy_graph_func_exists( name ):

12509 """ 12510 Checks whether a graph function exists. 12511 12512 12513 @param name: Graph function name. I{(string)} 12514 @return: B{C{True}} if function B{C{name}} exists, B{C{False}} otherwise. 12515 12516 """ 12517 return None

12518 -def z_UNIMPLEMENTED_gwy_graph_func_foreach( function , user_data ):

12519 """ 12520 Calls a function for each graph function. 12521 12522 @param function: Function to run for each graph function. It will get function 12523 name (constant string owned by module system) as its first 12524 argument, B{C{user_data}} as the second argument. I{(GFunc)} 12525 @param user_data: Data to pass to B{C{function}}. I{(gpointer)} 12526 @return: 12527 """ 12528 return None

12529 -def gwy_graph_func_get_menu_path( name ):

12530 """ 12531 Gets menu path of a graph function. 12532 12533 The returned menu path is only the tail part registered by the function, 12534 i.e., without any leading "/Graph". 12535 12536 12537 @param name: Graph function name. I{(string)} 12538 @return: The menu path. The returned string is owned by the module. 12539 12540 """ 12541 return None

12542 -def gwy_graph_func_get_sensitivity_mask( name ):

12543 """ 12544 Gets menu sensititivy mask for a graph function. 12545 12546 12547 @param name: Graph function name. I{(string)} 12548 @return: The menu item sensitivity mask (a combination of B{C{MenuSensFlags}} 12549 flags). 12550 12551 """ 12552 return None

12553 -def gwy_graph_func_get_stock_id( name ):

12554 """ 12555 Gets stock icon id of a graph function. 12556 12557 12558 @param name: Graph function name. I{(string)} 12559 @return: The stock icon id. The returned string is owned by the module. 12560 12561 """ 12562 return None

12573 -def z_UNIMPLEMENTED_gwy_graph_func_register( name , func , menu_path , stock_id , sens_mask , tooltip ):

12574 """ 12575 Registers a graph function. 12576 12577 Note: the string arguments are not copied as modules are not expected to 12578 vanish. If they are constructed (non-constant) strings, do not free them. 12579 Should modules ever become unloadable they will get chance to clean-up. 12580 12581 12582 @param name: Name of function to register. It should be a valid identifier and 12583 if a module registers only one function, module and function names 12584 should be the same. I{(string)} 12585 @param func: The function itself. I{(GraphFunc)} 12586 @param menu_path: Menu path under Graph menu. The menu path should be 12587 marked translatabe, but passed untranslated (to allow merging 12588 of translated and untranslated submenus). I{(string)} 12589 @param stock_id: Stock icon id for toolbar. I{(string)} 12590 @param sens_mask: Sensitivity mask (a combination of B{C{MenuSensFlags}} flags). 12591 Usually it is equal to B{C{MENU_FLAG_GRAPH}}, but it's 12592 possible to set other requirements. I{(int)} 12593 @param tooltip: Tooltip for this function. I{(string)} 12594 @return: Normally B{C{True}}; B{C{False}} on failure. 12595 12596 """ 12597 return None

12598 -def gwy_graph_func_run( name , graph ):

12599 """ 12600 Runs a graph function identified by B{C{name}}. 12601 12602 @param name: Graph function name. I{(string)} 12603 @param graph: Graph (a B{C{Graph}}). I{(L{Graph})} 12604 @return: 12605 """ 12606 return None

12607 -def gwy_graph_get_n_preset_colors( ):

12608 """ 12609 Gets the number of distinct colors L{Graph.get_preset_color}() can return. 12610 12611 12612 @return: The number of distinct colors. 12613 12614 """ 12615 return None

12616 -def gwy_graph_get_preset_color( i ):

12617 """ 12618 Gets a preset graph color. 12619 12620 Preset colors are a set of selected colors one can use to distingush graph 12621 curves when there is no reason to prefer a particular color. Note they 12622 can occasionally change between version, even their number can change. 12623 12624 12625 @param i: Color number, starting from 0 which is always black. It can be any 12626 number but colors start to repeat after 12627 L{Graph.get_n_preset_colors}() colors. I{(int)} 12628 @return: A constant color that must not be neither modified nor freed. 12629 12630 """ 12631 return None

12632 -def z_UNIMPLEMENTED_gwy_graph_get_type( ):

12633 return None

12634 -def z_UNIMPLEMENTED_gwy_graph_grid_type_get_type( ):

12635 return None

12636 -def z_UNIMPLEMENTED_gwy_graph_label_get_type( ):

12637 return None

12638 -def z_UNIMPLEMENTED_gwy_graph_label_position_get_type( ):

12639 return None

12640 -def z_UNIMPLEMENTED_gwy_graph_model_export_style_get_type( ):

12641 return None

12642 -def z_UNIMPLEMENTED_gwy_graph_model_get_type( ):

12643 return None

12644 -def z_UNIMPLEMENTED_gwy_graph_point_type_get_type( ):

12645 return None

12646 -def z_UNIMPLEMENTED_gwy_graph_status_type_get_type( ):

12647 return None

12648 -def gwy_graph_window_class_get_tooltips( ):

12649 """ 12650 Gets the tooltips object used for adding tooltips to Graph window parts. 12651 12652 12653 @return: The B{C{GtkTooltips}} object. (Do not free). 12654 12655 """ 12656 return None

12657 -def gwy_graph_window_class_set_tooltips( tips ):

12658 """ 12659 Sets the tooltips object to use for adding tooltips to graph window parts. 12660 12661 This is a class method. It affects only newly created graph windows, 12662 existing graph windows will continue to use the tooltips they were 12663 constructed with. 12664 12665 If no class tooltips object is set before first B{C{GraphWindow}} is created, 12666 the class instantiates one on its own. You can normally obtain it with 12667 L{Graph.window_class_get_tooltips}() then. The class takes a reference on 12668 the tooltips in either case. 12669 12670 @param tips: B{C{GtkTooltips}} object B{C{GraphWindow}} should use for setting tooltips. 12671 A B{C{NULL}} value disables tooltips altogether. I{(L{gtk.Tooltips})} 12672 @return: 12673 """ 12674 return None

12675 -def z_UNIMPLEMENTED_gwy_graph_window_get_type( ):

12676 return None

12677 -def z_UNIMPLEMENTED_gwy_hash_table_to_list_cb( unused_key , value , user_data ):

12678 """ 12679 B{C{GHashTable}} to B{C{GList}} convertor. 12680 12681 Usble in g_hash_table_foreach(), pass a pointer to a B{C{GList}}* as user 12682 data to it. 12683 12684 @param unused_key: Hash key (unused). I{(gpointer)} 12685 @param value: Hash value. I{(gpointer)} 12686 @param user_data: User data (a pointer to B{C{GList}}*). I{(gpointer)} 12687 @return: 12688 """ 12689 return None

12690 -def z_UNIMPLEMENTED_gwy_hash_table_to_slist_cb( unused_key , value , user_data ):

12691 """ 12692 B{C{GHashTable}} to B{C{GSList}} convertor. 12693 12694 Usble in g_hash_table_foreach(), pass a pointer to a B{C{GSList}}* as user 12695 data to it. 12696 12697 @param unused_key: Hash key (unused). I{(gpointer)} 12698 @param value: Hash value. I{(gpointer)} 12699 @param user_data: User data (a pointer to B{C{GSList}}*). I{(gpointer)} 12700 @return: 12701 """ 12702 return None

12703 -def z_UNIMPLEMENTED_gwy_hmarker_box_get_type( ):

12704 return None

12705 -def z_UNIMPLEMENTED_gwy_hruler_get_type( ):

12706 return None

12707 -def z_UNIMPLEMENTED_gwy_hscale_style_get_type( ):

12708 return None

12709 -def gwy_interpolation_get_dval( x , x1_ , y1_ , x2_ , y2_ , interpolation ):

12710 """ 12711 This function uses two-point interpolation 12712 methods to get interpolated value between 12713 two arbitrary data points. 12714 12715 12716 @param x: requested value coordinate I{(float)} 12717 @param x1_: x coordinate of first value I{(float)} 12718 @param y1_: y coordinate of first value I{(float)} 12719 @param x2_: x coordinate of second value I{(float)} 12720 @param y2_: y coordinate of second value I{(float)} 12721 @param interpolation: interpolation type I{(InterpolationType)} 12722 @return: interpolated value 12723 12724 """ 12725 return None

12726 -def z_UNIMPLEMENTED_gwy_interpolation_get_dval_of_equidists( x , data , interpolation ):

12727 """ 12728 Computes interpolated value from 2 or 4 equidistant values. 12729 12730 For B{C{INTERPOLATION_NONE}} no B{C{data}} value is actually used, and zero is 12731 returned. 12732 12733 For B{C{INTERPOLATION_ROUND}} or B{C{INTERPOLATION_LINEAR}} 12734 it is enough to set middle two B{C{data}} values, that to use B{C{data}} in format 12735 {0, data[i], data[i+1], 0} and function computes value at data[i+x] 12736 (the outer values are not used). 12737 12738 For four value interpolations you have to prepare B{C{data}} as 12739 {data[i-1], data[i], data[i+1], data[i+2]} and function again 12740 returns value at data[i+x]. 12741 12742 Interpolation with non-interpolating bases are silently replaced with an 12743 interpolating function with the same support size. See 12744 L{gwy_interpolation_interpolate_1d}() for a function interpolating from 12745 interpolation coefficients. 12746 12747 12748 @param x: Possibily noninteger position in B{C{data}} to get value at. I{(float)} 12749 @param data: Array of 4 values to interpolate between (see below). I{(gdouble*)} 12750 @param interpolation: Interpolation type to use. I{(InterpolationType)} 12751 @return: Interpolated value. 12752 12753 """ 12754 return None

12755 -def gwy_interpolation_get_support_size( interpolation ):

12756 """ 12757 Obtains the basis support size for an interpolation type. 12758 12759 Since: 2.2 12760 12761 @param interpolation: Interpolation type. I{(InterpolationType)} 12762 @return: The length of the support interval of the interpolation basis. 12763 12764 12765 """ 12766 return None

12767 -def gwy_interpolation_has_interpolating_basis( interpolation ):

12768 """ 12769 Obtains the interpolating basis property of an inteprolation type. 12770 12771 Interpolation types with inteprolating basis directly use data values 12772 for interpolation. For these types L{gwy_interpolation_resolve_coeffs_1d}() 12773 and L{gwy_interpolation_resolve_coeffs_2d}() are no-op. 12774 12775 Generalized interpolation types (with non-interpolation basis) require to 12776 preprocess the data values to obtain interpolation coefficients first. On 12777 the ohter hand they typically offer much higher interpolation quality. 12778 12779 Since: 2.2 12780 12781 @param interpolation: Interpolation type. I{(InterpolationType)} 12782 @return: B{C{True}} if the inteprolation type has interpolating basis, 12783 B{C{False}} if data values cannot be directly used for interpolation 12784 of this type. 12785 12786 12787 """ 12788 return None

12789 -def gwy_interpolation_interpolate_1d( x , coeff , interpolation ):

12790 """ 12791 Interpolates a signle data point in one dimension. 12792 12793 The interpolation basis support size can be obtained generically with 12794 L{gwy_interpolation_get_support_size}(). 12795 12796 Since: 2.2 12797 12798 @param x: Position in interval [0,1) to get value at. I{(float)} 12799 @param coeff: Array of support-length size with interpolation coefficients 12800 (that are equal to data values for an interpolating basis). I{(const-gdouble*)} 12801 @param interpolation: Interpolation type to use. I{(InterpolationType)} 12802 @return: Interpolated value. 12803 12804 12805 """ 12806 return None

12807 -def gwy_interpolation_interpolate_2d( x , y , rowstride , coeff , interpolation ):

12808 """ 12809 Interpolates a signle data point in two dimensions. 12810 12811 Since: 2.2 12812 12813 @param x: X-position in interval [0,1) to get value at. I{(float)} 12814 @param y: Y-position in interval [0,1) to get value at. I{(float)} 12815 @param rowstride: Row stride of B{C{coeff}}. I{(int)} 12816 @param coeff: Array of support-length-squared size with interpolation coefficients 12817 (that are equal to data values for an interpolating basis). I{(const-gdouble*)} 12818 @param interpolation: Interpolation type to use. I{(InterpolationType)} 12819 @return: Interpolated value. 12820 12821 12822 """ 12823 return None

12824 -def z_UNIMPLEMENTED_gwy_interpolation_resample_block_1d( length , data , newlength , newdata , interpolation , preserve ):

12825 """ 12826 Resamples a one-dimensional data array. 12827 12828 This is a primitive operation, in most cases methods such as 12829 L{DataLine.new_resampled}() provide more convenient interface. 12830 12831 Since: 2.2 12832 12833 @param length: Data block length. I{(int)} 12834 @param data: Data block to resample. I{(gdouble*)} 12835 @param newlength: Requested length after resampling. I{(int)} 12836 @param newdata: Array to put the resampled data to. I{(gdouble*)} 12837 @param interpolation: Interpolation type to use. I{(InterpolationType)} 12838 @param preserve: B{C{True}} to preserve the content of B{C{data}}, B{C{False}} to permit its 12839 overwriting with temporary data. I{(bool)} 12840 @return: 12841 """ 12842 return None

12843 -def z_UNIMPLEMENTED_gwy_interpolation_resample_block_2d( width , height , rowstride , data , newwidth , newheight , newrowstride , newdata , interpolation , preserve ):

12844 """ 12845 Resamples a two-dimensional data array. 12846 12847 This is a primitive operation, in most cases methods such as 12848 L{DataField.new_resampled}() provide more convenient interface. 12849 12850 Since: 2.2 12851 12852 @param width: Number of columns in B{C{data}}. I{(int)} 12853 @param height: Number of rows in B{C{data}}. I{(int)} 12854 @param rowstride: Total row length (including B{C{width}}). I{(int)} 12855 @param data: Data block to resample. I{(gdouble*)} 12856 @param newwidth: Requested number of columns after resampling. I{(int)} 12857 @param newheight: Requested number of rows after resampling. I{(int)} 12858 @param newrowstride: Requested total row length after resampling (including 12859 B{C{newwidth}}). I{(int)} 12860 @param newdata: Array to put the resampled data to. I{(gdouble*)} 12861 @param interpolation: Interpolation type to use. I{(InterpolationType)} 12862 @param preserve: B{C{True}} to preserve the content of B{C{data}}, B{C{False}} to permit its 12863 overwriting with temporary data. I{(bool)} 12864 @return: 12865 """ 12866 return None

12867 -def z_UNIMPLEMENTED_gwy_interpolation_resolve_coeffs_1d( n , data , interpolation ):

12868 """ 12869 Transforms data values in a one-dimensional array to interpolation 12870 coefficients. 12871 12872 This function is no-op for interpolation types with finite-support 12873 interpolating function. Therefore you can also omit it and use the data 12874 array directly for these interpolation types. 12875 12876 Since: 2.2 12877 12878 @param n: Number of points in B{C{data}}. I{(int)} 12879 @param data: An array of data values. It will be rewritten with the coefficients. I{(gdouble*)} 12880 @param interpolation: Interpolation type to prepare B{C{data}} for. I{(InterpolationType)} 12881 @return: 12882 """ 12883 return None

12884 -def z_UNIMPLEMENTED_gwy_interpolation_resolve_coeffs_2d( width , height , rowstride , data , interpolation ):

12885 """ 12886 Transforms data values in a two-dimensional array to interpolation 12887 coefficients. 12888 12889 This function is no-op for interpolation types with finite-support 12890 interpolating function. Therefore you can also omit it and use the data 12891 array directly for these interpolation types. 12892 12893 Since: 2.2 12894 12895 @param width: Number of columns in B{C{data}}. I{(int)} 12896 @param height: Number of rows in B{C{data}}. I{(int)} 12897 @param rowstride: Total row length (including B{C{width}}). I{(int)} 12898 @param data: An array of data values. It will be rewritten with the coefficients. I{(gdouble*)} 12899 @param interpolation: Interpolation type to prepare B{C{data}} for. I{(InterpolationType)} 12900 @return: 12901 """ 12902 return None

12903 -def z_UNIMPLEMENTED_gwy_interpolation_shift_block_1d( length , data , offset , newdata , interpolation , exterior , fill_value , preserve ):

12904 """ 12905 Shifts a one-dimensional data block by a possibly non-integer offset. 12906 12907 Since: 2.2 12908 12909 @param length: Data block length. I{(int)} 12910 @param data: Data block to shift. I{(gdouble*)} 12911 @param offset: The shift, in corrective sense. Shift value of 1.0 means the 12912 zeroth value of B{C{newdata}} will be set to the first value of B{C{data}}. I{(float)} 12913 @param newdata: Array to put the shifted data to. I{(gdouble*)} 12914 @param interpolation: Interpolation type to use. I{(InterpolationType)} 12915 @param exterior: Exterior pixels handling. I{(ExteriorType)} 12916 @param fill_value: The value to use with B{C{EXTERIOR_FIXED_VALUE}}. I{(float)} 12917 @param preserve: B{C{True}} to preserve the content of B{C{data}}, B{C{False}} to permit its 12918 overwriting with temporary data. I{(bool)} 12919 @return: 12920 """ 12921 return None

12922 -def z_UNIMPLEMENTED_gwy_interpolation_type_get_enum( ):

12923 """ 12924 Returns B{C{Enum}} for B{C{InterpolationType}} enum type. 12925 12926 12927 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 12928 12929 """ 12930 return None

12931 -def z_UNIMPLEMENTED_gwy_interpolation_type_get_type( ):

12932 return None

12933 -def z_UNIMPLEMENTED_gwy_inventory_get_type( ):

12934 return None

12935 -def z_UNIMPLEMENTED_gwy_inventory_new_filled( itype , nitems , items ):

12936 """ 12937 Creates a new inventory and fills it with items. 12938 12939 12940 @param itype: Type of items the inventory will contain. I{(const-InventoryItemType*)} 12941 @param nitems: The number of pointers in B{C{items}}. I{(int)} 12942 @param items: Item pointers to fill the newly created inventory with. I{(gpointer*)} 12943 @return: The newly created inventory. 12944 12945 """ 12946 return None

12947 -def z_UNIMPLEMENTED_gwy_inventory_new_from_array( itype , item_size , nitems , items ):

12948 """ 12949 Creates a new inventory from static item array. 12950 12951 The inventory is neither modifiable nor sortable, it simply serves as an 12952 adaptor for the array B{C{items}}. 12953 12954 12955 @param itype: Type of items the inventory will contain. Inventory keeps a copy 12956 of it, so it can be an automatic variable. I{(const-InventoryItemType*)} 12957 @param item_size: Item size in bytes. I{(int)} 12958 @param nitems: The number of items in B{C{items}}. I{(int)} 12959 @param items: An array with items. It will be directly used as thus must 12960 exist through the whole lifetime of inventory. I{(gconstpointer)} 12961 @return: The newly created inventory. 12962 12963 """ 12964 return None

12965 -def z_UNIMPLEMENTED_gwy_inventory_store_get_type( ):

12966 return None

12967 -def gwy_label_new_header( text ):

12968 """ 12969 Creates a bold, left aligned label. 12970 12971 The purpose of this function is to avoid propagation of too much markup to 12972 translations (and to reduce code clutter by avoiding dummy constructor and 12973 left-aligning automatically). 12974 12975 12976 @param text: Text to put into the label. It must be a valid markup and it will 12977 be made bold by adding appropriate markup around it. I{(string)} 12978 @return: A newly created B{C{GtkLabel}}. 12979 12980 """ 12981 return None

12982 -def z_UNIMPLEMENTED_gwy_layer_basic_get_type( ):

12983 return None

12984 -def z_UNIMPLEMENTED_gwy_layer_basic_range_type_get_type( ):

12985 return None

12986 -def z_UNIMPLEMENTED_gwy_layer_func_foreach( function , user_data ):

12987 """ 12988 Calls a function for each layer function. 12989 12990 @param function: Function to run for each layer function. It will get function 12991 name (constant string owned by module system) as its first 12992 argument, B{C{user_data}} as the second argument. I{(GFunc)} 12993 @param user_data: Data to pass to B{C{function}}. I{(gpointer)} 12994 @return: 12995 """ 12996 return None

12997 -def gwy_layer_func_register( type ):

12998 """ 12999 Registeres a layer function (layer type). 13000 13001 13002 @param type: Layer type in GObject type system. That is the return value of 13003 L{gwy_layer_foo_get_type}(). I{(GType)} 13004 @return: Normally B{C{True}}; B{C{False}} on failure. 13005 13006 """ 13007 return None

13008 -def z_UNIMPLEMENTED_gwy_layer_line_restrict_angle( data_view , endpoint , x , y , xy ):

13009 return None

13010 -def z_UNIMPLEMENTED_gwy_layer_mask_get_type( ):

13011 return None

13012 -def z_UNIMPLEMENTED_gwy_line_stat_quantity_get_type( ):

13013 return None

13014 -def z_UNIMPLEMENTED_gwy_list_store_row_changed( store , iter , path , row ):

13015 """ 13016 Convenience function to emit "GtkTreeModel::row-changed" signal on a tree 13017 store. 13018 13019 At least one of B{C{iter}}, B{C{path}}, B{C{row}} must be set to identify the row to emit 13020 "row-changed" on, and usually exactly one should be set. The remaining 13021 information necessary to call gtk_tree_model_row_changed() is inferred 13022 automatically. 13023 13024 The behaviour of this function is undefined for specified, but inconsistent 13025 B{C{iter}}, B{C{path}}, and B{C{row}}. 13026 13027 @param store: A list store. I{(GtkListStore*)} 13028 @param iter: A tree model iterator in B{C{store}}, or B{C{NULL}} for none. I{(GtkTreeIter*)} 13029 @param path: A tree model path in B{C{store}}, or B{C{NULL}} for none. I{(GtkTreePath*)} 13030 @param row: A row number in B{C{store}}, or -1 for none. I{(int)} 13031 @return: 13032 """ 13033 return None

13034 -def z_UNIMPLEMENTED_gwy_marker_box_get_type( ):

13035 return None

13036 -def z_UNIMPLEMENTED_gwy_marker_operation_type_get_type( ):

13037 return None

13038 -def gwy_mask_color_selector_run( dialog_title , parent , color_button , container , prefix ):

13039 """ 13040 Creates and runs a color selector dialog for a mask. 13041 13042 Note this function does not return anything, it runs the color selection 13043 dialog modally and returns when it is finished. 13044 13045 Since: 2.1 13046 13047 @param dialog_title: Title of the color selection dialog (B{C{NULL}} to use default). I{(string)} 13048 @param parent: Dialog parent window. The color selector dialog will be made 13049 transient for this window. I{(L{gtk.Window})} 13050 @param color_button: Color button to update on color change (or B{C{NULL}}). I{(ColorButton*)} 13051 @param container: Container to initialize the color from and save it to. I{(L{Container})} 13052 @param prefix: Prefix in B{C{container}} (normally "/0/mask"). I{(string)} 13053 @return: 13054 """ 13055 return None

13056 -def z_UNIMPLEMENTED_gwy_masking_type_get_enum( ):

13057 """ 13058 Returns B{C{Enum}} for B{C{MaskingType}} enum type. 13059 13060 Since: 2.18 13061 13062 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 13063 13064 13065 """ 13066 return None

13067 -def z_UNIMPLEMENTED_gwy_masking_type_get_type( ):

13068 return None

13069 -def z_UNIMPLEMENTED_gwy_math_choleski_decompose( n , matrix ):

13070 """ 13071 Decomposes a symmetric positive definite matrix in place. 13072 13073 13074 @param n: The dimension of B{C{a}}. I{(int)} 13075 @param matrix: Lower triangular part of a symmetric matrix, stored by rows, i.e., 13076 matrix = [a_00 a_10 a_11 a_20 a_21 a_22 a_30 ...]. I{(gdouble*)} 13077 @return: Whether the matrix was really positive definite. If B{C{False}}, 13078 the decomposition failed and B{C{a}} does not contain any meaningful 13079 values. 13080 13081 """ 13082 return None

13083 -def z_UNIMPLEMENTED_gwy_math_choleski_solve( n , decomp , rhs ):

13084 """ 13085 Solves a system of linear equations with predecomposed symmetric positive 13086 definite matrix B{C{a}} and right hand side B{C{b}}. 13087 13088 @param n: The dimension of B{C{a}}. I{(int)} 13089 @param decomp: Lower triangular part of Choleski decomposition as computed 13090 by L{gwy_math_choleski_decompose}(). I{(const-gdouble*)} 13091 @param rhs: Right hand side vector. Is is modified in place, on return it 13092 contains the solution. I{(gdouble*)} 13093 @return: 13094 """ 13095 return None

13096 -def z_UNIMPLEMENTED_gwy_math_curvature( coeffs , kappa1 , kappa2 , phi1 , phi2 , xc , yc , zc ):

13097 return None

13098 -def z_UNIMPLEMENTED_gwy_math_find_nearest_line( x , y , d2min , n , coords , metric ):

13099 """ 13100 Finds the line from B{C{coords}} nearest to the point (B{C{x}}, B{C{y}}). 13101 13102 13103 @param x: X-coordinate of the point to search. I{(float)} 13104 @param y: Y-coordinate of the point to search. I{(float)} 13105 @param d2min: Where to store the squared minimal distance, or B{C{NULL}}. I{(gdouble*)} 13106 @param n: The number of lines (i.e. B{C{coords}} has 4B{C{n}} items). I{(int)} 13107 @param coords: Line coordinates stored as x00, y00, x01, y01, x10, y10, etc. I{(const-gdouble*)} 13108 @param metric: Metric matrix (2x2, but stored sequentially by rows: m11, m12, 13109 m21, m22), it must be positive definite. Vector norm is then 13110 calculated as m11*x*x + (m12 + m21)*x*y + m22*y*y. 13111 It can be B{C{NULL}}, standard Euclidean metric is then used. I{(const-gdouble*)} 13112 @return: The line number. It may return -1 if (B{C{x}}, B{C{y}}) doesn't lie 13113 in the orthogonal stripe of any of the lines. 13114 13115 """ 13116 return None

13117 -def z_UNIMPLEMENTED_gwy_math_find_nearest_point( x , y , d2min , n , coords , metric ):

13118 """ 13119 Finds the point from B{C{coords}} nearest to the point (B{C{x}}, B{C{y}}). 13120 13121 13122 @param x: X-coordinate of the point to search. I{(float)} 13123 @param y: Y-coordinate of the point to search. I{(float)} 13124 @param d2min: Location to store the squared minimal distance to, or B{C{NULL}}. I{(gdouble*)} 13125 @param n: The number of points (i.e. B{C{coords}} has 2B{C{n}} items). I{(int)} 13126 @param coords: Point coordinates stored as x0, y0, x1, y1, x2, y2, etc. I{(const-gdouble*)} 13127 @param metric: Metric matrix (2x2, but stored sequentially by rows: m11, m12, 13128 m21, m22). Vector norm is then calculated as 13129 m11*x*x + (m12 + m21)*x*y + m22*y*y. 13130 It can be B{C{NULL}}, standard Euclidean metric is then used. I{(const-gdouble*)} 13131 @return: The point number. 13132 13133 """ 13134 return None

13135 -def z_UNIMPLEMENTED_gwy_math_fit_polynom( ndata , xdata , ydata , n , coeffs ):

13136 """ 13137 Fits a polynom through a general (x, y) data set. 13138 13139 13140 @param ndata: The number of items in B{C{xdata}}, B{C{ydata}}. I{(int)} 13141 @param xdata: Independent variable data (of size B{C{ndata}}). I{(const-gdouble*)} 13142 @param ydata: Dependent variable data (of size B{C{ndata}}). I{(const-gdouble*)} 13143 @param n: The degree of polynom to fit. I{(int)} 13144 @param coeffs: An array of size B{C{n}}+1 to store the coefficients to, or B{C{NULL}} 13145 (a fresh array is allocated then). I{(gdouble*)} 13146 @return: The coefficients of the polynom (B{C{coeffs}} when it was not B{C{NULL}}, 13147 otherwise a newly allocated array). 13148 13149 """ 13150 return None

13151 -def z_UNIMPLEMENTED_gwy_math_humanize_numbers( unit , maximum , precision ):

13152 """ 13153 Finds a human-friendly representation for a range of numbers. 13154 13155 13156 @param unit: The smallest possible step. I{(float)} 13157 @param maximum: The maximum possible value. I{(float)} 13158 @param precision: A location to store printf() precession, if not B{C{NULL}}. I{(gint*)} 13159 @return: The magnitude i.e., a power of 1000. 13160 13161 """ 13162 return None

13163 -def gwy_math_is_in_polygon( x , y , poly , n ):

13164 """ 13165 Establishes wether the test point B{C{x}}, B{C{y}} is inside the polygon B{C{poly}}. 13166 The polygon can be defined either clockwise or anti-clockwise and 13167 can be a concave, convex or self-intersecting polygon. 13168 13169 <warning> Result can be either True or False if the test point 13170 is *exactly* on an edge. </warning> 13171 13172 Since: 2.7 13173 13174 @param x: The x coordinate of the test point. I{(float)} 13175 @param y: The y coordinate of the test point. I{(float)} 13176 @param poly: An array of coordinate pairs (points) that define a 13177 polygon. I{(const-gdouble*)} 13178 @param n: The number of corners of the polygon. I{(int)} 13179 @return: True if the test point is inside poly and False otherwise. 13180 13181 13182 """ 13183 return None

13184 -def z_UNIMPLEMENTED_gwy_math_lin_solve( n , matrix , rhs , result ):

13185 """ 13186 Solve a regular system of linear equations. 13187 13188 13189 @param n: The size of the system. I{(int)} 13190 @param matrix: The matrix of the system (B{C{n}} times B{C{n}}), ordered by row, then 13191 column. I{(const-gdouble*)} 13192 @param rhs: The right hand side of the sytem. I{(const-gdouble*)} 13193 @param result: Where the result should be stored. May be B{C{NULL}} to allocate 13194 a fresh array for the result. I{(gdouble*)} 13195 @return: The solution (B{C{result}} if it wasn't B{C{NULL}}), may be B{C{NULL}} if the 13196 matrix is singular. 13197 13198 """ 13199 return None

13200 -def z_UNIMPLEMENTED_gwy_math_lin_solve_rewrite( n , matrix , rhs , result ):

13201 """ 13202 Solves a regular system of linear equations. 13203 13204 This is a memory-conservative version of L{gwy_math_lin_solve}() overwriting 13205 B{C{matrix}} and B{C{rhs}} with intermediate results. 13206 13207 13208 @param n: The size of the system. I{(int)} 13209 @param matrix: The matrix of the system (B{C{n}} times B{C{n}}), ordered by row, then 13210 column. I{(gdouble*)} 13211 @param rhs: The right hand side of the sytem. I{(gdouble*)} 13212 @param result: Where the result should be stored. May be B{C{NULL}} to allocate 13213 a fresh array for the result. I{(gdouble*)} 13214 @return: The solution (B{C{result}} if it wasn't B{C{NULL}}), may be B{C{NULL}} if the 13215 matrix is singular. 13216 13217 """ 13218 return None

13219 -def z_UNIMPLEMENTED_gwy_math_median( n , array ):

13220 """ 13221 Finds median of an array of values using Quick select algorithm. 13222 13223 13224 @param n: Number of items in B{C{array}}. I{(gsize)} 13225 @param array: Array of doubles. It is modified by this function. All values are 13226 kept, but their positions in the array change. I{(gdouble*)} 13227 @return: The median value of B{C{array}}. 13228 13229 """ 13230 return None

13231 -def z_UNIMPLEMENTED_gwy_math_median_uncertainty( n , array , uarray ):

13232 return None

13233 -def z_UNIMPLEMENTED_gwy_math_nlfit_derive( x , n_param , param , fixed_param , ff , user_data , deriv , dres ):

13234 """ 13235 Numerically computes the partial derivative of a fitting function. 13236 13237 @param x: The value to compute the derivative at. I{(float)} 13238 @param n_param: The nuber of parameters. I{(int)} 13239 @param param: Array of parameters (of size B{C{n_param}}). I{(const-gdouble*)} 13240 @param fixed_param: Which parameters should be treated as fixed (corresponding 13241 entries are set to B{C{True}}). I{(const-gboolean*)} 13242 @param ff: The fitted function. I{(NLFitFunc)} 13243 @param user_data: User data as passed to L{gwy_math_nlfit_fit}(). I{(gpointer)} 13244 @param deriv: Array where the put the result to. I{(gdouble*)} 13245 @param dres: Set to B{C{True}} if succeeds, B{C{False}} on failure. I{(gboolean*)} 13246 @return: 13247 """ 13248 return None

13249 -def z_UNIMPLEMENTED_gwy_math_nlfit_fit( nlfit , n_dat , x , y , n_param , param , user_data ):

13250 """ 13251 Performs a nonlinear fit of B{C{nlfit}} function on (B{C{x}},B{C{y}}) data. 13252 13253 13254 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13255 @param n_dat: The number of data points in B{C{x}}, B{C{y}}. I{(int)} 13256 @param x: Array of independent variable values. I{(const-gdouble*)} 13257 @param y: Array of dependent variable values. I{(const-gdouble*)} 13258 @param n_param: The nuber of parameters. I{(int)} 13259 @param param: Array of parameters (of size B{C{n_param}}). Note the parameters must 13260 be initialized to reasonably near values. I{(gdouble*)} 13261 @param user_data: Any pointer that will be passed to the function and derivative 13262 as B{C{user_data}}. I{(gpointer)} 13263 @return: The final residual sum, a negative number in the case of failure. 13264 13265 """ 13266 return None

13267 -def z_UNIMPLEMENTED_gwy_math_nlfit_fit_full( nlfit , n_dat , x , y , weight , n_param , param , fixed_param , link_map , user_data ):

13268 """ 13269 Performs a nonlinear fit of B{C{nlfit}} function on (B{C{x}},B{C{y}}) data, allowing 13270 some fixed parameters. 13271 13272 Initial values of linked (dependent) parameters are overwritten by master 13273 values, their B{C{fixed_param}} property is ignored and master's property 13274 controls whether all are fixed or all variable. 13275 13276 13277 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13278 @param n_dat: The number of data points in B{C{x}}, B{C{y}}, B{C{weight}}. I{(int)} 13279 @param x: Array of independent variable values. I{(const-gdouble*)} 13280 @param y: Array of dependent variable values. I{(const-gdouble*)} 13281 @param weight: Array of weights associated to each data point. Can be B{C{NULL}}, 13282 weight of 1 is then used for all data. I{(const-gdouble*)} 13283 @param n_param: The nuber of parameters. I{(int)} 13284 @param param: Array of parameters (of size B{C{n_param}}). Note the parameters must 13285 be initialized to reasonably near values. I{(gdouble*)} 13286 @param fixed_param: Which parameters should be treated as fixed (set corresponding 13287 element to B{C{True}} for them). May be B{C{NULL}} if all parameters 13288 are variable. I{(const-gboolean*)} 13289 @param link_map: Map of linked parameters. One of linked parameters is master, 13290 Values in this array are indices of corresponding master 13291 parameter for each parameter (for independent parameters set 13292 B{C{link_map}}[i] == i). May be B{C{NULL}} if all parameter are 13293 independent. I{(const-gint*)} 13294 @param user_data: Any pointer that will be passed to the function and derivative I{(gpointer)} 13295 @return: The final residual sum, a negative number in the case of failure. 13296 13297 """ 13298 return None

13299 -def z_UNIMPLEMENTED_gwy_math_nlfit_free( nlfit ):

13300 """ 13301 Completely frees a Marquardt-Levenberg nonlinear fitter. 13302 13303 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13304 @return: 13305 """ 13306 return None

13307 -def z_UNIMPLEMENTED_gwy_math_nlfit_get_correlations( nlfit , par1 , par2 ):

13308 """ 13309 Returns the correlation coefficient between B{C{par1}}-th and B{C{par2}}-th parameter. 13310 13311 This function can be used only after a successful fit. 13312 13313 13314 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13315 @param par1: First parameter index. I{(int)} 13316 @param par2: Second parameter index. I{(int)} 13317 @return: The correlation coefficient. 13318 13319 """ 13320 return None

13321 -def z_UNIMPLEMENTED_gwy_math_nlfit_get_dispersion( nlfit ):

13322 """ 13323 Returns the residual sum divided by the number of degrees of freedom. 13324 13325 This function can be used only after a successful fit. 13326 13327 13328 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13329 @return: The dispersion. 13330 13331 """ 13332 return None

13333 -def z_UNIMPLEMENTED_gwy_math_nlfit_get_max_iterations( nlfit ):

13334 """ 13335 Returns the maximum number of iterations of nonlinear fitter B{C{nlfit}}. 13336 13337 13338 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13339 @return: The maximum number of iterations. 13340 13341 """ 13342 return None

13343 -def z_UNIMPLEMENTED_gwy_math_nlfit_get_sigma( nlfit , par ):

13344 """ 13345 Returns the standard deviation of parameter number B{C{par}}. 13346 13347 This function makes sense only after a successful fit. 13348 13349 13350 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13351 @param par: Parameter index. I{(int)} 13352 @return: The SD of B{C{par}}-th parameter. 13353 13354 """ 13355 return None

13356 -def z_UNIMPLEMENTED_gwy_math_nlfit_set_max_iterations( nlfit , maxiter ):

13357 """ 13358 Sets the maximum number of iterations for nonlinear fitter B{C{nlfit}}. 13359 13360 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13361 @param maxiter: The maximum number of iterations. I{(int)} 13362 @return: 13363 """ 13364 return None

13365 -def z_UNIMPLEMENTED_gwy_math_nlfit_succeeded( nlfit ):

13366 """ 13367 Obtains the status of the last fitting. 13368 13369 Fitting failure can be (and usually should be) also determined by checking 13370 for negative return value of L{gwy_math_nlfit_fit}() or 13371 L{gwy_math_nlfit_fit_full}(). This function allows to test it later. 13372 13373 Since: 2.7 13374 13375 @param nlfit: A Marquardt-Levenberg nonlinear fitter. I{(NLFitter*)} 13376 @return: B{C{True}} if the last fitting suceeded, B{C{False}} if it failed. 13377 13378 13379 """ 13380 return None

13381 -def z_UNIMPLEMENTED_gwy_math_sort( n , array ):

13382 """ 13383 Sorts an array of doubles using a quicksort algorithm. 13384 13385 This is usually about twice as fast as the generic quicksort function 13386 thanks to specialization for doubles. 13387 13388 @param n: Number of items in B{C{array}}. I{(gsize)} 13389 @param array: Array of doubles to sort in place. I{(gdouble*)} 13390 @return: 13391 """ 13392 return None

13393 -def z_UNIMPLEMENTED_gwy_math_tridiag_solve_rewrite( n , d , a , b , rhs ):

13394 """ 13395 Solves a tridiagonal system of linear equations. 13396 13397 13398 @param n: The dimension of B{C{d}}. I{(int)} 13399 @param d: The diagonal of a tridiagonal matrix, its contents will be overwritten. I{(gdouble*)} 13400 @param a: The above-diagonal stripe (it has B{C{n}}-1 elements). I{(const-gdouble*)} 13401 @param b: The below-diagonal stripe (it has B{C{n}}-1 elements). I{(const-gdouble*)} 13402 @param rhs: The right hand side of the system, upon return it will contain the 13403 solution. I{(gdouble*)} 13404 @return: B{C{True}} if the elimination suceeded, B{C{False}} if the system is 13405 (numerically) singular. The contents of B{C{d}} and B{C{rhs}} may be 13406 overwritten in the case of failure too, but not to any meaningful 13407 values. 13408 13409 """ 13410 return None

13411 -def z_UNIMPLEMENTED_gwy_md5_get_digest( buffer , buffer_size , digest16 ):

13412 """ 13413 Compute the MD5 hash of a buffer. 13414 13415 The MD5 algorithm takes as input a message of arbitrary length and 13416 produces as output a 128-bit "fingerprint" or "message digest" of 13417 the input. For more information see RFC 1321. 13418 13419 @param buffer: A byte buffer. I{(string)} 13420 @param buffer_size: Size of B{C{buffer}} (in bytes) or -1 if B{C{buffer}} is nul-terminated. I{(int)} 13421 @param digest: 16 bytes to store the hash code to. 13422 @return: 13423 """ 13424 return None

13425 -def z_UNIMPLEMENTED_gwy_memcpy_byte_swap( source , dest , item_size , nitems , byteswap ):

13426 """ 13427 Copies a block of memory swapping bytes along the way. 13428 13429 The bits in B{C{byteswap}} correspond to groups of bytes to swap: if j-th bit is 13430 set, adjacent groups of 2j bits are swapped. For example, value 3 means 13431 items will be divided into couples (bit 1) of bytes and adjacent couples of 13432 bytes swapped, and then divided into single bytes (bit 0) and adjacent bytes 13433 swapped. The net effect is reversal of byte order in groups of four bytes. 13434 More generally, if you want to reverse byte order in groups of size 13435 2<superscript>j</superscript>, use byte swap pattern j-1. 13436 13437 When B{C{byteswap}} is zero, this function reduces to plain memcpy(). 13438 13439 Since: 2.1 13440 13441 @param source: Source memory block. I{(const-guint8*)} 13442 @param dest: Destination memory location. I{(guint8*)} 13443 @param item_size: Size of one copied item, it should be a power of two. I{(gsize)} 13444 @param nitems: Number of items of size B{C{item_size}} to copy. I{(gsize)} 13445 @param byteswap: Byte swap pattern. I{(gsize)} 13446 @return: 13447 """ 13448 return None

13449 -def z_UNIMPLEMENTED_gwy_memmem( haystack , haystack_len , needle , needle_len ):

13450 """ 13451 Find a block of memory in another block of memory. 13452 13453 This function is very similar to strstr(), except that it works with 13454 arbitrary memory blocks instead of B{C{NUL}}-terminated strings. 13455 13456 If B{C{needle_len}} is zero, B{C{haystack}} is always returned. 13457 13458 On GNU systems with glibc at least 2.1 this is a just a trivial memmem() 13459 wrapper. On other systems it emulates memmem() behaviour. 13460 13461 Since: 2.12 13462 13463 @param haystack: Memory block to search in. I{(gconstpointer)} 13464 @param haystack_len: Size of B{C{haystack}}, in bytes. I{(gsize)} 13465 @param needle: Memory block to find. I{(gconstpointer)} 13466 @param needle_len: Size of B{C{needle}}, in bytes. I{(gsize)} 13467 @return: Pointer to the first byte of memory block in B{C{haystack}} that matches 13468 B{C{needle}}; B{C{NULL}} if no such block exists. 13469 13470 13471 """ 13472 return None

13473 -def z_UNIMPLEMENTED_gwy_menu_gl_material( callback , cbdata ):

13474 """ 13475 Creates a pop-up GL material menu. 13476 13477 Object data <literal>"gl-material-name"</literal> is set to GL material 13478 name for each menu item. 13479 13480 13481 @param callback: A callback called when a menu item is activated (or B{C{NULL}} for 13482 none). I{(GCallback)} 13483 @param cbdata: User data passed to the callback. I{(gpointer)} 13484 @return: The newly created pop-up menu as B{C{GtkWidget}}. 13485 13486 """ 13487 return None

13488 -def z_UNIMPLEMENTED_gwy_menu_gradient( callback , cbdata ):

13489 """ 13490 Creates a pop-up gradient menu. 13491 13492 Object data <literal>"gradient-name"</literal> is set to gradient name for 13493 each menu item. 13494 13495 13496 @param callback: A callback called when a menu item is activated (or B{C{NULL}} for 13497 none). I{(GCallback)} 13498 @param cbdata: User data passed to the callback. I{(gpointer)} 13499 @return: The newly created pop-up menu as B{C{GtkWidget}}. 13500 13501 """ 13502 return None

13503 -def z_UNIMPLEMENTED_gwy_menu_sens_flags_get_type( ):

13504 return None

13505 -def z_UNIMPLEMENTED_gwy_merge_type_get_enum( ):

13506 """ 13507 Returns B{C{Enum}} for B{C{MergeType}} enum type. 13508 13509 13510 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 13511 13512 """ 13513 return None

13514 -def z_UNIMPLEMENTED_gwy_merge_type_get_type( ):

13515 return None

13516 -def gwy_module_browser( ):

13517 """ 13518 Shows a simple module browser. 13519 13520 @return: 13521 """ 13522 return None

13523 -def z_UNIMPLEMENTED_gwy_module_error_get_type( ):

13524 return None

13525 -def gwy_module_error_quark( ):

13526 """ 13527 Returns error domain for module loading. 13528 13529 See and use B{C{MODULE_ERROR}}. 13530 13531 13532 @return: The error domain. 13533 13534 """ 13535 return None

13536 -def z_UNIMPLEMENTED_gwy_module_file_error_get_type( ):

13537 return None

13538 -def gwy_module_file_error_quark( ):

13539 """ 13540 Returns error domain for file module functions. 13541 13542 See and use B{C{MODULE_FILE_ERROR}}. 13543 13544 13545 @return: The error domain. 13546 13547 """ 13548 return None

13549 -def z_UNIMPLEMENTED_gwy_module_foreach( function , data ):

13550 """ 13551 Runs B{C{function}} on each registered module. 13552 13553 It passes module name as the key and pointer to module 13554 info (B{C{ModuleInfo}}) as the value. Neither should be modified. 13555 13556 @param function: A B{C{GHFunc}} run for each module. I{(GHFunc)} 13557 @param data: User data. I{(gpointer)} 13558 @return: 13559 """ 13560 return None

13561 -def gwy_module_get_filename( name ):

13562 """ 13563 Returns full file name of a module. 13564 13565 13566 @param name: A module name. I{(string)} 13567 @return: Module file name as a string that must be modified or freed. 13568 13569 """ 13570 return None

13571 -def z_UNIMPLEMENTED_gwy_module_get_functions( name ):

13572 """ 13573 Returns list of names of functions a module implements. 13574 13575 13576 @param name: A module name. I{(string)} 13577 @return: List of module function names, as a B{C{GSList}} that is owned by 13578 module loader and must not be modified or freed. 13579 13580 """ 13581 return None

13582 -def z_UNIMPLEMENTED_gwy_module_lookup( name ):

13583 """ 13584 Returns information about one module. 13585 13586 13587 @param name: A module name. I{(string)} 13588 @return: The module info, of B{C{NULL}} if not found. It must be considered 13589 constant and never modified or freed. 13590 13591 """ 13592 return None

13593 -def z_UNIMPLEMENTED_gwy_module_register_module( name ):

13594 """ 13595 Loads a single module. 13596 13597 13598 @param name: Module file name to load, including full path and extension. I{(string)} 13599 @return: Module info on success, B{C{NULL}} on failure. 13600 13601 """ 13602 return None

13603 -def z_UNIMPLEMENTED_gwy_module_register_modules( paths ):

13604 """ 13605 Registers all modules in given directories. 13606 13607 It can be called several times (on different directories). No errors are 13608 reported, register modules individually with L{gwy_module_register_module}() 13609 to get registration errors. 13610 13611 @param paths: A B{C{NULL}}-terminated list of directory names. I{(const-gchar**)} 13612 @return: 13613 """ 13614 return None

13615 -def z_UNIMPLEMENTED_gwy_nlfit_preset_get_type( ):

13616 return None

13617 -def gwy_nlfit_presets( ):

13618 """ 13619 Gets inventory with all the NLFit presets. 13620 13621 13622 @return: NLFit preset inventory. 13623 13624 """ 13625 return None

13626 -def z_UNIMPLEMENTED_gwy_null_store_get_type( ):

13627 return None

13628 -def z_UNIMPLEMENTED_gwy_orientation_get_enum( ):

13629 """ 13630 Returns B{C{Enum}} for B{C{Orientation}} enum type. 13631 13632 13633 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 13634 13635 """ 13636 return None

13637 -def z_UNIMPLEMENTED_gwy_orientation_get_type( ):

13638 return None

13639 -def gwy_pixbuf_draw_data_field( pixbuf , data_field , gradient ):

13640 """ 13641 Paints a data field to a pixbuf with an auto-stretched color gradient. 13642 13643 Minimum data value is mapped to start of B{C{gradient}}, maximum value to its 13644 end, values between are mapped linearly to B{C{gradient}}. 13645 13646 @param pixbuf: A Gdk pixbuf to draw to. I{(GdkPixbuf*)} 13647 @param data_field: A data field to draw. I{(L{DataField})} 13648 @param gradient: A color gradient to draw with. I{(Gradient*)} 13649 @return: 13650 """ 13651 return None

13652 -def gwy_pixbuf_draw_data_field_adaptive( pixbuf , data_field , gradient ):

13653 """ 13654 Paints a data field to a pixbuf with a color gradient adaptively. 13655 13656 The mapping from data field (minimum, maximum) range to gradient is 13657 nonlinear, deformed using inverse function to height density cummulative 13658 distribution. 13659 13660 @param pixbuf: A Gdk pixbuf to draw to. I{(GdkPixbuf*)} 13661 @param data_field: A data field to draw. I{(L{DataField})} 13662 @param gradient: A color gradient to draw with. I{(Gradient*)} 13663 @return: 13664 """ 13665 return None

13666 -def gwy_pixbuf_draw_data_field_as_mask( pixbuf , data_field , color ):

13667 """ 13668 Paints a data field to a pixbuf as a single-color mask with varying opacity. 13669 13670 Values equal or smaller to 0.0 are drawn as fully transparent, values 13671 greater or equal to 1.0 as fully opaque, values between are linearly 13672 mapped to pixel opacity. 13673 13674 @param pixbuf: A Gdk pixbuf to draw to. I{(GdkPixbuf*)} 13675 @param data_field: A data field to draw. I{(L{DataField})} 13676 @param color: A color to use. I{(const-RGBA*)} 13677 @return: 13678 """ 13679 return None

13680 -def gwy_pixbuf_draw_data_field_with_range( pixbuf , data_field , gradient , minimum , maximum ):

13681 """ 13682 Paints a data field to a pixbuf with an explicite color gradient range. 13683 13684 B{C{minimum}} and all smaller values are mapped to start of B{C{gradient}}, B{C{maximum}} 13685 and all greater values to its end, values between are mapped linearly to 13686 B{C{gradient}}. 13687 13688 @param pixbuf: A Gdk pixbuf to draw to. I{(GdkPixbuf*)} 13689 @param data_field: A data field to draw. I{(L{DataField})} 13690 @param gradient: A color gradient to draw with. I{(Gradient*)} 13691 @param minimum: The value corresponding to gradient start. I{(float)} 13692 @param maximum: The value corresponding to gradient end. I{(float)} 13693 @return: 13694 """ 13695 return None

13696 -def z_UNIMPLEMENTED_gwy_pixmap_layer_get_type( ):

13697 return None

13698 -def z_UNIMPLEMENTED_gwy_plain_tool_changed_get_type( ):

13699 return None

13700 -def z_UNIMPLEMENTED_gwy_plain_tool_get_type( ):

13701 return None

13702 -def gwy_plain_tool_get_z_average( data_field , point , radius ):

13703 """ 13704 Computes average value over a part of data field B{C{dfield}}. 13705 13706 It is not an error if part of it lies outside the data field borders 13707 (it is simply not counted in), however the intersection have to be nonempty. 13708 13709 13710 @param data_field: A data field. I{(L{DataField})} 13711 @param point: Real X and Y-coordinate of area center in physical units. I{(const-gdouble*)} 13712 @param radius: Area radius in pixels, 1 means a signle pixel. The actual radius 13713 passed to L{DataField.circular_area_extract}() is B{C{radius}}-0.5. I{(int)} 13714 @return: The average value. 13715 13716 """ 13717 return None

13718 -def z_UNIMPLEMENTED_gwy_plane_fit_quantity_get_type( ):

13719 return None

13720 -def z_UNIMPLEMENTED_gwy_plane_symmetry_get_enum( ):

13721 """ 13722 Returns B{C{Enum}} for B{C{PlaneSymmetry}} enum type. 13723 13724 13725 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 13726 13727 """ 13728 return None

13729 -def z_UNIMPLEMENTED_gwy_plane_symmetry_get_type( ):

13730 return None

13731 -def gwy_process_func_exists( name ):

13732 """ 13733 Checks whether a data processing function exists. 13734 13735 13736 @param name: Data processing function name. I{(string)} 13737 @return: B{C{True}} if function B{C{name}} exists, B{C{False}} otherwise. 13738 13739 """ 13740 return None

13741 -def z_UNIMPLEMENTED_gwy_process_func_foreach( function , user_data ):

13742 """ 13743 Calls a function for each process function. 13744 13745 @param function: Function to run for each process function. It will get function 13746 name (constant string owned by module system) as its first 13747 argument, B{C{user_data}} as the second argument. I{(GFunc)} 13748 @param user_data: Data to pass to B{C{function}}. I{(gpointer)} 13749 @return: 13750 """ 13751 return None

13752 -def gwy_process_func_get_menu_path( name ):

13753 """ 13754 Returns the menu path of a data processing function. 13755 13756 The returned menu path is only the tail part registered by the function, 13757 i.e., without any leading "/Data Process". 13758 13759 13760 @param name: Data processing function name. I{(string)} 13761 @return: The menu path. The returned string is owned by the module. 13762 13763 """ 13764 return None

13765 -def gwy_process_func_get_run_types( name ):

13766 """ 13767 Returns run modes supported by a data processing function. 13768 13769 13770 @param name: Data processing function name. I{(string)} 13771 @return: The run mode bit mask. 13772 13773 """ 13774 return None

13775 -def gwy_process_func_get_sensitivity_mask( name ):

13776 """ 13777 Gets menu sensititivy mask for a data processing function. 13778 13779 13780 @param name: Data processing function name. I{(string)} 13781 @return: The menu item sensitivity mask (a combination of B{C{MenuSensFlags}} 13782 flags). 13783 13784 """ 13785 return None

13786 -def gwy_process_func_get_stock_id( name ):

13787 """ 13788 Gets stock icon id of a data processing function. 13789 13790 13791 @param name: Data processing function name. I{(string)} 13792 @return: The stock icon id. The returned string is owned by the module. 13793 13794 """ 13795 return None

13806 -def z_UNIMPLEMENTED_gwy_process_func_register( name , func , menu_path , stock_id , run , sens_mask , tooltip ):

13807 """ 13808 Registers a data processing function. 13809 13810 Note: the string arguments are not copied as modules are not expected to 13811 vanish. If they are constructed (non-constant) strings, do not free them. 13812 Should modules ever become unloadable they will get a chance to clean-up. 13813 13814 13815 @param name: Name of function to register. It should be a valid identifier and 13816 if a module registers only one function, module and function names 13817 should be the same. I{(string)} 13818 @param func: The function itself. I{(ProcessFunc)} 13819 @param menu_path: Menu path under Data Process menu. The menu path should be 13820 marked translatabe, but passed untranslated (to allow merging 13821 of translated and untranslated submenus). I{(string)} 13822 @param stock_id: Stock icon id for toolbar. I{(string)} 13823 @param run: Supported run modes. Data processing functions can have two run 13824 modes: B{C{RUN_IMMEDIATE}} (no questions asked) and 13825 B{C{RUN_INTERACTIVE}} (a modal dialog with parameters). I{(RunType)} 13826 @param sens_mask: Sensitivity mask (a combination of B{C{MenuSensFlags}} flags). 13827 Usually it contains B{C{MENU_FLAG_DATA}}, possibly other 13828 requirements. I{(int)} 13829 @param tooltip: Tooltip for this function. I{(string)} 13830 @return: Normally B{C{True}}; B{C{False}} on failure. 13831 13832 """ 13833 return None

13834 -def gwy_process_func_run( name , data , run ):

13835 """ 13836 Runs a data processing function identified by B{C{name}}. 13837 13838 @param name: Data processing function name. I{(string)} 13839 @param data: Data (a B{C{Container}}). I{(L{Container})} 13840 @param run: How the function should be run. I{(RunType)} 13841 @return: 13842 """ 13843 return None

13844 -def gwy_process_type_init( ):

13845 """ 13846 Makes libgwyprocess types safe for deserialization and performs other 13847 initialization. You have to call this function before using objects 13848 from libgwyprocess. 13849 13850 Calls L{gwy_type_init}() first to make sure libgwyddion is initialized. 13851 13852 It is safe to call this function more than once, subsequent calls are no-op. 13853 13854 @return: 13855 """ 13856 return None

13857 -def gwy_radio_button_get_value( button ):

13858 """ 13859 Gets the integer value associated with a radio button. 13860 13861 13862 @param button: A radio button belonging to a group created by 13863 L{gwy_radio_buttons_create}(). I{(L{gtk.Widget})} 13864 @return: The integer value corresponding to B{C{button}}. 13865 13866 """ 13867 return None

13868 -def gwy_radio_button_set_value( button , value ):

13869 """ 13870 Sets the integer value associated with a radio button. 13871 13872 This function allow to change associated radio button values after creation 13873 or even construct a radio button group with associated integers without the 13874 help of L{gwy_radio_buttons_create}(). 13875 13876 @param button: A radio button to set associated value of. I{(L{gtk.Widget})} 13877 @param value: Value to associate. I{(int)} 13878 @return: 13879 """ 13880 return None

13881 -def z_UNIMPLEMENTED_gwy_radio_buttons_attach_to_table( group , table , colspan , row ):

13882 """ 13883 Attaches a group of radio buttons to table rows. 13884 13885 Since: 2.1 13886 13887 @param group: A radio button group. Not necessarily created by 13888 L{gwy_radio_buttons_create}(). I{(GSList*)} 13889 @param table: A table. I{(GtkTable*)} 13890 @param colspan: The number of columns the radio buttons should span across. I{(int)} 13891 @param row: Table row to start attaching at. I{(int)} 13892 @return: The row after the last attached radio button. 13893 13894 13895 """ 13896 return None

13897 -def z_UNIMPLEMENTED_gwy_radio_buttons_create( entries , nentries , callback , cbdata , current ):

13898 """ 13899 Creates a radio button group from an enum. 13900 13901 Try to avoid -1 as an enum value. 13902 13903 13904 @param entries: Radio button group items. I{(const-Enum*)} 13905 @param nentries: The number of items. Since 2.18 negative value means that 13906 B{C{entries}} is terminated with a B{C{NULL}}-named item. I{(int)} 13907 @param callback: A callback called when a menu item is activated (or B{C{NULL}} for 13908 no callback). I{(GCallback)} 13909 @param cbdata: User data passed to the callback. I{(gpointer)} 13910 @param current: Value to be shown as currently selected (-1 to use what happens 13911 to be first). I{(int)} 13912 @return: The newly created radio button group (a B{C{GSList}}). Iterate over 13913 the list and pack the widgets (the order is the same as in 13914 B{C{entries}}). The group is owned by the buttons and must not be 13915 freed. 13916 13917 """ 13918 return None

13919 -def z_UNIMPLEMENTED_gwy_radio_buttons_find( group , value ):

13920 """ 13921 Finds a radio button by its associated integer value. 13922 13923 13924 @param group: A radio button group created by L{gwy_radio_buttons_create}(). I{(GSList*)} 13925 @param value: The value associated with the button to find. I{(int)} 13926 @return: The radio button corresponding to B{C{value}}, or B{C{NULL}} on failure. 13927 13928 """ 13929 return None

13930 -def z_UNIMPLEMENTED_gwy_radio_buttons_get_current( group ):

13931 """ 13932 Gets the integer enum value corresponding to currently selected item. 13933 13934 13935 @param group: A radio button group created by L{gwy_radio_buttons_create}(). I{(GSList*)} 13936 @return: The enum value corresponding to currently selected item. In 13937 case of failure -1 is returned. 13938 13939 """ 13940 return None

13941 -def z_UNIMPLEMENTED_gwy_radio_buttons_set_current( group , current ):

13942 """ 13943 Sets currently selected radio button in B{C{group}} based on integer item object 13944 data (as set by L{gwy_radio_buttons_create}()). 13945 13946 13947 @param group: A radio button group created by L{gwy_radio_buttons_create}(). I{(GSList*)} 13948 @param current: Value to be shown as currently selected. I{(int)} 13949 @return: B{C{True}} if current button was set, B{C{False}} if B{C{current}} was not found. 13950 13951 """ 13952 return None

13953 -def gwy_raw_data_size( datatype ):

13954 """ 13955 Reports the size of a single raw data item. 13956 13957 Since: 2.25 13958 13959 @param datatype: Raw data type. I{(RawDataType)} 13960 @return: The size of a single raw data item of type B{C{datatype}}. 13961 13962 13963 """ 13964 return None

13965 -def z_UNIMPLEMENTED_gwy_raw_data_type_get_type( ):

13966 return None

13967 -def gwy_resource_classes_finalize( ):

13968 """ 13969 Destroys the inventories of all resource classes. 13970 13971 This function makes the affected resource classes unusable. Its purpose is 13972 to faciliate reference leak debugging by destroying a large number of 13973 objects that normally live forever. 13974 13975 Note static resource classes that never called L{Resource.class_load}() 13976 are excluded. 13977 13978 Since: 2.8 13979 13980 @return: 13981 """ 13982 return None

13983 -def z_UNIMPLEMENTED_gwy_resource_editor_get_type( ):

13984 return None

13985 -def z_UNIMPLEMENTED_gwy_resource_get_type( ):

13986 return None

13987 -def gwy_resource_parse( text , expected_type ):

13988 """ 13989 Reconstructs a resource from human readable form. 13990 13991 13992 @param text: Textual resource representation. I{(string)} 13993 @param expected_type: Resource object type. If not 0, only resources of give type 13994 are allowed. Zero value means any B{C{Resource}} is allowed. I{(GType)} 13995 @return: Newly created resource (or B{C{NULL}}). 13996 13997 """ 13998 return None

13999 -def gwy_resource_tree_view_set_active( treeview , active ):

14000 """ 14001 Selects a resource in a list and scrolls to make it visible. 14002 14003 14004 @param treeview: A resource selector tree view. I{(L{gtk.Widget})} 14005 @param active: Resource name to be shown as currently selected. I{(string)} 14006 @return: B{C{True}} if B{C{active}} was selected, B{C{False}} if there is no such 14007 resource. 14008 14009 """ 14010 return None

14011 -def z_UNIMPLEMENTED_gwy_rgba_get_type( ):

14012 return None

14013 -def gwy_rgba_remove_from_container( container , prefix ):

14014 """ 14015 Removes RGBA color components from a container. 14016 14017 This is a convenience function to remove the components in the common 14018 arrangement. 14019 14020 14021 @param container: A B{C{Container}} to remove the color components from. I{(L{Container})} 14022 @param prefix: Prefix in B{C{container}}, e.g. "/0/mask" (it will remove 14023 "/0/mask/red", "/0/mask/green", etc. then). I{(string)} 14024 @return: B{C{True}} if anything was removed. 14025 14026 """ 14027 return None

14028 -def z_UNIMPLEMENTED_gwy_ruler_get_type( ):

14029 return None

14030 -def z_UNIMPLEMENTED_gwy_run_type_get_type( ):

14031 return None

14032 -def gwy_save_auxiliary_data( title , parent , data_len , data ):

14033 """ 14034 Saves a report or other auxiliary data to a user specified file. 14035 14036 This is actually a simple L{gwy_save_auxiliary_with_callback}() wrapper, see 14037 its description for details. 14038 14039 Since: 2.3 14040 14041 @param title: File chooser dialog title. I{(string)} 14042 @param parent: Parent window for the file chooser dialog (may be B{C{NULL}}). I{(L{gtk.Window})} 14043 @param data_len: The length of B{C{data}} in bytes. Pass -1 if B{C{data}} is text, it must 14044 be nul-terminated then and it will be saved in text mode (this 14045 matters if the operating system distinguishes between text and 14046 binary). A non-negative value causes the data to be saved as 14047 binary. I{(gssize)} 14048 @param data: The data to save. I{(string)} 14049 @return: B{C{True}} if the data was save, B{C{False}} if it was not saved for any 14050 reason. 14051 14052 14053 """ 14054 return None

14055 -def z_UNIMPLEMENTED_gwy_save_auxiliary_with_callback( title , parent , create , destroy , user_data ):

14056 """ 14057 Saves a report or other auxiliary data to a user specified file. 14058 14059 Since: 2.3 14060 14061 @param title: File chooser dialog title. I{(string)} 14062 @param parent: Parent window for the file chooser dialog (may be B{C{NULL}}). I{(L{gtk.Window})} 14063 @param create: Function to create the data (it will not be called if the user 14064 cancels the saving). I{(SaveAuxiliaryCreate)} 14065 @param destroy: Function to destroy the data (if will be called iff B{C{create}} will 14066 be called), it may be B{C{NULL}}. I{(SaveAuxiliaryDestroy)} 14067 @param user_data: User data passed to B{C{create}} and B{C{destroy}}. I{(gpointer)} 14068 @return: B{C{True}} if the data was save, B{C{False}} if it was not saved for any 14069 reason (I/O error, cancellation, overwrite cancellation, etc.). 14070 14071 14072 """ 14073 return None

14074 -def z_UNIMPLEMENTED_gwy_sci_text_get_type( ):

14075 return None

14076 -def z_UNIMPLEMENTED_gwy_selection_get_type( ):

14077 return None

14078 -def z_UNIMPLEMENTED_gwy_selection_graph_1darea_get_type( ):

14079 return None

14080 -def z_UNIMPLEMENTED_gwy_selection_graph_area_get_type( ):

14081 return None

14082 -def z_UNIMPLEMENTED_gwy_selection_graph_line_get_type( ):

14083 return None

14084 -def z_UNIMPLEMENTED_gwy_selection_graph_point_get_type( ):

14085 return None

14086 -def z_UNIMPLEMENTED_gwy_selection_graph_zoom_get_type( ):

14087 return None

14088 -def z_UNIMPLEMENTED_gwy_sensitivity_group_get_type( ):

14089 return None

14090 -def gwy_serializable_clone( source , copy ):

14091 """ 14092 Makes an object identical to another object of the same type. 14093 14094 More precisely, B{C{source}} may be subclass of B{C{copy}} (the extra information 14095 is lost then). 14096 14097 @param source: An object implementing B{C{Serializable}} interface. I{(L{gobject.GObject})} 14098 @param copy: An object of the same type as B{C{source}} to modify after it. I{(L{gobject.GObject})} 14099 @return: 14100 """ 14101 return None

14102 -def z_UNIMPLEMENTED_gwy_serializable_deserialize( buffer , size , position ):

14103 """ 14104 Restores a serialized object from byte buffer. 14105 14106 The newly created object has reference count according to its nature, thus 14107 a B{C{GtkObject}} will have a floating reference, a B{C{GObject}} will have a 14108 refcount of 1, etc. 14109 14110 14111 @param buffer: A block of memory of size B{C{size}} contaning object representation. I{(string)} 14112 @param size: The size of B{C{buffer}}. I{(gsize)} 14113 @param position: The position of the object in B{C{buffer}}, it's updated to 14114 point after it. I{(gsize*)} 14115 @return: A newly created object. 14116 14117 """ 14118 return None

14119 -def gwy_serializable_duplicate( object ):

14120 """ 14121 Creates a copy of an object. 14122 14123 If the object doesn't support duplication natively, it's brute-force 14124 serialized and then deserialized, this may be quite inefficient, 14125 namely for large objects. 14126 14127 You can duplicate a B{C{NULL}}, too, but you are discouraged from doing it. 14128 14129 14130 @param object: An object implementing B{C{Serializable}} interface. I{(L{gobject.GObject})} 14131 @return: The newly created object copy. However if the object is a 14132 singleton, B{C{object}} itself (with incremented reference count) 14133 can be returned, too. 14134 14135 """ 14136 return None

14137 -def gwy_serializable_get_size( serializable ):

14138 """ 14139 Calculates the expected size of serialized object. 14140 14141 14142 @param serializable: A B{C{GObject}} that implements B{C{Serializable}} interface. I{(L{gobject.GObject})} 14143 @return: The expected size of serialized B{C{serializable}}. 14144 14145 """ 14146 return None

14147 -def z_UNIMPLEMENTED_gwy_serializable_get_type( ):

14148 return None

14149 -def z_UNIMPLEMENTED_gwy_serializable_serialize( serializable , buffer ):

14150 """ 14151 Serializes an object to byte buffer. 14152 14153 This is a high-level method. Do not use it for implementation of child 14154 object serialization (should you ever need to do it manually), it would 14155 lead to repeated required buffer size calculations. In such a case, use 14156 L{gwy_serializable_do_serialize}() FIXME: but that's not public. 14157 14158 14159 @param serializable: A B{C{GObject}} that implements B{C{Serializable}} interface. I{(L{gobject.GObject})} 14160 @param buffer: A buffer to which the serialized object should be appended, 14161 or B{C{NULL}} to allocate and return a new B{C{GByteArray}}. I{(GByteArray*)} 14162 @return: B{C{buffer}} or a newly allocated B{C{GByteArray}} with serialized 14163 object appended. 14164 14165 """ 14166 return None

14167 -def gwy_serialize_check_string( buffer , size , position , compare_to ):

14168 """ 14169 Check whether B{C{size}} bytes of memory in B{C{buffer}} can be interpreted as a 14170 nul-terminated string, and eventually whether it's equal to B{C{compare_to}}. 14171 14172 When B{C{compare_to}} is B{C{NULL}}, the comparsion is not performed. 14173 14174 14175 @param buffer: A memory location containing a nul-terminated string at position 14176 B{C{position}}. I{(string)} 14177 @param size: The size of B{C{buffer}}. I{(gsize)} 14178 @param position: The position of the string in B{C{buffer}}. I{(gsize)} 14179 @param compare_to: String to compare B{C{buffer}} to, or B{C{NULL}}. I{(string)} 14180 @return: The length of the nul-terminated string including the nul 14181 character; zero otherwise. 14182 14183 """ 14184 return None

14185 -def z_UNIMPLEMENTED_gwy_serialize_get_items_size( object_name , nitems , items ):

14186 """ 14187 Calculates serialized object size for hash-like objects. 14188 14189 The component specification is the same as in 14190 L{gwy_serialize_object_items}(). 14191 14192 14193 @param object_name: The type name of the object. I{(string)} 14194 @param nitems: The number of B{C{items}} items. I{(gsize)} 14195 @param items: The components to serialize. I{(const-SerializeItem*)} 14196 @return: Serialized object size, it included space for object name and size. 14197 The value is exact unless some components are objects that do not 14198 return exact size estimate themselves. 14199 14200 """ 14201 return None

14202 -def z_UNIMPLEMENTED_gwy_serialize_get_struct_size( object_name , nspec , spec ):

14203 """ 14204 Calculates serialized object size for struct-like objects. 14205 14206 The component specification is the same as in 14207 L{gwy_serialize_pack_object_struct}(). 14208 14209 14210 @param object_name: The type name of the object. I{(string)} 14211 @param nspec: The number of items in B{C{spec}}. I{(gsize)} 14212 @param spec: The components to serialize. I{(const-SerializeSpec*)} 14213 @return: Serialized object size, it included space for object name and size. 14214 The value is exact unless some components are objects that do not 14215 return exact size estimate themselves. 14216 14217 """ 14218 return None

14219 -def z_UNIMPLEMENTED_gwy_serialize_object_items( buffer , object_name , nitems , items ):

14220 """ 14221 Serializes an object to buffer in gwy-file format. 14222 14223 More precisely, it appends serialization of object with g_type_name() 14224 B{C{object_name}} with components described by B{C{items}} to B{C{buffer}}. 14225 14226 14227 @param buffer: A buffer to which the serialized components should be appended, 14228 or B{C{NULL}}. I{(GByteArray*)} 14229 @param object_name: The type of the object. I{(string)} 14230 @param nitems: The number of B{C{items}} items. I{(gsize)} 14231 @param items: The components to serialize. I{(const-SerializeItem*)} 14232 @return: B{C{buffer}} or a newly allocated B{C{GByteArray}} with serialization of 14233 B{C{items}} components appended. 14234 14235 """ 14236 return None

14237 -def z_UNIMPLEMENTED_gwy_serialize_pack_object_struct( buffer , object_name , nspec , spec ):

14238 """ 14239 Appends serialization of object with g_type_name() B{C{object_name}} and 14240 components described by B{C{spec}} to B{C{buffer}} in gwy-file format. 14241 14242 Here's how a serialization method of a simple object whose state is 14243 described by a single real number foo could look (without error checking): 14244 <informalexample><programlisting> 14245 static guchar* 14246 my_object_serialize(GObject *obj, 14247 guchar *buffer, 14248 gsize *size) 14249 { 14250 MyObject *my_object = MY_OBJECT(obj); 14251 SerializeSpec spec[] = { 14252 { 'd', "foo", &my_object->foo, NULL, }, 14253 }; 14254 14255 return L{gwy_serialize_pack_object_struct}(buffer, size, 14256 "MyObject", 14257 G_N_ELEMENTS(spec), spec); 14258 } 14259 </programlisting></informalexample> 14260 14261 14262 @param buffer: A buffer to which the serialized components should be appended. I{(GByteArray*)} 14263 @param object_name: The type name of the object. I{(string)} 14264 @param nspec: The number of items in B{C{spec}}. I{(gsize)} 14265 @param spec: The components to serialize. I{(const-SerializeSpec*)} 14266 @return: The buffer with serialization of B{C{spec}} components appended. 14267 14268 """ 14269 return None

14270 -def z_UNIMPLEMENTED_gwy_serialize_unpack_object_struct( buffer , size , position , object_name , nspec , spec ):

14271 """ 14272 Deserializes an object with named components packed into gwy-file format by 14273 L{gwy_serialize_pack_object_struct}(). 14274 14275 Extra components are ignored (but cause a warning), components of different 14276 type than expected cause failure, missing components are not detected. 14277 14278 It is safe to pass pointers to existing non-atomic objects (strings, arrays, 14279 objects) in B{C{spec}} values, they will be dereferenced and freed as necessary 14280 when an unpacked value is about to replace them. 14281 For the same reason it is an error to pass pointers to unintialized memory 14282 there, always initialize non-atomic B{C{spec}} values to B{C{NULL}} pointers, at 14283 least. 14284 14285 Caller is responsible for use/clean-up of these values if deserialization 14286 succeeds or not. 14287 14288 Here's how a deserialization method of a simple object whose state is 14289 described by a single real number B{C{foo}} could look (without error checking): 14290 <informalexample><programlisting> 14291 static GObject* 14292 my_object_deserialize(const guchar *buffer, 14293 gsize size, 14294 gsize *position) 14295 { 14296 double foo = 1.0; 14297 SerializeSpec spec[] = { 14298 { 'd', "foo", &foo, NULL, }, 14299 }; 14300 MyObject *my_object; 14301 14302 L{gwy_serialize_unpack_object_struct}(buffer, size, position, 14303 "MyObject", 14304 G_N_ELEMENTS(spec), spec); 14305 return my_object_new(foo); 14306 } 14307 </programlisting></informalexample> 14308 14309 14310 @param buffer: A memory location containing a serialized object at position 14311 B{C{position}}. I{(string)} 14312 @param size: Current size of B{C{buffer}}, new size is returned here. I{(gsize)} 14313 @param position: The position of the object in B{C{buffer}}, it's updated to point 14314 after it. I{(gsize*)} 14315 @param object_name: The type name of the object. I{(string)} 14316 @param nspec: The number of items in B{C{spec}}. I{(gsize)} 14317 @param spec: The components to deserialize. I{(SerializeSpec*)} 14318 @return: Whether the unpacking succeeded 14319 (see description body for definition of success and failure). 14320 14321 """ 14322 return None

14323 -def gwy_set_data_preview_size( data_view , max_size ):

14324 """ 14325 Sets up data view zoom to not exceed specified size. 14326 14327 Before calling this function, data keys have be set, data fields and layers 14328 have to be present and physically square mode set in the container. 14329 Sizing of both pixel-wise square and physically square displays is performed 14330 correctly. 14331 14332 Since: 2.7 14333 14334 @param data_view: A data view used for module preview. I{(L{DataView})} 14335 @param max_size: Maximum allowed B{C{data_view}} size (width and height). I{(int)} 14336 @return: 14337 """ 14338 return None

14339 -def gwy_sgettext( msgid ):

14340 """ 14341 Translate a message id containing disambiguating prefix ending with `|'. 14342 14343 14344 @param msgid: Message id to translate, containing `|'-separated prefix. I{(string)} 14345 @return: Translated message, or B{C{msgid}} itself with all text up to the last 14346 `|' removed if there is no translation. 14347 14348 """ 14349 return None

14350 -def z_UNIMPLEMENTED_gwy_shader_get_type( ):

14351 return None

14352 -def z_UNIMPLEMENTED_gwy_si_unit_format_style_get_type( ):

14353 return None

14354 -def z_UNIMPLEMENTED_gwy_si_unit_get_type( ):

14355 return None

14356 -def gwy_si_unit_new_parse( unit_string , power10 ):

14357 """ 14358 Creates a new SI unit from string representation. 14359 14360 This is a more powerful version of L{SiUnit.new}(): B{C{unit_string}} may 14361 be a relatively complex unit, with prefixes, like "pA/s" or "km^2". 14362 Beside conversion to a base SI unit like "A/s" or "m^2" it also computes 14363 the power of 10 one has to multiply the base unit with to get an equivalent 14364 of B{C{unit_string}}. 14365 14366 For example, for <literal>"pA/s"</literal> it will store -12 to B{C{power10}} 14367 because 1 pA/s is 1e-12 A/s, for <literal>"km^2"</literal> it will store 6 14368 to B{C{power10}} because 1 km^2 is 1e6 m^2. 14369 14370 14371 @param unit_string: Unit string (it can be B{C{NULL}} for an empty unit). I{(string)} 14372 @param power10: Where power of 10 should be stored (or B{C{NULL}}). I{(int)} 14373 @return: A new SI unit. 14374 14375 """ 14376 return None

14377 -def z_UNIMPLEMENTED_gwy_si_unit_value_format_free( format ):

14378 """ 14379 Frees a value format structure. 14380 14381 @param format: A value format to free. I{(SIValueFormat*)} 14382 @return: 14383 """ 14384 return None

14385 -def z_UNIMPLEMENTED_gwy_si_unit_value_format_set_units( format , units ):

14386 """ 14387 Sets the units field of a value format structure. 14388 14389 This function keeps the B{C{units}} and B{C{units_gstring}} fields consistent. 14390 14391 @param format: A value format to set units of. I{(SIValueFormat*)} 14392 @param units: The units string. I{(string)} 14393 @return: 14394 """ 14395 return None

14396 -def z_UNIMPLEMENTED_gwy_spectra_get_type( ):

14397 return None

14398 -def z_UNIMPLEMENTED_gwy_statusbar_get_type( ):

14399 return None

14400 -def gwy_stock_register_stock_items( ):

14401 """ 14402 Registers stock items. 14403 14404 This function must be called before any stock items are used. 14405 14406 @return: 14407 """ 14408 return None

14409 -def z_UNIMPLEMENTED_gwy_str_next_line( buffer ):

14410 """ 14411 Extracts a next line from a character buffer, modifying it in place. 14412 14413 B{C{buffer}} is updated to point after the end of the line and the "\n" 14414 (or "\r" or "\r\n") is replaced with "\0", if present. 14415 14416 The final line may or may not be terminated with an EOL marker, its contents 14417 is returned in either case. Note, however, that the empty string "" is not 14418 interpreted as an empty unterminated line. Instead, B{C{NULL}} is immediately 14419 returned. 14420 14421 The typical usage of L{gwy_str_next_line}() is: 14422 |[ 14423 gchar *p = text; 14424 for (gchar *line = L{gwy_str_next_line}(&p); 14425 line; 14426 line = L{gwy_str_next_line}(&p)) { 14427 g_strstrip(line); 14428 // Do something more with line 14429 } 14430 ]| 14431 14432 14433 @param buffer: Text buffer. I{(gchar**)} 14434 @return: The start of the line. B{C{NULL}} if the buffer is empty or B{C{NULL}}. 14435 The return value is <emphasis>not</emphasis> a new string; the 14436 normal return value is the previous value of B{C{buffer}}. 14437 14438 """ 14439 return None

14440 -def gwy_strdiffpos( s1 , s2 ):

14441 """ 14442 Finds position where two strings differ. 14443 14444 14445 @param s1: A string. I{(string)} 14446 @param s2: A string. I{(string)} 14447 @return: The last position where the strings do not differ yet. 14448 Particularly, -1 is returned if either string is B{C{NULL}}, 14449 zero-length, or they differ in the very first character. 14450 14451 """ 14452 return None

14453 -def z_UNIMPLEMENTED_gwy_string_list_get_type( ):

14454 return None

14455 -def z_UNIMPLEMENTED_gwy_string_to_enum( str , enum_table , n ):

14456 """ 14457 Creates an integer representation of a string enum value B{C{str}}. 14458 14459 14460 @param str: A string containing one of B{C{enum_table}} string values. I{(string)} 14461 @param enum_table: A table of corresponding string-integer pairs. I{(const-Enum*)} 14462 @param n: The number of elements in B{C{enum_table}}, may be -1 when B{C{enum_table}} is 14463 terminated by a B{C{NULL}} name. I{(int)} 14464 @return: The integer enum value (NOT index in the table), or -1 if B{C{str}} 14465 was not found. 14466 14467 """ 14468 return None

14469 -def z_UNIMPLEMENTED_gwy_string_to_flags( str , enum_table , n , delimiter ):

14470 """ 14471 Creates an integer flag combination of its string representation B{C{str}}. 14472 14473 14474 @param str: A string containing one of B{C{enum_table}} string values. I{(string)} 14475 @param enum_table: A table of corresponding string-integer pairs. I{(const-Enum*)} 14476 @param n: The number of elements in B{C{enum_table}}, may be -1 when B{C{enum_table}} is 14477 terminated by a B{C{NULL}} name. I{(int)} 14478 @param delimiter: A delimiter to split B{C{str}} on, when B{C{NULL}} space is used. I{(string)} 14479 @return: All the flags present in B{C{str}}, bitwise ORer. 14480 14481 """ 14482 return None

14483 -def gwy_strisident( s , more , startmore ):

14484 """ 14485 Checks whether a string is valid identifier. 14486 14487 Valid identifier must start with an alphabetic character or a character from 14488 B{C{startmore}}, and it must continue with alphanumeric characters or characters 14489 from B{C{more}}. 14490 14491 Note underscore is not allowed by default, you have to pass it in B{C{more}} 14492 and/or B{C{startmore}}. 14493 14494 14495 @param s: A NUL-terminated string. I{(string)} 14496 @param more: List of additional ASCII characters allowed inside identifier, empty 14497 list can be passed as B{C{NULL}}. I{(string)} 14498 @param startmore: List of additional ASCII characters allowed as the first 14499 identifier characters, empty list can be passed as B{C{NULL}}. I{(string)} 14500 @return: B{C{True}} if B{C{s}} is valid identifier, B{C{False}} otherwise. 14501 14502 """ 14503 return None

14504 -def gwy_strkill( s , killchars ):

14505 """ 14506 Removes characters in B{C{killchars}} from string B{C{s}}, modifying it in place. 14507 14508 Use L{gwy_strkill}(g_strdup(B{C{s}}), B{C{killchars}}) to get a modified copy. 14509 14510 14511 @param s: A NUL-terminated string. I{(gchar*)} 14512 @param killchars: A string containing characters to kill. I{(string)} 14513 @return: B{C{s}} itself, the return value is to allow function call nesting. 14514 14515 """ 14516 return None

14517 -def gwy_strreplace( haystack , needle , replacement , maxrepl ):

14518 """ 14519 Replaces occurences of string B{C{needle}} in B{C{haystack}} with B{C{replacement}}. 14520 14521 14522 @param haystack: A NUL-terminated string to search in. I{(string)} 14523 @param needle: A NUL-terminated string to search for. I{(string)} 14524 @param replacement: A NUL-terminated string to replace B{C{needle}} with. I{(string)} 14525 @param maxrepl: Maximum number of occurences to replace (use (gsize)-1 to replace 14526 all occurences). I{(gsize)} 14527 @return: A newly allocated string. 14528 14529 """ 14530 return None

14531 -def gwy_table_attach_hscale( table , row , name , units , pivot , style ):

14532 """ 14533 Attaches a spinbutton with a scale and labels, or something else to a table 14534 row. 14535 14536 You can use functions L{gwy_table_hscale_get_scale}(), 14537 L{gwy_table_hscale_get_check}(), etc. to get the various widgets from pivot 14538 later. 14539 14540 FIXME: What exactly happens with various B{C{style}} values is quite convoluted. 14541 14542 14543 @param table: A B{C{GtkTable}}. I{(L{gtk.Widget})} 14544 @param row: Row in B{C{table}} to attach stuff to. I{(int)} 14545 @param name: The label before B{C{pivot}} widget. I{(string)} 14546 @param units: The label after B{C{pivot}} widget. I{(string)} 14547 @param pivot: Either a B{C{GtkAdjustment}}, or a widget to use instead of the spin 14548 button and scale widgets (if B{C{style}} is B{C{HSCALE_WIDGET}}). I{(GtkObject*)} 14549 @param style: A mix of options an flags determining what and how will be attached 14550 to the table. I{(HScaleStyle)} 14551 @return: The middle widget. If a spinbutton is attached, then this 14552 spinbutton is returned. Otherwise (in B{C{HSCALE_WIDGET}} case) 14553 B{C{pivot}} itself. 14554 14555 """ 14556 return None

14557 -def gwy_table_attach_row( table , row , name , units , middle_widget ):

14558 """ 14559 Attaches a widget with two labels to a table. 14560 14561 @param table: A B{C{GtkTable}}. I{(L{gtk.Widget})} 14562 @param row: Table row to attach to. I{(int)} 14563 @param name: The label before B{C{middle_widget}}. I{(string)} 14564 @param units: The label after B{C{adj}}. I{(string)} 14565 @param middle_widget: A widget. I{(L{gtk.Widget})} 14566 @return: 14567 """ 14568 return None

14569 -def gwy_table_attach_spinbutton( table , row , name , units , adj ):

14570 """ 14571 Attaches a spinbutton with two labels to a table. 14572 14573 14574 @param table: A B{C{GtkTable}}. I{(L{gtk.Widget})} 14575 @param row: Table row to attach to. I{(int)} 14576 @param name: The label before B{C{adj}}. I{(string)} 14577 @param units: The label after B{C{adj}}. I{(string)} 14578 @param adj: An adjustment to create spinbutton from. I{(GtkObject*)} 14579 @return: The spinbutton as a B{C{GtkWidget}}. 14580 14581 """ 14582 return None

14583 -def gwy_table_get_child_widget( table , row , col ):

14584 """ 14585 Finds a widget in B{C{GtkTable}} by its coordinates. 14586 14587 Coordinates (B{C{col}}, B{C{row}}) are taken as coordinates of widget top left corner. 14588 More precisely, the returned widget either contains the specified grid 14589 point or it is attached by its left side, top side, or top left corner to 14590 this point. 14591 14592 If there are multiple matches due to overlapping widgets, a random 14593 match is returned. 14594 14595 14596 @param table: A B{C{GtkTable}}. I{(L{gtk.Widget})} 14597 @param row: Row in B{C{table}}. I{(int)} 14598 @param col: Column in B{C{table}}. I{(int)} 14599 @return: The widget at (B{C{col}}, B{C{row}}) or B{C{NULL}} if there is no such widget. 14600 14601 """ 14602 return None

14603 -def gwy_table_hscale_set_sensitive( pivot , sensitive ):

14604 """ 14605 Sets sensitivity of a group of controls create by L{gwy_table_attach_hscale}(). 14606 14607 Do not use with B{C{HSCALE_CHECK}}, simply set state of the check button 14608 in such a case. 14609 14610 This function can be used with rows created by L{gwy_table_attach_spinbutton}() 14611 too if the spinbutton is passed as B{C{pivot}}. 14612 14613 @param pivot: The same object that was passed to L{gwy_table_attach_hscale}() as 14614 B{C{pivot}}. I{(GtkObject*)} 14615 @param sensitive: B{C{True}} to make the row sensitive, B{C{False}} to insensitive. I{(bool)} 14616 @return: 14617 """ 14618 return None

14619 -def z_UNIMPLEMENTED_gwy_text_header_error_get_type( ):

14620 return None

14621 -def gwy_text_header_error_quark( ):

14622 """ 14623 Returns error domain for expression parsin and evaluation. 14624 14625 See and use B{C{TEXT_HEADER_ERROR}}. 14626 14627 Since: 2.18 14628 14629 @return: The error domain. 14630 14631 14632 """ 14633 return None

14634 -def z_UNIMPLEMENTED_gwy_text_header_parse( header , parser , user_data ):

14635 """ 14636 Parses a line-oriented text header into a hash table. 14637 14638 See B{C{TextHeaderParser}} for details of memory and error handling. 14639 14640 Lines consisting only of whitespace are ignored. 14641 14642 Since: 2.18 14643 14644 @param header: Text header to parse. It must be B{C{NULL}}-terminated and writable. 14645 Its contents will be modified to directly embed the hash keys 14646 and/or values. It must not be freed while the returned hash 14647 table is in use. I{(gchar*)} 14648 @param parser: Parser specification. I{(const-TextHeaderParser*)} 14649 @param user_data: User data passed to parser callbacks. I{(gpointer)} 14650 @return: A newly created hash table with values indexed by they keys found 14651 in the header. 14652 14653 14654 """ 14655 return None

14656 -def z_UNIMPLEMENTED_gwy_ticks_style_get_type( ):

14657 return None

14658 -def gwy_tip_cmap( tip , surface , result , set_fraction , set_message ):

14659 """ 14660 Performs certainty map algorithm published by Villarrubia. This function 14661 converts all fields into form requested by "morph_lib.c" library, that is 14662 almost identical with original Villarubia's library. Result certainty map 14663 can be used as a mask of points where tip did not directly touch the 14664 surface. 14665 14666 14667 @param tip: Tip data. I{(L{DataField})} 14668 @param surface: Surface data. I{(L{DataField})} 14669 @param result: Data field to store ceratainty map data to. I{(L{DataField})} 14670 @param set_fraction: Function that sets fraction to output (or B{C{NULL}}). I{(SetFractionFunc)} 14671 @param set_message: Function that sets message to output (of B{C{NULL}}). I{(SetMessageFunc)} 14672 @return: Certainty map, i.e. B{C{result}}, on success. May return B{C{NULL}} if 14673 aborted. 14674 14675 """ 14676 return None

14677 -def gwy_tip_cmap( tip , surface ):

14678 return None

14679 -def gwy_tip_dilation( tip , surface , result , set_fraction , set_message ):

14680 """ 14681 Performs tip convolution (dilation) algorithm published by Villarrubia. This 14682 function converts all fields into form requested by "morph_lib.c" library, 14683 that is almost identical with original Villarubia's library. 14684 14685 14686 @param tip: Tip data. I{(L{DataField})} 14687 @param surface: Surface data. I{(L{DataField})} 14688 @param result: Data field where to store dilated surface to. I{(L{DataField})} 14689 @param set_fraction: Function that sets fraction to output (or B{C{NULL}}). I{(SetFractionFunc)} 14690 @param set_message: Function that sets message to output (or B{C{NULL}}). I{(SetMessageFunc)} 14691 @return: Dilated surface data, i.e. B{C{result}}, on success. May return B{C{NULL}} 14692 if aborted. 14693 14694 """ 14695 return None

14696 -def gwy_tip_dilation( tip , surface ):

14697 return None

14698 -def gwy_tip_erosion( tip , surface , result , set_fraction , set_message ):

14699 """ 14700 Performs surface reconstruction (erosion) algorithm published by 14701 Villarrubia. This function converts all fields into form requested by 14702 "morph_lib.c" library, that is almost identical with original Villarubia's 14703 library. 14704 14705 14706 @param tip: Tip data. I{(L{DataField})} 14707 @param surface: Surface to be eroded. I{(L{DataField})} 14708 @param result: Data field where to store dilated surface to. I{(L{DataField})} 14709 @param set_fraction: Function that sets fraction to output (or B{C{NULL}}). I{(SetFractionFunc)} 14710 @param set_message: Function that sets message to output (or B{C{NULL}}). I{(SetMessageFunc)} 14711 @return: Reconstructed (eroded) surface, i.e. B{C{result}}, on success. May 14712 return B{C{NULL}} if aborted. 14713 14714 """ 14715 return None

14716 -def gwy_tip_erosion( tip , surface ):

14717 return None

14718 -def gwy_tip_estimate_full( tip , surface , threshold , use_edges , count , set_fraction , set_message ):

14719 """ 14720 Performs full blind estimation algorithm published by Villarrubia. This 14721 function converts all fields into form requested by "morph_lib.c" library, 14722 that is almost identical with original Villarubia's library. Note that the 14723 threshold value must be chosen sufficently high value to supress small 14724 fluctulations due to noise (that would lead to very sharp tip) but 14725 sufficiently low value to put algorithm at work. A value similar to 1/10000 14726 of surface range can be good. Otherwise we recommend to start with zero 14727 threshold and increase it slowly to observe changes and choose right value. 14728 14729 14730 @param tip: Tip data to be refined (allocated). I{(L{DataField})} 14731 @param surface: Surface data. I{(L{DataField})} 14732 @param threshold: Threshold for noise supression. I{(float)} 14733 @param use_edges: Whether use also edges of image. I{(bool)} 14734 @param count: Where to store the number of places that produced refinements to. I{(int)} 14735 @param set_fraction: Function that sets fraction to output (or B{C{NULL}}). I{(SetFractionFunc)} 14736 @param set_message: Function that sets message to output (or B{C{NULL}}). I{(SetMessageFunc)} 14737 @return: Estimated tip. May return B{C{NULL}} if aborted. 14738 14739 """ 14740 return None

14741 -def gwy_tip_estimate_full( tip , surface , threshold , use_edges ):

14742 return None

14743 -def gwy_tip_estimate_partial( tip , surface , threshold , use_edges , count , set_fraction , set_message ):

14744 """ 14745 Performs partial blind estimation algorithm published by Villarrubia. This 14746 function converts all fields into form requested by "morph_lib.c" library, 14747 that is almost identical with original Villarubia's library. Note that the 14748 threshold value must be chosen sufficently high value to supress small 14749 fluctulations due to noise (that would lead to very sharp tip) but 14750 sufficiently low value to put algorithm at work. A value similar to 1/10000 14751 of surface range can be good. Otherwise we recommend to start with zero 14752 threshold and increase it slowly to observe changes and choose right value. 14753 14754 14755 @param tip: Tip data to be refined (allocated). I{(L{DataField})} 14756 @param surface: Surface data. I{(L{DataField})} 14757 @param threshold: Threshold for noise supression. I{(float)} 14758 @param use_edges: Whether use also edges of image. I{(bool)} 14759 @param count: Where to store the number of places that produced refinements to. I{(int)} 14760 @param set_fraction: Function that sets fraction to output (or B{C{NULL}}). I{(SetFractionFunc)} 14761 @param set_message: Function that sets message to output (or B{C{NULL}}). I{(SetMessageFunc)} 14762 @return: Estimated tip. May return B{C{NULL}} if aborted. 14763 14764 """ 14765 return None

14766 -def gwy_tip_estimate_partial( tip , surface , threshold , use_edges ):

14767 return None

14768 -def gwy_tip_model_get_npresets( ):

14769 """ 14770 Find number of actual tip model presets. 14771 14772 14773 @return: Number of presets. 14774 14775 """ 14776 return None

14777 -def z_UNIMPLEMENTED_gwy_tip_model_get_preset( preset_id ):

14778 """ 14779 Get data related to tip preset. 14780 14781 14782 @param preset_id: Preset identifier. I{(int)} 14783 @return: Chosen preset data. 14784 14785 """ 14786 return None

14787 -def z_UNIMPLEMENTED_gwy_tip_model_get_preset_by_name( name ):

14788 """ 14789 Get data related to preset with specified name. 14790 14791 14792 @param name: Name of tip (e. g. "contact"). I{(string)} 14793 @return: Chosen preset data. 14794 14795 """ 14796 return None

14797 -def z_UNIMPLEMENTED_gwy_tip_model_get_preset_group_name( preset ):

14798 """ 14799 Get group name of preset (e. g. "analytical".) 14800 14801 14802 @param preset: Tip model preset. I{(const-TipModelPreset*)} 14803 @return: Preset group name. 14804 14805 """ 14806 return None

14807 -def z_UNIMPLEMENTED_gwy_tip_model_get_preset_id( preset ):

14808 """ 14809 Get preset identifier within all presets. 14810 14811 14812 @param preset: Tip model preset. I{(const-TipModelPreset*)} 14813 @return: Preset id. 14814 14815 """ 14816 return None

14817 -def z_UNIMPLEMENTED_gwy_tip_model_get_preset_nparams( preset ):

14818 """ 14819 Get number of tip preset parameters. 14820 14821 14822 @param preset: Tip model preset. I{(const-TipModelPreset*)} 14823 @return: Number of parameters. 14824 14825 """ 14826 return None

14827 -def z_UNIMPLEMENTED_gwy_tip_model_get_preset_tip_name( preset ):

14828 """ 14829 Get name of the preset (e. g. "contact"). 14830 14831 14832 @param preset: Tip model preset. I{(const-TipModelPreset*)} 14833 @return: Preset name. 14834 14835 """ 14836 return None

14837 -def z_UNIMPLEMENTED_gwy_tip_type_get_type( ):

14838 return None

14839 -def z_UNIMPLEMENTED_gwy_tool_func_foreach( function , user_data ):

14840 """ 14841 Calls a function for each tool function. 14842 14843 @param function: Function to run for each tool function. It will get function 14844 name (constant string owned by module system) as its first 14845 argument, B{C{user_data}} as the second argument. I{(GFunc)} 14846 @param user_data: Data to pass to B{C{function}}. I{(gpointer)} 14847 @return: 14848 """ 14849 return None

14850 -def gwy_tool_func_register( type ):

14851 """ 14852 Registeres a tool function (tool type). 14853 14854 14855 @param type: Layer type in GObject type system. That is the return value of 14856 L{gwy_tool_foo_get_type}(). I{(GType)} 14857 @return: Normally B{C{True}}; B{C{False}} on failure. 14858 14859 """ 14860 return None

14861 -def z_UNIMPLEMENTED_gwy_tool_switch_event_get_type( ):

14862 return None

14863 -def z_UNIMPLEMENTED_gwy_transform_direction_get_type( ):

14864 return None

14865 -def gwy_type_init( ):

14866 """ 14867 Makes libgwyddion types safe for deserialization and performs other 14868 initialization. You have to call this function before using objects 14869 from libgwyddion. 14870 14871 Calls g_type_init() first to make sure GLib object system is initialized. 14872 14873 It is safe to call this function more than once, subsequent calls are no-op. 14874 14875 @return: 14876 """ 14877 return None

14878 -def z_UNIMPLEMENTED_gwy_undo_checkpointv( data , n , keys ):

14879 """ 14880 Create a point in the undo history it is possible to return to. 14881 14882 14883 @param data: A data container. I{(L{Container})} 14884 @param n: The number of strings in B{C{keys}}. I{(int)} 14885 @param keys: An array of container string keys to save data. 14886 It can contain holes, that is NUL's, they are ignored. However, it 14887 should contain at least one real key. I{(const-gchar**)} 14888 @return: Undo level id. Not useful (yet). 14889 14890 """ 14891 return None

14892 -def gwy_undo_container_get_modified( data ):

14893 """ 14894 Tests whether a container was modified. 14895 14896 FIXME: it may not work. 14897 14898 14899 @param data: Data container to get modification infomation of. I{(L{Container})} 14900 @return: B{C{True}} if container was modified, B{C{False}} otherwise. 14901 14902 """ 14903 return None

14904 -def gwy_undo_container_has_redo( data ):

14905 """ 14906 Returns whether there is any redo available for a container. 14907 14908 14909 @param data: Data container to get redo infomation of. I{(L{Container})} 14910 @return: B{C{True}} if there is redo, B{C{False}} otherwise. 14911 14912 """ 14913 return None

14914 -def gwy_undo_container_has_undo( data ):

14915 """ 14916 Returns whether there is any undo available for a container. 14917 14918 14919 @param data: Data container to get undo infomation of. I{(L{Container})} 14920 @return: B{C{True}} if there is undo, B{C{False}} otherwise. 14921 14922 """ 14923 return None

14924 -def gwy_undo_container_remove( data , prefix ):

14925 """ 14926 Removes undo/redo information for a data container. 14927 14928 @param data: A data container. I{(L{Container})} 14929 @param prefix: Prefix to remove undo/redo information under. Pass B{C{NULL}} to remove 14930 undo/redo information altogether. I{(string)} 14931 @return: 14932 """ 14933 return None

14934 -def gwy_undo_container_set_unmodified( data ):

14935 """ 14936 Marks a data container as umodified (that is, saved). 14937 14938 @param data: Data container to set modification infomation of. I{(L{Container})} 14939 @return: 14940 """ 14941 return None

14942 -def gwy_undo_get_enabled( ):

14943 """ 14944 Reports whether undo/redo is globally enabled. 14945 14946 Since: 2.21 14947 14948 @return: B{C{True}} if undo/redo is enabled, B{C{False}} if it is disabled. 14949 14950 14951 """ 14952 return None

14953 -def z_UNIMPLEMENTED_gwy_undo_qcheckpointv( data , n , keys ):

14954 """ 14955 Create a point in the undo history it is possible to return to. 14956 14957 14958 @param data: A data container. I{(L{Container})} 14959 @param n: The number of strings in B{C{keys}}. I{(int)} 14960 @param keys: An array of container quark keys to save data. 14961 It can contain holes, that is 0's, they are ignored. However, it 14962 should contain at least one real key. I{(const-GQuark*)} 14963 @return: Undo level id. Not useful (yet). 14964 14965 """ 14966 return None

14967 -def gwy_undo_redo_container( data ):

14968 """ 14969 Performs undo on a data container. 14970 14971 It must have redo available. 14972 14973 @param data: A data container. I{(L{Container})} 14974 @return: 14975 """ 14976 return None

14977 -def gwy_undo_set_enabled( setting ):

14978 """ 14979 Globally enables or disables undo/redo. 14980 14981 By default, undo/redo is enabled. Non-GUI applications that run module 14982 functions may wish to disable it to conserve resources. 14983 14984 If undo/redo is disabled undo information manipulating functions such as 14985 L{gwy_app_undo_qcheckpoint}() become no-op and 14986 L{gwy_undo_container_get_modified}() always returns zero. Disabling undo also 14987 removes saved undo data of all containers. 14988 14989 Since: 2.21 14990 14991 @param setting: B{C{True}} to enable undo, B{C{False}} to disable it. I{(bool)} 14992 @return: 14993 """ 14994 return None

14995 -def gwy_undo_undo_container( data ):

14996 """ 14997 Performs undo on a data container. 14998 14999 It must have undo available. 15000 15001 @param data: A data container. I{(L{Container})} 15002 @return: 15003 """ 15004 return None

15005 -def z_UNIMPLEMENTED_gwy_units_placement_get_type( ):

15006 return None

15007 -def z_UNIMPLEMENTED_gwy_vector_layer_get_type( ):

15008 return None

15009 -def gwy_version_major( ):

15010 """ 15011 Gets the major version of Gwyddion. 15012 15013 If the version is 1.99.7.20060604, this function returns 1. 15014 15015 15016 @return: The major version. 15017 15018 """ 15019 return None

15020 -def gwy_version_minor( ):

15021 """ 15022 Gets the minor version of Gwyddion. 15023 15024 If the version is 1.99.7.20060604, this function returns 99. 15025 15026 15027 @return: The minor version. 15028 15029 """ 15030 return None

15031 -def gwy_version_string( ):

15032 """ 15033 Gets the full Gwyddion version as a string. 15034 15035 If the version is 1.99.7.20060604, this function returns 15036 <literal>"1.99.7.20060604"</literal>. 15037 15038 This is the only method to get finer version information than major.minor. 15039 However, only development versions use finer versioning than major.minor 15040 therefore a module or app requiring such information is probably broken 15041 anyway. A meaningful use is to advertise the version of Gwyddion your app 15042 runs with. 15043 15044 15045 @return: The full version as a constant string. 15046 15047 """ 15048 return None

15049 -def z_UNIMPLEMENTED_gwy_visibility_reset_type_get_type( ):

15050 return None

15051 -def z_UNIMPLEMENTED_gwy_vruler_get_type( ):

15052 return None

15053 -def z_UNIMPLEMENTED_gwy_watershed_state_type_get_type( ):

15054 return None

15055 -def gwy_widget_get_activate_on_unfocus( widget ):

15056 """ 15057 Obtains the activate-on-unfocus state of a widget. 15058 15059 Since: 2.5 15060 15061 @param widget: A widget. I{(L{gtk.Widget})} 15062 @return: B{C{True}} if signal "GtkWidget::activate" is emitted when focus leaves 15063 the widget. 15064 15065 15066 """ 15067 return None

15068 -def gwy_widget_set_activate_on_unfocus( widget , activate ):

15069 """ 15070 Sets the activate-on-unfocus state of a widget. 15071 15072 When it is enabled, signal "GtkWidget::activate" is emited whenever focus 15073 leaves the widget. 15074 15075 Since: 2.5 15076 15077 @param widget: A widget. I{(L{gtk.Widget})} 15078 @param activate: B{C{True}} to enable activate-on-unfocus, B{C{False}} disable it. I{(bool)} 15079 @return: 15080 """ 15081 return None

15082 -def gwy_widget_sync_sensitivity( master , slave ):

15083 """ 15084 Make widget's sensitivity follow the sensitivity of another widget. 15085 15086 The sensitivity of B{C{slave}} is set according to B{C{master}}'s effective 15087 sensitivity (as returned by GTK_WIDGET_IS_SENSITIVE()), i.e. it does not 15088 just synchronize GtkWidget:sensitive property. 15089 15090 Since: 2.8 15091 15092 @param master: Master widget. I{(L{gtk.Widget})} 15093 @param slave: Slave widget. I{(L{gtk.Widget})} 15094 @return: 15095 """ 15096 return None

15097 -def gwy_widgets_get_gl_config( ):

15098 """ 15099 Returns OpenGL framebuffer configuration for 3D widgets. 15100 15101 Call L{gwy_widgets_gl_init}() first. 15102 15103 15104 @return: The OpenGL framebuffer configuration, B{C{NULL}} if OpenGL 15105 initialization was not successfull. 15106 15107 """ 15108 return None

15109 -def gwy_widgets_gl_init( ):

15110 """ 15111 Configures an OpenGL-capable visual for 3D widgets. 15112 15113 Use L{gwy_widgets_get_gl_config}() to get the framebuffer configuration. 15114 15115 This function must be called before OpenGL widgets can be used. 15116 15117 15118 @return: B{C{True}} if an appropriate visual was found. If Gwyddion was compiled 15119 without OpenGL support, it always returns B{C{False}}. 15120 15121 """ 15122 return None

15123 -def gwy_widgets_type_init( ):

15124 """ 15125 Makes libgwydgets types safe for deserialization and performs other 15126 initialization. You have to call this function before using widgets and 15127 objects from libgwydgets. 15128 15129 Calls L{gwy_draw_type_init}() first to make sure libgwydraw is initialized. 15130 15131 It is safe to call this function more than once, subsequent calls are no-op. 15132 15133 @return: 15134 """ 15135 return None

15136 -def z_UNIMPLEMENTED_gwy_windowing_type_get_enum( ):

15137 """ 15138 Returns B{C{Enum}} for B{C{WindowingType}} enum type. 15139 15140 15141 @return: B{C{NULL}}-terminated B{C{Enum}} which must not be modified nor freed. 15142 15143 """ 15144 return None

15145 -def z_UNIMPLEMENTED_gwy_windowing_type_get_type( ):

15146 return None

15147 -def z_UNIMPLEMENTED_gwyfile_pack_metadata( data ):

15148 return None

15149 -def z_UNIMPLEMENTED_match_line( res , ref , cmp , maxoff , offset , score ):

15150 return None

15151 -def z_UNIMPLEMENTED_omicronflat_getscalingfactor( ):

15152 return None

15153 -def z_UNIMPLEMENTED_omicronflat_load( ):

15154 return None

15155 -def z_UNIMPLEMENTED_omicronflat_read2dimage( ):

15156 return None

15157 -def z_UNIMPLEMENTED_omicronflat_readcits( ):

15158 return None

15159 -def z_UNIMPLEMENTED_omicronflat_readmetadata( ):

15160 return None

15161 -def z_UNIMPLEMENTED_omicronflat_readmetainfo( ):

15162 return None

15163 -def z_UNIMPLEMENTED_omicronflat_readsps( ):

15164 return None

15165 -def z_UNIMPLEMENTED_omicronflat_readstring( ):

15166 return None

15167 -def z_UNIMPLEMENTED_open_temporary_file( filename , error ):

15168 return None

15169 -def z_UNIMPLEMENTED_proc_find_plugin( name , run ):

15170 return None

15171 -def z_UNIMPLEMENTED_proc_plugin_proxy_run( data , run , name ):

15172 return None

15173 -def z_UNIMPLEMENTED_proc_register_plugins( plugins , file , buffer ):

15174 return None

15175 -def z_UNIMPLEMENTED_register_plugins( plugins , dir , register_func ):

15176 return None

15177 -def z_UNIMPLEMENTED_text_dump_export( data , filename , error ):

15178 return None

15179

Source Code for Module gwy