public inbox for guile-gtk@sourceware.org
 help / color / mirror / Atom feed
* texinfo documentation
@ 2003-05-12  1:21 Kevin Ryde
  2003-05-12  1:52 ` Marko Rauhamaa
  0 siblings, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-12  1:21 UTC (permalink / raw)
  To: guile-gtk

I'm proposing to put together a bit of texinfo documentation for
guile-gtk.  There's not a huge amount to say, certainly there's no
need to duplicate the gtk docs, but there's enough to be worth a bit
of a manual I think.

I've actually made a start, mainly adapting the README file and one or
two notes of my own.  The advantage of changing to texinfo is of
course nice indexing and the various output formats.  I'll post
something when there's more to see.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-12  1:21 texinfo documentation Kevin Ryde
@ 2003-05-12  1:52 ` Marko Rauhamaa
  2003-05-23 22:01   ` Kevin Ryde
  0 siblings, 1 reply; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-12  1:52 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> I've actually made a start, mainly adapting the README file and one or
> two notes of my own.  The advantage of changing to texinfo is of
> course nice indexing and the various output formats.  I'll post
> something when there's more to see.

You may want to take a look at

   http://pacujo.net/marko/guile/defs.html

as well. I'm keeping it up to date with my modifications and progress of
understanding.


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-12  1:52 ` Marko Rauhamaa
@ 2003-05-23 22:01   ` Kevin Ryde
  2003-05-23 23:36     ` Marko Rauhamaa
  0 siblings, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-23 22:01 UTC (permalink / raw)
  To: Marko Rauhamaa; +Cc: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
>    http://pacujo.net/marko/guile/defs.html

There's no doubt some nice notes there, but initially I'm only
interested in getting the documented interfaces tied down.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-23 22:01   ` Kevin Ryde
@ 2003-05-23 23:36     ` Marko Rauhamaa
  2003-05-23 23:57       ` Kevin Ryde
  0 siblings, 1 reply; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-23 23:36 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> Marko Rauhamaa <marko@pacujo.net> writes:
> >
> >    http://pacujo.net/marko/guile/defs.html
> 
> There's no doubt some nice notes there, but initially I'm only
> interested in getting the documented interfaces tied down.

I'm sorry but I don't understand that comment. What "documented
interfaces" are you talking about, and what do you mean by "tying them
down"?


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-23 23:36     ` Marko Rauhamaa
@ 2003-05-23 23:57       ` Kevin Ryde
  2003-05-24  0:05         ` Marko Rauhamaa
  0 siblings, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-23 23:57 UTC (permalink / raw)
  To: Marko Rauhamaa; +Cc: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
> I'm sorry but I don't understand that comment. What "documented
> interfaces" are you talking about,

The functions and variables that an application programmer using
guile-gtk will utilize.  How they work internally doesn't matter, not
directly.

> and what do you mean by "tying them down"?

Currently not all aspects (of how stuff works from within guile) are
spelt out in as much detail as would be desirable.  In my view at
least.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-23 23:57       ` Kevin Ryde
@ 2003-05-24  0:05         ` Marko Rauhamaa
  2003-05-24  2:19           ` Kevin Ryde
  0 siblings, 1 reply; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-24  0:05 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> Marko Rauhamaa <marko@pacujo.net> writes:
> >
> > I'm sorry but I don't understand that comment. What "documented
> > interfaces" are you talking about,
> 
> The functions and variables that an application programmer using
> guile-gtk will utilize. How they work internally doesn't matter, not
> directly.

Ah, ok. I mentioned this to Marius, and he expressed the wish that it
should be enough to read the GTK+ C library documentation. But at least
the existing deviations should be noted.


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-24  0:05         ` Marko Rauhamaa
@ 2003-05-24  2:19           ` Kevin Ryde
       [not found]             ` <m3llwwdhjf.fsf@lumo.pacujo.net>
  0 siblings, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-24  2:19 UTC (permalink / raw)
  To: guile-gtk

[-- Attachment #1: Type: text/plain, Size: 984 bytes --]

Marko Rauhamaa <marko@pacujo.net> writes:
>
> Ah, ok. I mentioned this to Marius, and he expressed the wish that it
> should be enough to read the GTK+ C library documentation.

Of course you have to know the transformations for names and types and
stuff.

Below is where I'm up to (text output of .texi).  It basically
represents an expansion of various bits of the README.  There's
various issues to be considered about what's meant to be documented
features and not.  For instance I'm not sure if the (gtk threads)
module is to be considered experimental or final.

I haven't got around to saying anything about GdkPixbuf.  And nothing
about Glade yet either (partly because I only know a little about how
it's supposed to work).

If the TODO file entry about integration with gnome-guile comes to
pass then I'd be happy to add words about that stuff too.  (I think
it'd be a good thing to be all-in-one.  It's easy with autoconf to
build only what's possible or what's desired.)


[-- Attachment #2: guile-gtk.txt --]
[-- Type: text/plain, Size: 20491 bytes --]

START-INFO-DIR-ENTRY
* gtk-guile: (gtk-guile).	Guile interface to Gtk.
END-INFO-DIR-ENTRY

Gtk Guile
*********

This manual describes how to install and use the Guile interface to Gtk,
version {No value for `VERSION'}.

   Copyright 2003 Kevin Ryde.

   Permission is granted to make and distribute verbatim copies of this
manual provided the copyright notice and this permission notice are
preserved on all copies.

   Permission is granted to copy and distribute modified versions of
this manual under the conditions for verbatim copying, provided that
the entire resulting derived work is distributed under the terms of a
permission notice identical to this one.

   Permission is granted to copy and distribute translations of this
manual into another language, under the above conditions for modified
versions, except that this permission notice may be stated in a
translation approved by Free Software Foundation.


...Table of Contents...
Introduction
************

Guile Gtk makes the Gtk+, Gdk Pixbuf, Glade and Gtk GL graphical user
interface libraries available from within Guile.  This manual makes no
attempt to document those libraries, only how to use them from Guile.
(*note The Guile Reference Manual: (guile)Top.)

   Currently Guile Gtk supports Gtk version 1.2, and versions of Gdk
Pixbuf, Glade and Gtk GL corresponding to that.

   The Guile Gtk home page is `http://non-gnu.org/guile-gtk'.  A mailing
list for users and developers is available, see the home page for
details.

   As a taste of Guile Gtk style, here is a hello world program.  Those
familiar with Gtk should find it straightforward.

     (use-modules (gtk gtk))
     
     (define top (gtk-window-new 'toplevel))
     (gtk-signal-connect top "destroy" gtk-exit)
     
     (define label (gtk-label-new " Hello world! "))
     (gtk-container-add top label)
     
     (gtk-widget-show-all top)
     (gtk-main)

Installing
**********

To build and install you will need Guile 1.6.4 or higher, and Gtk
version 1.2.x.  Gdk Pixbuf, Glade and Gtk GL are optional, support for
them will be built if they're available.

   Guile Gtk uses an Autoconf, Automake and Libtool based configuration
system.  A basic build can be made with,

     ./configure
     make

Some self-tests can be run with

     make check

And you can install (under `/usr/local' by default) with

     make install

   The file `INSTALL' has generic information about `./configure'.
Running `./configure --help' will print a summary of the usage and
options.  The following Guile Gtk specific options are available.

`--with-gdk-pixbuf=yes/no'
`--with-libglade=yes/no'
`--with-gtkgl=yes/no'
     Enable or disable Gdk Pixbuf, Glade, or Gtk GL support,
     respectively.  The default for each is to enable it if available.

Known Problems
**************

`app'
     Don't be tempted to define `app' to some sort of widget or the
     like.  In Guile 1.6.4 `app' is used for the implementation of the
     module system.

Reporting Bugs
**************

If you think you've found a bug in Guile Gtk, please investigate and
make a full report.  Include the following in any report,

   * System and CPU type, obtained from running `./config.guess' (or
     `uname -a' if your system is unknown).

   * The versions of Guile and Guile Gtk, the configuration options
     used, and if patched or packaged then say so.

   * The build compiler and its version.

   * A test program illustrating the problem.  Describe how to run it,
     what it does, and what you think it should do.

   * If you get a Scheme level error, include the backtrace obtained
     from running with `guile --debug'.

   * If you get a C level crash, try running under the debugger and
     include a backtrace (`where' in GDB) if it's informative.

   * If the bug is related to `./configure', then the contents of
     `config.log'.

Send your report to <guile-gtk@sources.redhat.com>.

General Conventions
*******************

Unless otherwise stated, Gtk+ functions and variables are made
available in Guile with names transformed to Guile conventions.  This
means underscores become hyphens, and only lower case is used.

   For instance the C function `gtk_label_new' is `gtk-label-new' in
Guile, or `GTK_WIDGET_FLAGS' is `gtk-widget-flags'.

   The following general rules are applied to parameters and return
values.

`NULL'
     `NULL' is represented as `#f' within Guile, for functions which
     accept or return `NULL'.

`int', `gint', etc
     All Glib integer types are simply Guile integers.  Range checks
     are applied to parameters, and "inexact" values are not accepted,
     even if they happen to be integers.  (*note Exact and Inexact
     Numbers: (guile)Exactness.)

`gboolean'
     Booleans are returned as the usual Guile `#t' and `#f'.  Any
     non-`#f' value is taken to be true in a parameter.

`GList', `GSList' etc
     Are passed and returned as Guile lists.  For instance
     `gtk-container-children' returns a list of widgets.

Arrays
     Are passed or returned as Guile lists.  For instance
     `gtk-curve-set-vector' takes a list of floats.

`enum' enumerations
     Enumerations are represented in Guile as symbols, with names
     corresponding to the C definitions but without the prefix
     indicating their type.

     For instance `GtkWindowType' value `GTK_WINDOW_TOPLEVEL' is just
     the symbol `toplevel'.

`enum' flags
     Sets of flags are represented in Guile as a list of symbols,
     possibly an empty list, with names corresponding to the C
     definitions but without the prefix indicating their type.

     For example a `GdkModifierType' value could be a list `(shift-mask
     control-mask)'.

Signal names
     Signal names are Guile strings, for instance `"clicked"' or
     `"map_event"'.

Signal handler functions
     At the Guile level signal handler procedures are passed the same
     parameters as the C code functions, except the object and
     client-data are omitted.  The return value is used when the signal
     expects a return value.

     For instance the `clicked' signal from a `GtkButton' passes no
     parameters,

          (define (my-click-handler)
            (display "hello\n"))
          (gtk-signal-connect button "clicked" my-click-handler)

     Or an `expose_event' passes just a `GtkEvent', and expects a return
     value.

          (define (my-expose-handler)
            (do-some-drawing)
            #f)  ;; propagate event to other handlers
          (gtk-signal-connect drawarea "expose_event" my-expose-handler)

     The object and client data parameters are deliberately omitted.
     Such things can be handled in a more Scheme-like and flexible way
     with a closure, ie. captured variables with desired values.  *note
     The Concept of Closure: (guile)About Closure..

Multiple return values
     A list of values is returned for functions with multiple return
     values.

     For example at the C level `gtk_pixmap_get' returns a `GdkPixmap'
     and a `GdkBitmap' via pointers.  Guile Gtk `gtk-pixmap-get' returns
     these in a two-element list.

Threading
     Guile threads can be used by a Guile Gtk program, and the Glib
     library thread primitives are setup to use the Guile functionality.

     Gtk functions are not thread-safe, but Guile Gtk avoids problems
     in this area by preventing other threads running while it's in
     Gtk.  This means an application doesn't have to follow the normal
     rules for threaded Gtk programs in the use of `gdk-threads-enter'
     and `gdk-threads-leave', but those functions are still available
     and still work in the usual way.

Gdk Module
**********

The Gdk interface module can be used with

     (use-modules (gtk gdk))

   A call to `gdk_init' is made automatically, an application doesn't
need to do that itself.  The program command line is searched for
standard Gdk arguments and removed when found (for instance `--display'.
*note Runtime Environment: (guile)Runtime Environment..

   The following rules apply to the various Gdk types.

Equality
     Currently Gdk objects are not uniquely represented by a single
     Guile level object, meaning they cannot be compared with `eq?',
     and unfortunately currently `equal?' cannot be used either.  Gdk
     functions like `gdk-font-equal' and `gdk-color-equal' can be used
     in the usual way though.

`GdkAtom'
     Is passed and returned as a Guile symbol, for example `WM_NAME'.

`GdkColor'
     As a convenience, functions expecting a `GdkColor' object can be
     passed a string, which will be parsed and allocated to a pixel in
     the default colormap, as per `gdk-color-intern' (*note Gdk
     Extras::).

`GdkCursor'
     As a convenience, functions expecting a `GdkCursor' object can be
     passed a Guile symbol, which will be converted to a cursor object
     as per `gdk-cursor-new'.  The symbol should be from the
     `GdkCursorType' enumeration, translated to Guile form in the usual
     Guile Gtk fashion.  For example `GDK_CROSS_REVERSE' would be
     `cross-reverse'.

`GdkFont'
     As a convenience, functions expecting a `GdkFont' object can be
     passed a string, which will be loaded as per `gdk-font-intern'
     (*note Gdk Extras::).

`GdkPoint'
     Is represented as a pair, with `x' in the `car' and `y' in the
     `cdr'.  (*note Pairs: (guile)Pairs.)

Pixels
     Are represented as integers, in the usual Gdk fashion.  Guile Gtk
     makes no attempt to track what pixels are allocated in what
     colormaps, any management of that is left to applications.


The following standard Gdk functions have particular notes for the
Guile Gtk interface.

 - Function: gdk-pixmap-new drawable width height [depth]
     DEPTH defaults to -1, meaning copy from DRAWABLE.

Gdk Extras
**********

The following are extra Gdk level functions provided by Guile Gtk.

 - Function: gdk-color-intern color
     If COLOR is a `GdkColor' object, return it.  If it's a string then
     parse it using `gdk-color-parse' and allocate a pixel in the
     default colormap using `gdk-color-alloc'.

     A program can use `gdk-color-intern' as an easy way to convert
     strings to `GdkColor' objects, so as to avoid repeatedly having
     that done when calling functions expecting a color.

 - Function: gdk-font-intern font
     If FONT is a `GdkFont' object, return it.  If it's a string then
     load that font using `gdk-font-load', throwing an error if that
     function fails.

     A program can use `gdk-font-intern' as an easy way to convert
     strings to `GdkFont' objects, so as to avoid repeatedly having
     that done when calling functions expecting a font.

Gtk Module
**********

The Gtk interface module can be used with

     (use-modules (gtk gtk))

   A call to `gtk_init' is made automatically, an application doesn't
need to do that itself.  The program command line is searched for
standard Gtk arguments, and removed when found (for instance
`--gtk-module'.  *note Runtime Environment: (guile)Runtime Environment..

   The following rules apply to the various Gtk types.

Gtk Objects
     Type predicates like `GTK_IS_CHECK_BUTTON' are implemented as for
     instance `gtk-check-button?'.  There are no type checking casts
     like in C, Guile functions expecting a particular object class
     always check they get that class, or a sub-class.

     Each Gtk object is represented uniquely at the Scheme level, so
     widgets etc can be compared or hashed with `eq?'.  An object will
     be destroyed when garbage collected, assuming it's not otherwise
     in use by Gtk.

`GtkAdjustment'
     All the fields can be read or set directly, for instance
     `gtk-adjustment-page-size' or `gtk-adjustment-set-lower'.

     Note that `gtk-adjustment-set-value' is the corresponding C
     function, and will emit the `value_changed' signal.  The other
     `set' functions are Guile Gtk field setters and an application
     should call the standard `gtk-adjustment-changed' when ready to
     emit the `changed' signal.


The following standard Gtk functions have particular notes for the
Guile Gtk interface.

 - Function: gtk-box-pack-start box child [expand [fill [padding]]]
 - Function: gtk-box-pack-end box child [expand [fill [padding]]]
     EXPAND and FILL default to `#f', PADDING defaults to 0.

 - Function: gtk-exit [exitcode]
     EXITCODE defaults to 0, meaning normal successful termination.

 - Function: gtk-pixmap-new pixmap [bitmap]
 - Function: gtk-pixmap-set pixmap [bitmap]
     BITMAP defaults to `#f', meaning no mask.

 - Function: gtk-scrolled-window-new [hadjustment [vadjustment]]
     HADJUSTMENT and VADJUSTMENT default to `#f', meaning create new
     `GtkAdjustment' objects.

 - Function: gtk-signal-connect object name func [objectsignal [after]]
     OBJECTSIGNAL has no purpose and should always be `#f', which is its
     default.  AFTER defaults to `#f', meaning FUNC is called before
     OBJECT runs the default handler for this signal.

     (*note General Conventions::, for how FUNC is called.)

 - Function: gtk-table-attach table child left right top bottom [xopts
          [yopts [xpad [ypad]]]]
     XOPTS and YOPTS each default to `(expand fill)', XPAD and YPAD
     default to 0.

Gtk Extras
**********

The following are extra Gtk level functions provided by Guile Gtk.

 - Function: gtk-callback-trampoline [tramp]
     Get or set the trampoline procedure for Gtk callbacks.  With no
     arguments, the current trampoline is returned.  With an argument,
     the trampoline procedure is set, and the old procedure returned.

     When making a callback for a signal or similar, Guile Gtk goes
     through this trampoline.  TRAMP is called as `(TRAMP proc args)',
     where `proc' is the application procedure to call, and `args' is a
     list of arguments for it (possibly empty).  A minimal trampoline
     would be,

          (define (my-trampoline proc args)
            (apply proc args))

     which could also be written as `(define my-trampoline apply)'.

     The default trampoline uses `catch' to trap errors from the
     callback, and displays them in a window (*note Catching
     Exceptions: (guile)Catch.).  A stack backtrace is included if the
     Guile `debug' option is enabled (*note Debugger options:
     (guile)Debugger options.)

     The aim is to give the user some feedback, in the GUI, about what
     has gone wrong, rather than suddenly terminating.  An application
     can set a new trampoline to do this in its preferred way.

 - Function: gtk-color-selection-get-current-color colorsel
     Return a `GdkColor' with the current color from the COLORSEL
     widget.  This color is not allocated to any colormap, so the
     `pixel' field is unspecified.  This is a standard function in Gtk
     2, and Guile Gtk makes it available under Gtk 1.2 also.


The following functions are provided by

     (use-modules (gtk threads))

 - Function: gtk-threads-ensure-handler
     Start a Gtk main loop in a new Guile thread, if this function has
     not previously been called.  This is a convenient way for an
     application ensure a main loop, but go on to do other things.

     The main loop is started within a `gdk-threads-enter' /
     `gdk-threads-leave' pair in the usual way for a threaded program,
     as per the following code.  (Though in fact it's done with a
     `dynamic-wind' so enters and leaves are correctly handled if a
     continuation is captured in `gtk-main'.)

          (gdk-threads-enter)
          (gtk-main)
          (gdk-threads-leave)

 - Function: gtk-threads-handler?
     Return true if `gtk-threads-ensure-handler' has started a Gtk main
     loop.

Obsolete Features
*****************

The following functions are considered obsolete and are not recommended
for use in new programs.

 - Function: gtk-standalone?
     Return true if Guile Gtk is running as a standalone program.  This
     is now always true.

     In the past a `guile-gtk' executable existed and had an option to
     indicate an interactive read-eval-print loop should be started, in
     which case `gtk-standalone?' returned `#f'.

 - Function: gtk-standalone-main top-widget
     When running standalone (`gtk-standalone?' returns true), run
     `gtk-main' and connect the `destroy' signal of TOP-WIDGET to
     `gtk-exit' so the program will exit when that widget is destroyed.
     When not standalone, do nothing and return immediately.

     Since `gtk-standalone?' is now always true, an application can
     just as easily connect the signal and run `gtk-main' itself.

          (gtk-signal-connect top-widget "destroy" gtk-exit)
          (gtk-main)

Example Programs
****************

The `examples' subdirectory in the sources contains various programs
illustrating Guile Gtk.

`calc.scm'
     A HP48 style desk calculator.  This takes quite a bit of code by
     the time all the widgets are setup, but it's well commented.

     A `.calcrc' in the user's home directory can add new buttons.  The
     ability to load user extensions is a powerful feature and a
     significant advantage Guile Gtk has over the regular C interface
     to Gtk.

`calendar.scm'
     A tiny program showing the `GtkCalendar' widget.

`clist.scm'
     Display the password file in a window.  (You might need to enlarge
     the window manually.)

`continuations.scm'
     Illustrate the use of Scheme continuations to have application
     code wait for a dialog to return, but all the while run the usual
     Gtk main loop.

`hello-world.scm'
     A simple program illustrating a button which can be pressed to
     print a familiar message.

`metaspline.scm'
     A Metafont style bezier spline editor, using the Gdk drawing
     primitives.

`simple.scm'
     Another simple program, with a label and a button.

`run-glade.scm'
     Load and run a Glade application.  For instance `simple.glade',

          guile -s run-glade.scm simple.glade

`test-dnd.scm'
`test-gdk.scm'
`test-glade.scm'
`test-gtk.scm'
     Test programs for drag-and-drop, Gdk, Glade and Gtk respectively.
     These are primarily for the developers' use, but can be run to see
     something happen and to test Guile Gtk is working.


Concept Index
*************

Booleans:
          See ``General Conventions''.
Bugs:
          See ``Reporting Bugs''.
Bugs, known:
          See ``Known Problems''.
Check:
          See ``Installing''.
Configure:
          See ``Installing''.
Conventions:
          See ``General Conventions''.
Example programs:
          See ``Example Programs''.
Gdk extras:
          See ``Gdk Extras''.
Gdk module <1>:
          See ``Gdk Extras''.
Gdk module:
          See ``Gdk Module''.
Gtk extras:
          See ``Gtk Extras''.
Gtk module <1>:
          See ``Gtk Extras''.
Gtk module:
          See ``Gtk Module''.
Home page:
          See ``Introduction''.
Installing:
          See ``Installing''.
Introduction:
          See ``Introduction''.
Known problems:
          See ``Known Problems''.
Mailing list:
          See ``Introduction''.
NULL:
          See ``General Conventions''.
Obsolete features:
          See ``Obsolete Features''.
Reporting bugs:
          See ``Reporting Bugs''.
Self tests:
          See ``Installing''.
Web page:
          See ``Introduction''.
Function and Type Index
***********************

gdk-color-intern:
          See ``Gdk Extras''.
gdk-font-intern:
          See ``Gdk Extras''.
gdk-pixmap-new:
          See ``Gdk Module''.
GdkAtom:
          See ``Gdk Module''.
GdkColor:
          See ``Gdk Module''.
GdkCursor:
          See ``Gdk Module''.
GdkFont:
          See ``Gdk Module''.
GdkPoint:
          See ``Gdk Module''.
gtk-box-pack-end:
          See ``Gtk Module''.
gtk-box-pack-start:
          See ``Gtk Module''.
gtk-callback-trampoline:
          See ``Gtk Extras''.
gtk-color-selection-get-current-color:
          See ``Gtk Extras''.
gtk-exit:
          See ``Gtk Module''.
gtk-pixmap-new:
          See ``Gtk Module''.
gtk-pixmap-set:
          See ``Gtk Module''.
gtk-scrolled-window-new:
          See ``Gtk Module''.
gtk-signal-connect:
          See ``Gtk Module''.
gtk-standalone-main:
          See ``Obsolete Features''.
gtk-standalone?:
          See ``Obsolete Features''.
gtk-table-attach:
          See ``Gtk Module''.
gtk-threads-ensure-handler:
          See ``Gtk Extras''.
gtk-threads-handler?:
          See ``Gtk Extras''.
GtkAdjustment:
          See ``Gtk Module''.

...Table of Contents...

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
       [not found]             ` <m3llwwdhjf.fsf@lumo.pacujo.net>
@ 2003-05-25 22:48               ` Kevin Ryde
  2003-05-25 23:28                 ` Marko Rauhamaa
  0 siblings, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-25 22:48 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
> Kevin Ryde <user42@zip.com.au>:
>
>> `app'
>>      Don't be tempted to define `app' to some sort of widget or the
>>      like.  In Guile 1.6.4 `app' is used for the implementation of the
>>      module system.
>
> What does that mean?

Exactly what it says.  Try defining app to something and then doing a
use-modules.

> It's ok to pass vectors as well.
>
> Arrays are passed and returned as guile vectors, but it's ok to pass
> lists as well.

Yep, I haven't put that yet.

> I don't know (yet) how much of the whole story needs to be exposed to
> the application developer, but the GTK functions dealing with signals
> come in two C variants: regular and full. The guile code always uses the
> full variant but strips the "-full" suffix from the procedure name.

I haven't looked closely enough to see if full variants work or can be
usefully used from scheme code.  The regular forms are presumably what
will be used most often.

> It may be worth noting that the guile version of a nonvoid C function
> with k output parameters returns a list with (k + 1) elements, but the
> guile version of a void C function with k output parameters returns a
> list with k elements.

I'll add another example.

> Also: GdkRectangle is a pair of pairs. However, whenever it is an input
> parameter, GdkRectangle is expanded into (x y w h). Thus the
> pair-of-pairs format is used only to return a GdkRectangle.

That's rather inconsistent, and will probably make life hard if one
wants to pass a returned value on to another function.

-- 
All messages to the list only.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-25 22:48               ` Kevin Ryde
@ 2003-05-25 23:28                 ` Marko Rauhamaa
  2003-05-26  0:06                   ` Kevin Ryde
  2003-05-26  0:07                   ` gdk-rectangle-new " Kevin Ryde
  0 siblings, 2 replies; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-25 23:28 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> Marko Rauhamaa <marko@pacujo.net> writes:
> >
> > Kevin Ryde <user42@zip.com.au>:
> >
> >> `app'
> >>      Don't be tempted to define `app' to some sort of widget or the
> >>      like.  In Guile 1.6.4 `app' is used for the implementation of the
> >>      module system.
> >
> > What does that mean?
> 
> Exactly what it says.  Try defining app to something and then doing a
> use-modules.

Oh, if you mean:

  `app'
      This global symbol is reserved by guile. Don't define it.

then better state it that way.

I was confused because I didn't know why I would "be tempted to define"
it "to some sort of widget".

> > I don't know (yet) how much of the whole story needs to be exposed to
> > the application developer, but the GTK functions dealing with signals
> > come in two C variants: regular and full. The guile code always uses the
> > full variant but strips the "-full" suffix from the procedure name.
> 
> I haven't looked closely enough to see if full variants work or can be
> usefully used from scheme code.  The regular forms are presumably what
> will be used most often.

There are no scheme procedures for the full variants. (But guile-gtk
secretly uses the full variants to implement the plain-vanilla
variants.)

> > Also: GdkRectangle is a pair of pairs. However, whenever it is an input
> > parameter, GdkRectangle is expanded into (x y w h). Thus the
> > pair-of-pairs format is used only to return a GdkRectangle.
> 
> That's rather inconsistent, and will probably make life hard if one
> wants to pass a returned value on to another function.

Some of the inconsistency is there in the C functions themselves. But
guile-gtk expands rectangles "consistently" everywhere. The reason is
obviously that it's nicer to call

   (gdk-useful-function window x y w h)

than

   (gdk-useful-function window (cons (cons x y) (cons w h)))


Well, you probably need rectangles most often to process exposures. It
would be nice to be able to call:

   (gdk-gc-set-clip-rectangle gc (gdk-event-area e))

instead of

   (let ((r (gdk-event-area e)))
      (gdk-gc-set-clip-rectangle (caar r) (cdar r) (cadr r) (cddr r)))

Since gdk-gc-set-clip-rectangle was added recently by me (following
existing examples), I could change it to take a rectangle.


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-25 23:28                 ` Marko Rauhamaa
@ 2003-05-26  0:06                   ` Kevin Ryde
  2003-05-26  2:42                     ` Marko Rauhamaa
  2003-05-26  0:07                   ` gdk-rectangle-new " Kevin Ryde
  1 sibling, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-26  0:06 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
>   `app'
>       This global symbol is reserved by guile. Don't define it.

Yep, beaut.

> Since gdk-gc-set-clip-rectangle was added recently by me (following
> existing examples), I could change it to take a rectangle.

I think the function called gdk-gc-set-clip-rectangle should be the
same as the corresponding C function.

By all means add some extra routine if the basic way is too painful,
but I think variations between C and scheme functions (of the same
name) will only serve to cause confusion.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* gdk-rectangle-new (was: texinfo documentation)
  2003-05-25 23:28                 ` Marko Rauhamaa
  2003-05-26  0:06                   ` Kevin Ryde
@ 2003-05-26  0:07                   ` Kevin Ryde
  2003-05-26  1:20                     ` Marko Rauhamaa
  1 sibling, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-26  0:07 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
> ... (cons (cons x y) (cons w h)))

There's probably some value in a gdk-rectangle-new function,
irrespective of what the underlying representation is.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: gdk-rectangle-new (was: texinfo documentation)
  2003-05-26  0:07                   ` gdk-rectangle-new " Kevin Ryde
@ 2003-05-26  1:20                     ` Marko Rauhamaa
  0 siblings, 0 replies; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-26  1:20 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> Marko Rauhamaa <marko@pacujo.net> writes:
> >
> > ... (cons (cons x y) (cons w h)))
> 
> There's probably some value in a gdk-rectangle-new function,
> irrespective of what the underlying representation is.

Next you'll be asking for

   (gdk-rectangle-x rect)
   (gdk-rectangle-y rect)
   (gdk-rectangle-width rect)
   (gdk-rectangle-height rect)

;-)

And don't forget that for consistency's sake we'll have to introduce:

   (gdk-point-new)
   (gdk-point-x)
   (gdk-point-y)


The "underlying representation" is not opaque; as it stands, the
application programmer must deal with it directly.

Of course, for clarity you can say:

   `((,x . ,y) ,w . ,h)


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-26  0:06                   ` Kevin Ryde
@ 2003-05-26  2:42                     ` Marko Rauhamaa
  2003-05-29 23:37                       ` Kevin Ryde
  2003-05-29 23:43                       ` texinfo documentation Kevin Ryde
  0 siblings, 2 replies; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-26  2:42 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> I think the function called gdk-gc-set-clip-rectangle should be the
> same as the corresponding C function.

I have now changed all the rectangle-inputting procedures to input
GdkRectangle's instead of (x,y,w,h).

> By all means add some extra routine if the basic way is too painful,
> but I think variations between C and scheme functions (of the same
> name) will only serve to cause confusion.

Here are examples of the few remaining discrepancies:

 - C: gboolean gdk_rectangle_intersect (GdkRectangle *r1,
                                        GdkRectangle *r2,
                                        GdkRectangle *dest);

   guile-gtk: (gdk-rectangle-intersect rect1 rect2) => rect or #f

   instead of: (gdk-rectangle-intersect rect1 rect2) => (bool rect)

 - C: void gdk_rectangle_union (GdkRectangle *src1,
                                GdkRectangle *src2,
                                GdkRectangle *dest);

   guile-gtk: (gdk-rectangle-union rect1 rect2) => rect

   instead of: (gdk-rectangle-union rect1 rect2) => (rect)

 - C: gint gdk_string_to_compound_text (const gchar *str,
					GdkAtom *encoding, gint *format,
					guchar **ctext, gint *length);

   (where the return value is 0 on success)

   guile-gtk: (gdk-string-to-compound str) => (string or #f
                                               encoding
                                               format)

   instead of: (gdk-string-to-compound str) => (int
                                                encoding
                                                format
                                                (cvecr uint))


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-26  2:42                     ` Marko Rauhamaa
@ 2003-05-29 23:37                       ` Kevin Ryde
  2003-05-30  1:06                         ` Marko Rauhamaa
  2003-05-29 23:43                       ` texinfo documentation Kevin Ryde
  1 sibling, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-05-29 23:37 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
>    guile-gtk: (gdk-rectangle-intersect rect1 rect2) => rect or #f
>
>    guile-gtk: (gdk-rectangle-union rect1 rect2) => rect

These two look sensible, and will suit typical rectangle arithmetic.

>    guile-gtk: (gdk-string-to-compound str) => (string or #f
>                                                encoding
>                                                format)

Hmm.  (bool encoding format string) would better match the C function,
in particular enough not to need to be described as a special case.

(Or only with a general note somewhere that gint returns that should
be understdood as gboolean are treated that way by guile-gtk.)


Obviously there's no need to be absolutely slavish, but every
difference is an inconsistency and a likely source of annoyance for
programmers.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-26  2:42                     ` Marko Rauhamaa
  2003-05-29 23:37                       ` Kevin Ryde
@ 2003-05-29 23:43                       ` Kevin Ryde
  2003-06-01  4:31                         ` Marko Rauhamaa
  2003-07-07 22:29                         ` gdk-window-get-geometry " Kevin Ryde
  1 sibling, 2 replies; 21+ messages in thread
From: Kevin Ryde @ 2003-05-29 23:43 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
> I have now changed all the rectangle-inputting procedures to input
> GdkRectangle's instead of (x,y,w,h).

In the other direction, is gdk_window_get_geometry one of yours?  You
need to name stuff in the ChangeLog so it's possible to tell.

That function really wants to be a plain multiple-values thingie, not
have its x,y,w,h transmuted into a rectangle (if I read the code
rightly).

Propose a new routine in the latter style if you have a burning need
for it, but the function called gdk-window-get-geometry really should
follow the general conventions.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-29 23:37                       ` Kevin Ryde
@ 2003-05-30  1:06                         ` Marko Rauhamaa
  2003-06-13 22:05                           ` gdk-string-to-compound (was: texinfo documentation) Kevin Ryde
  0 siblings, 1 reply; 21+ messages in thread
From: Marko Rauhamaa @ 2003-05-30  1:06 UTC (permalink / raw)
  To: guile-gtk

Kevin Ryde <user42@zip.com.au>:

> Marko Rauhamaa <marko@pacujo.net> writes:
> >    guile-gtk: (gdk-string-to-compound str) => (string or #f
> >                                                encoding
> >                                                format)
> 
> Hmm.  (bool encoding format string) would better match the C function,
> in particular enough not to need to be described as a special case.
> 
> (Or only with a general note somewhere that gint returns that should
> be understdood as gboolean are treated that way by guile-gtk.)

Note that the C function returns 0 for success and any other value for
failure.

> Obviously there's no need to be absolutely slavish, but every
> difference is an inconsistency and a likely source of annoyance for
> programmers.

Since it's technically impossible to be absolutely slavish, I'm afraid
we will have to publish the signatures of each and every guile-gtk
function -- no other explanations are necessary.


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: texinfo documentation
  2003-05-29 23:43                       ` texinfo documentation Kevin Ryde
@ 2003-06-01  4:31                         ` Marko Rauhamaa
  2003-06-02 23:51                           ` gdk-window-get-origin (was: texinfo documentation) Kevin Ryde
  2003-07-07 22:29                         ` gdk-window-get-geometry " Kevin Ryde
  1 sibling, 1 reply; 21+ messages in thread
From: Marko Rauhamaa @ 2003-06-01  4:31 UTC (permalink / raw)
  To: guile-gtk; +Cc: mvo

Kevin Ryde <user42@zip.com.au>:

> Marko Rauhamaa <marko@pacujo.net> writes:
> >
> > I have now changed all the rectangle-inputting procedures to input
> > GdkRectangle's instead of (x,y,w,h).
> 
> That function really wants to be a plain multiple-values thingie, not
> have its x,y,w,h transmuted into a rectangle (if I read the code
> rightly).
> 
> Propose a new routine in the latter style if you have a burning need
> for it, but the function called gdk-window-get-geometry really should
> follow the general conventions.

I found the origin (no pun intended) of my audaciousness:

   gdk-window-get-origin

was written prior to my time, and it returns (x . y) (i.e., GdkPoint)
instead of (x y) as suggested by

   gint gdk_window_get_origin (GdkWindow *window, gint *x, gint *y);

That precedent led to a whole slew of other analogous GdkPoint routines,
and it was only natural to extend the principle to GdkRectangle as well.

While I could back out on my changes, this one would require a higher
authority. Now, gdk-window-get-origin is not included in my SuSE 7.3
release (guile-gtk ver. 0.19). Was it ever released out to the public?
It is a vintage function according to the ChangeLog (2001-02-04).

So it seems to me we are stuck with the deviation. The good side is that
the deviation is more natural for scheme programmers. The bad side is
that we can't simply refer the application developers to the C
documentation. Each guile-gtk function signature needs to be mentioned.


Marko

-- 
Marko Rauhamaa      mailto:marko@pacujo.net     http://pacujo.net/marko/

^ permalink raw reply	[flat|nested] 21+ messages in thread

* gdk-window-get-origin (was: texinfo documentation)
  2003-06-01  4:31                         ` Marko Rauhamaa
@ 2003-06-02 23:51                           ` Kevin Ryde
  0 siblings, 0 replies; 21+ messages in thread
From: Kevin Ryde @ 2003-06-02 23:51 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
>    gdk-window-get-origin
>
> was written prior to my time, and it returns (x . y)

There are a few such.  gdk-window-get-size was the only one I'd been
using.  I'm going to put the following in the docs.

 - Function: gdk-window-get-deskrelative-origin window
 - Function: gdk-window-get-origin window
 - Function: gdk-window-get-position window
 - Function: gdk-window-get-root-origin window
 - Function: gdk-window-get-size window
     Unlike other multiple-return values functions, these return a pair
     rather than a list.  The `car' is X and the `cdr' is Y.  Or for
     `gdk-window-get-size' the same for WIDTH and HEIGHT.

> That precedent led to a whole slew of other analogous GdkPoint routines,
> and it was only natural to extend the principle to GdkRectangle as well.

I think the above should be regarded as unfortunate departures from
the multiple-values convention.

> While I could back out on my changes,

Please do so.

> this one would require a higher
> authority. Now, gdk-window-get-origin is not included in my SuSE 7.3
> release (guile-gtk ver. 0.19). Was it ever released out to the public?
> It is a vintage function according to the ChangeLog (2001-02-04).

They look to me too long established to be changed.

> Each guile-gtk function signature needs to be mentioned.

The aim, I think, is still that this should not be necessary.  Careful
attention to uniformity should keep exceptions to a minimum.

Even if it does turn out to be worth having each described, it's still
got to be highly desirable to have maximum consistency with the
corresponding C functions.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* gdk-string-to-compound (was: texinfo documentation)
  2003-05-30  1:06                         ` Marko Rauhamaa
@ 2003-06-13 22:05                           ` Kevin Ryde
  2003-07-07 22:30                             ` gdk-string-to-compound Kevin Ryde
  0 siblings, 1 reply; 21+ messages in thread
From: Kevin Ryde @ 2003-06-13 22:05 UTC (permalink / raw)
  To: guile-gtk

Marko Rauhamaa <marko@pacujo.net> writes:
>
> Note that the C function returns 0 for success and any other value for
> failure.

I see the return is actually a count of failed characters in the
conversion, or an X error code (negative).  Not documented by gtk, but
may as well be passed on upwards.  On that basis I think
gdk-string-to-compound should be an ordinary multiple-values function,
returning 4 results.

^ permalink raw reply	[flat|nested] 21+ messages in thread

* gdk-window-get-geometry (was: texinfo documentation)
  2003-05-29 23:43                       ` texinfo documentation Kevin Ryde
  2003-06-01  4:31                         ` Marko Rauhamaa
@ 2003-07-07 22:29                         ` Kevin Ryde
  1 sibling, 0 replies; 21+ messages in thread
From: Kevin Ryde @ 2003-07-07 22:29 UTC (permalink / raw)
  To: guile-gtk

[-- Attachment #1: Type: text/plain, Size: 234 bytes --]

As previously mentioned, I propose to have

        * gdk-1.2.defs (gdk_window_get_geometry): Return multiple values per C
        function, not a rectangle.
        * gdk-support.c (gdk_window_get_geometry): Remove, no longer used.


[-- Attachment #2: gdk-1.2.defs.get-geom.diff --]
[-- Type: text/plain, Size: 511 bytes --]

--- gdk-1.2.defs.~1.37.~	2003-07-03 11:01:30.000000000 +1000
+++ gdk-1.2.defs	2003-07-03 11:44:40.000000000 +1000
@@ -1151,9 +1151,13 @@
   ((GdkWindow window)
    (GdkColormap colormap)))
 
-(define-func gdk_window_get_geometry_interp
-  (SCM (values (depth)))		; returns rect
+(define-func gdk_window_get_geometry
+  (none (values (x y width height depth)))
   ((GdkWindow window)
+   (int x)
+   (int y)
+   (int width)
+   (int height)
    (int depth)))
 
 (define-func gdk_window_set_geometry_hints_interp

[-- Attachment #3: gdk-support.c.get-geom.diff --]
[-- Type: text/plain, Size: 565 bytes --]

--- gdk-support.c.~1.24.~	2003-06-19 11:03:47.000000000 +1000
+++ gdk-support.c	2003-07-07 17:00:00.000000000 +1000
@@ -865,15 +865,6 @@
   return (guint32) ((GdkWindowPrivate*)window)->xwindow;
 }
 
-SCM
-gdk_window_get_geometry_interp (GdkWindow *window,gint *depth)
-{
-  gint x, y, w, h;
-  gdk_window_get_geometry (window, &x, &y, &w, &h, depth);
-  return scm_cons (scm_cons (SCM_MAKINUM (x), SCM_MAKINUM (y)),
-		   scm_cons (SCM_MAKINUM (w), SCM_MAKINUM (h)));
-}
-
 void
 gdk_window_set_geometry_hints_interp (GdkWindow *window,
 				      gint min_width,

^ permalink raw reply	[flat|nested] 21+ messages in thread

* Re: gdk-string-to-compound
  2003-06-13 22:05                           ` gdk-string-to-compound (was: texinfo documentation) Kevin Ryde
@ 2003-07-07 22:30                             ` Kevin Ryde
  0 siblings, 0 replies; 21+ messages in thread
From: Kevin Ryde @ 2003-07-07 22:30 UTC (permalink / raw)
  To: guile-gtk

[-- Attachment #1: Type: text/plain, Size: 208 bytes --]

As threatened,

        * gdk-1.2.defs, gdk-support.c, guile-gtk.h
        (gdk_string_to_compound_text_interp): Return the status code, put text
        return in same position in values as the C function.


[-- Attachment #2: gdk-1.2.defs.compound.diff --]
[-- Type: text/plain, Size: 749 bytes --]

--- gdk-1.2.defs.~1.37.~	2003-07-03 11:01:30.000000000 +1000
+++ gdk-1.2.defs	2003-07-07 17:15:54.000000000 +1000
@@ -1928,12 +1928,17 @@
    (int format)
    (SCM text)))				; string
 
+;; The return value is only documented as zero for success or non-zero for
+;; failure, but a negative is an Xlib error code or positive is a count of
+;; failed characters.  Not sure if applications will find a use for this,
+;; but we may as well return it.
+;;
 (define-func gdk_string_to_compound_text_interp
-  (SCM					; string or #f
-   (values (encoding format)))
+  (int (values (encoding format ctext)))
   ((string str)
    (atom encoding)
-   (int format)))
+   (int format)
+   (SCM ctext)))  ;; string or #f
 
 (define-func gdk_atom_intern
   atom

[-- Attachment #3: gdk-support.c.compound.diff --]
[-- Type: text/plain, Size: 928 bytes --]

--- gdk-support.c.~1.24.~	2003-06-19 11:03:47.000000000 +1000
+++ gdk-support.c	2003-07-07 17:17:28.000000000 +1000
@@ -1501,17 +1501,21 @@
 }
 #undef FUNCNAME
 
-SCM
-gdk_string_to_compound_text_interp (char *str, GdkAtom *encoding, gint *format)
+gint
+gdk_string_to_compound_text_interp (char *str, GdkAtom *encoding, gint *format,
+                                    SCM *textp)
 {
   guchar *ctext;
-  gint length;
-  SCM text;
-  if (gdk_string_to_compound_text (str, encoding, format, &ctext, &length))
-    return SCM_BOOL_F;
-  text = scm_mem2string ((char *) ctext, length);
-  gdk_free_compound_text (ctext);
-  return text;
+  gint ret, length;
+  ret = gdk_string_to_compound_text (str, encoding, format, &ctext, &length);
+  if (ctext != NULL)
+    {
+      *textp = scm_mem2string ((char *) ctext, length);
+      gdk_free_compound_text (ctext);
+    }
+  else
+    *textp = SCM_BOOL_F;
+  return ret;
 }
 
 SCM

[-- Attachment #4: guile-gtk.h.compound.diff --]
[-- Type: text/plain, Size: 635 bytes --]

--- guile-gtk.h.~1.28.~	2003-07-03 11:08:31.000000000 +1000
+++ guile-gtk.h	2003-07-07 17:10:52.000000000 +1000
@@ -468,8 +468,8 @@
 
 SCM gdk_text_property_to_text_list_interp (GdkAtom encoding, gint format,
 					   SCM text);
-SCM gdk_string_to_compound_text_interp (char *str, GdkAtom *encoding,
-					gint *format);
+gint gdk_string_to_compound_text_interp (char *str, GdkAtom *encoding,
+                                         gint *format, SCM *textp);
 SCM gdk_property_get_interp (GdkWindow *window, GdkAtom property, GdkAtom type,
 			     gulong offset, gulong length, int pdelete,
 			     GdkAtom *actual_property_type,

^ permalink raw reply	[flat|nested] 21+ messages in thread

end of thread, other threads:[~2003-07-07 22:30 UTC | newest]

Thread overview: 21+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2003-05-12  1:21 texinfo documentation Kevin Ryde
2003-05-12  1:52 ` Marko Rauhamaa
2003-05-23 22:01   ` Kevin Ryde
2003-05-23 23:36     ` Marko Rauhamaa
2003-05-23 23:57       ` Kevin Ryde
2003-05-24  0:05         ` Marko Rauhamaa
2003-05-24  2:19           ` Kevin Ryde
     [not found]             ` <m3llwwdhjf.fsf@lumo.pacujo.net>
2003-05-25 22:48               ` Kevin Ryde
2003-05-25 23:28                 ` Marko Rauhamaa
2003-05-26  0:06                   ` Kevin Ryde
2003-05-26  2:42                     ` Marko Rauhamaa
2003-05-29 23:37                       ` Kevin Ryde
2003-05-30  1:06                         ` Marko Rauhamaa
2003-06-13 22:05                           ` gdk-string-to-compound (was: texinfo documentation) Kevin Ryde
2003-07-07 22:30                             ` gdk-string-to-compound Kevin Ryde
2003-05-29 23:43                       ` texinfo documentation Kevin Ryde
2003-06-01  4:31                         ` Marko Rauhamaa
2003-06-02 23:51                           ` gdk-window-get-origin (was: texinfo documentation) Kevin Ryde
2003-07-07 22:29                         ` gdk-window-get-geometry " Kevin Ryde
2003-05-26  0:07                   ` gdk-rectangle-new " Kevin Ryde
2003-05-26  1:20                     ` Marko Rauhamaa

This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).