Add support for overriding virtual-method for classes

This was only possible for interfaces, but in fact for a GApplication
we might need to override the local_command_line virtual_method, as
per the documentation.
Group all with statements for which we need a pragma Warnings(Off) so
that a single instance of the pragma is needed.

Minor style fixes

N625-006

Change-Id: I36aa3285fbabc964e198f1b1e2f0cf21a2210037

Author: briot

contrib/adaformat.py

@@ -85,10 +85,12 @@ def __init__(self, ada, property):
         self.is_ptr = False
         self.param = ada     # type as parameter
         self.cparam = ada    # type for Ada subprograms binding to C
-        self.cleanup = None  # If set, a tmp variable is created to hold the
-                             # result of convert during the call, and is then
-                             # free by calling this cleanup. Use "%s" as the
-                             # name of the variable.
+
+        self.cleanup = None
+        # If set, a tmp variable is created to hold the result of convert during
+        # the call, and is then free by calling this cleanup. Use "%s" as the
+        # name of the variable.
+
         self.isArray = False
 
         # In some cases, Ada provides a special value for a parameter that
@@ -132,8 +134,8 @@ def convert_to_c(self, pkg=None):
            It can also use %(var)s which will be substituted by the name of the
            parameter.
            Otherwise, it is used as " Tmp := <convert>".
-           It might be necessary to also override add_with() to add the necessary
-           with statements.
+           It might be necessary to also override add_with() to add the
+           necessary with statements.
         """
 
         if self.allow_none and self.val_or_null:
@@ -193,8 +195,8 @@ def as_c_param(self, pkg=None):
             return self.cparam
 
     def as_call(
-        self, name, pkg, wrapper="%s", lang="ada", mode="in", value=None,
-        is_temporary_variable=True):
+       self, name, pkg, wrapper="%s", lang="ada", mode="in", value=None,
+       is_temporary_variable=True):
         """'name' represents a parameter of type 'self'.
            'pkg' is the Package instance in which the call occurs.
            'wrapper' is used in the call itself, and %s is replaced by the
@@ -227,18 +229,20 @@ def as_call(
             # Unless we are already using a temporary variable.
 
             if (ret
-                and ret != "%(var)s"
-                and mode != "in"
-                and not is_temporary_variable):
+               and ret != "%(var)s"
+               and mode != "in"
+               and not is_temporary_variable):
 
                 tmp = "Tmp_%s" % name
 
                 if mode in ("out", "access"):
-                    tmpvars = [Local_Var(name=tmp, type=returns[4], aliased=True)]
+                    tmpvars = [Local_Var(
+                        name=tmp, type=returns[4], aliased=True)]
                 else:
                     tmpvars = [
                         Local_Var(name=tmp, type=returns[4], aliased=True,
-                                  default=self.convert_to_c(pkg=pkg) % {"var":name})]
+                            default=self.convert_to_c(pkg=pkg) % {
+                                "var": name})]
 
                 if "%(tmp)s" in ret:
                     tmp2 = "Tmp2_%s" % name
@@ -264,17 +268,17 @@ def as_call(
                 call = VariableCall(
                     call=wrapper % tmp,
                     precall=self.convert_to_c(pkg=pkg) % {
-                        "var":name, "tmp":tmp},
+                        "var": name, "tmp": tmp},
                     postcall=self.cleanup % tmp,
-                    tmpvars=[Local_Var(name=tmp, type=self.cparam)]
-                       + []) # additional_tmp_vars
+                    tmpvars=[Local_Var(name=tmp, type=self.cparam)] + [])
 
             elif self.cleanup:
                 tmp = "Tmp_%s" % name
-                conv = self.convert_to_c(pkg=pkg) % {"var":name}
+                conv = self.convert_to_c(pkg=pkg) % {"var": name}
 
-                # Initialize the temporary variable with a default value, in case
-                # it is an unconstrained type (a chars_ptr_array for instance)
+                # Initialize the temporary variable with a default value, in
+                # case it is an unconstrained type (a chars_ptr_array for
+                # instance)
                 call = VariableCall(
                     call=wrapper % tmp,
                     precall='',
@@ -283,7 +287,7 @@ def as_call(
                         name=tmp, type=AdaType(self.cparam), default=conv)])
 
             else:
-                conv = self.convert_to_c(pkg=pkg) % {"var":name}
+                conv = self.convert_to_c(pkg=pkg) % {"var": name}
                 call = VariableCall(
                     call=wrapper % conv, precall='', postcall="", tmpvars=[])
 
@@ -411,7 +415,7 @@ def __init__(self, ada, userecord=True, allow_none=False, classwide=False):
         self.is_ptr = False
         self.classwide = classwide  # Parameter should include "'Class"
         self.userecord = userecord  # Parameter should be "access .._Record"
-        self.allow_none=allow_none
+        self.allow_none = allow_none
 
     def convert_from_c(self):
         stub = "Stub_%s" % (base_name(self.ada), )
@@ -451,6 +455,7 @@ def copy(self):
         result = CType.copy(self)
         return result
 
+
 class Tagged(GObject):
     """Tagged types that map C objects, but do not derive from GObject"""
 
@@ -467,6 +472,7 @@ def as_ada_param(self, pkg):
         # Make sure to bind as a CType here, not as a GOBject
         return CType.as_ada_param(self, pkg)
 
+
 class UTF8(CType):
     def __init__(self):
         CType.__init__(self, "UTF8_String", "Glib.Properties.Property_String")
@@ -539,7 +545,7 @@ def add_with(self, pkg=None, specs=False):
         if pkg:
             pkg.add_with("GNAT.Strings", specs=True)
             pkg.add_with("Interfaces.C.Strings", specs=specs)
-            pkg.add_with("Gtkada.Bindings", specs=specs)
+            pkg.add_with("Gtkada.Bindings", specs=specs, might_be_unused=True)
 
 
 class Record(CType):
@@ -2048,20 +2054,26 @@ def _output_withs(self, withs):
         if withs:
             result = []
             m = max_length(withs)
-            for w in sorted(withs.keys()):
+            had_warnings_off = False
+
+            # sort so that all packages for which 'might_be_unused' is True
+            # are last in the list
+
+            for w in sorted(withs.keys(), key=lambda w: 'zz%s' % w if withs[w][1] else w):
                 do_use, might_be_unused = withs[w]
 
-                if might_be_unused:
+                if might_be_unused and not had_warnings_off:
                     result.append("pragma Warnings(Off);  --  might be unused")
+                    had_warnings_off = True
 
                 if do_use:
                     result.append(
                         "with %-*s use %s;" % (m + 1, w + ";", w))
                 else:
                     result.append("with %s;" % w)
 
-                if might_be_unused:
-                    result.append("pragma Warnings(On);")
+            if had_warnings_off:
+                result.append("pragma Warnings(On);")
 
             return "\n".join(result) + "\n"
         return ""

contrib/binding.py

@@ -1439,7 +1439,8 @@ def _virtual_methods(self):
             info = ''
 
             for c in all:
-                if not self.gtkpkg.bind_virtual_method(c.get('name')):
+                if not self.gtkpkg.bind_virtual_method(
+                   c.get('name'), default=self.is_interface):
                     continue
 
                 gtkmethod=self.gtkpkg.get_method(cname=c.get(cidentifier))
@@ -1451,7 +1452,12 @@ def _virtual_methods(self):
                     section = self.pkg.section("Virtual Methods")
 
                 info += 'procedure Set_%s\n' % basename
-                info += '   (Self    : %s_Interface_Descr;\n' % ifacename
+
+                if self.is_interface:
+                    info += '   (Self    : %s_Interface_Descr;\n' % ifacename
+                else:
+                    info += '   (Self    : Glib.Object.GObject_Class;\n'
+
                 info += '    Handler : %s);\n' % adaname
                 info += 'pragma Import (C, Set_%s, "gtkada_%s_set_%s");\n' % (
                     basename, ifacename, basename.lower())
@@ -2698,8 +2704,7 @@ def generate(self, gir):
         self._globals()
         self._fields()
 
-        if self.is_interface:
-            self._virtual_methods()
+        self._virtual_methods()
 
         if not into and self.name != "Gtk.Widget":
             self._implements()

contrib/binding.xml

@@ -7468,6 +7468,8 @@ package body Generic_Set is
    </package>
 
    <package id="GApplication" ada="Glib.Application">
+     <virtual-method id='command_line' bind='True'/>
+     <virtual-method id='local_command_line' bind='True'/>
      <enum ctype="GApplicationFlags"/>
      <method id="g_application_get_dbus_connection" bind="False"/> <!-- requires DBus -->
      <method id="g_application_open" bind="False" /> <!-- requires GFile -->

contrib/binding_gtkada.py

@@ -43,6 +43,10 @@
            direction="..." <!-- Override direction (see <parameter> node below) -->
        />
 
+       <!-- By default, virtual methods are bound for interfaces, but not for
+            other classes. You should use the following to control which
+            methods should be bound.
+       -->
        <virtual-method     <!--  list of virtual methods to bind -->
            id='...'        <!--  the name of the virtual method, or '*'  -->
            bind=True       <!--  by default, all methods bound for interfaces -->
@@ -437,20 +441,21 @@ def get_global_functions(self):
                     if c.get("bind", "true").lower() != "false"]
         return []
 
-    def bind_virtual_method(self, name):
+    def bind_virtual_method(self, name, default):
         """
         Whether to bind the given virtual method
         """
-        if not hasattr(self, 'disabled_virtual_methods'):
-            if self.node is None:
-                self.disabled_virtual_methods = set()
-            else:
-                self.disabled_virtual_methods = set(
-                    c.get('id')
-                    for c in self.node.findall("virtual-method")
-                    if c.get("bind", "true").lower() == "false")
-        return (name not in self.disabled_virtual_methods
-                and '*' not in self.disabled_virtual_methods)
+        if not hasattr(self, 'virtual_methods'):
+            self.virtual_methods = {'*': default}
+            if self.node is not None:
+                for c in self.node.findall("virtual-method"):
+                    self.virtual_methods[c.get('id')] = (
+                        c.get("bind", "true").lower() == "true")
+
+        v = self.virtual_methods.get(name, None)
+        if v is None:
+            v = self.virtual_methods['*']
+        return v
 
 
 class GtkAdaMethod(object):

src/generated/glib-action_group.ads

@@ -76,8 +76,8 @@ with Glib;                 use Glib;
 with Glib.Object;          use Glib.Object;
 with Glib.Types;           use Glib.Types;
 with Glib.Variant;         use Glib.Variant;
-with Gtkada.Bindings;      use Gtkada.Bindings;
 pragma Warnings(Off);  --  might be unused
+with Gtkada.Bindings;      use Gtkada.Bindings;
 with Interfaces.C.Strings; use Interfaces.C.Strings;
 pragma Warnings(On);
 

src/generated/glib-application.adb

@@ -28,10 +28,6 @@ with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks;
 with Glib.Values;                use Glib.Values;
 with Gtk.Arguments;              use Gtk.Arguments;
 with GtkAda.Types;               use GtkAda.Types;
-with Gtkada.Bindings;            use Gtkada.Bindings;
-pragma Warnings(Off);  --  might be unused
-with Interfaces.C.Strings;       use Interfaces.C.Strings;
-pragma Warnings(On);
 
 package body Glib.Application is
 

src/generated/glib-application.ads

@@ -167,6 +167,10 @@ with Glib.Object;             use Glib.Object;
 with Glib.Properties;         use Glib.Properties;
 with Glib.Types;              use Glib.Types;
 with Glib.Variant;            use Glib.Variant;
+with Interfaces.C.Strings;    use Interfaces.C.Strings;
+pragma Warnings(Off);  --  might be unused
+with Gtkada.Bindings;         use Gtkada.Bindings;
+pragma Warnings(On);
 
 package Glib.Application is
 
@@ -862,6 +866,42 @@ package Glib.Application is
    return Gapplication
    renames Implements_Gaction_Map.To_Object;
 
+   ---------------------
+   -- Virtual Methods --
+   ---------------------
+
+   type Virtual_Command_Line is access function
+     (Self         : System.Address;
+      Command_Line : System.Address) return Gint;
+   pragma Convention (C, Virtual_Command_Line);
+
+   type Virtual_Local_Command_Line is access function
+     (Self        : System.Address;
+      Arguments   : access Interfaces.C.Strings.chars_ptr_array;
+      Exit_Status : access Gint) return Glib.Gboolean;
+   pragma Convention (C, Virtual_Local_Command_Line);
+   --  This virtual function is always invoked in the local instance. It gets
+   --  passed a pointer to a null-terminated copy of Argv and is expected to
+   --  remove arguments that it handled (shifting up remaining arguments).
+   --  The last argument to local_command_line is a pointer to the Status
+   --  variable which can used to set the exit status that is returned from
+   --  Glib.Application.Run.
+   --  See Glib.Application.Run for more details on
+   --  Glib.Application.Gapplication startup.
+   --  "arguments": array of command line arguments
+   --  "exit_status": exit status to fill after processing the command line.
+
+   subtype Application_Interface_Descr is Glib.Object.Interface_Description;
+   procedure Set_Command_Line
+     (Self    : Glib.Object.GObject_Class;
+      Handler : Virtual_Command_Line);
+   pragma Import (C, Set_Command_Line, "gtkada_Application_set_command_line");
+   procedure Set_Local_Command_Line
+     (Self    : Glib.Object.GObject_Class;
+      Handler : Virtual_Local_Command_Line);
+   pragma Import (C, Set_Local_Command_Line, "gtkada_Application_set_local_command_line");
+   --  See Glib.Object.Add_Interface
+
 private
    Platform_Data_Property : constant Glib.Properties.Property_Object :=
      Glib.Properties.Build ("platform-data");

src/generated/glib-simple_action_group.adb

@@ -24,8 +24,8 @@
 pragma Style_Checks (Off);
 pragma Warnings (Off, "*is already use-visible*");
 with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks;
-with Gtkada.Bindings;            use Gtkada.Bindings;
 pragma Warnings(Off);  --  might be unused
+with Gtkada.Bindings;            use Gtkada.Bindings;
 with Interfaces.C.Strings;       use Interfaces.C.Strings;
 pragma Warnings(On);
 

src/generated/gtk-application_window.adb

@@ -24,8 +24,8 @@
 pragma Style_Checks (Off);
 pragma Warnings (Off, "*is already use-visible*");
 with Glib.Type_Conversion_Hooks; use Glib.Type_Conversion_Hooks;
-with Gtkada.Bindings;            use Gtkada.Bindings;
 pragma Warnings(Off);  --  might be unused
+with Gtkada.Bindings;            use Gtkada.Bindings;
 with Interfaces.C.Strings;       use Interfaces.C.Strings;
 pragma Warnings(On);
 

src/generated/gtk-font_chooser.ads

@@ -37,12 +37,12 @@ with Glib;                 use Glib;
 with Glib.Object;          use Glib.Object;
 with Glib.Properties;      use Glib.Properties;
 with Glib.Types;           use Glib.Types;
-pragma Warnings(Off);  --  might be unused
-with Interfaces.C.Strings; use Interfaces.C.Strings;
-pragma Warnings(On);
 with Pango.Font;           use Pango.Font;
 with Pango.Font_Face;      use Pango.Font_Face;
 with Pango.Font_Family;    use Pango.Font_Family;
+pragma Warnings(Off);  --  might be unused
+with Interfaces.C.Strings; use Interfaces.C.Strings;
+pragma Warnings(On);
 
 package Gtk.Font_Chooser is
 

src/generated/gtk-selection_data.adb

@@ -24,9 +24,11 @@
 pragma Style_Checks (Off);
 pragma Warnings (Off, "*is already use-visible*");
 with GtkAda.Types;         use GtkAda.Types;
-with Gtkada.Bindings;      use Gtkada.Bindings;
 with Gtkada.C;             use Gtkada.C;
 with Interfaces.C.Strings; use Interfaces.C.Strings;
+pragma Warnings(Off);  --  might be unused
+with Gtkada.Bindings;      use Gtkada.Bindings;
+pragma Warnings(On);
 
 package body Gtk.Selection_Data is
 

src/misc_generated.c

@@ -313,4 +313,10 @@ void gtkada_Action_Map_set_lookup_action(GActionMapInterface* iface, void* handl
 }
 void gtkada_Action_Map_set_remove_action(GActionMapInterface* iface, void* handler) {
     iface->remove_action = handler;
+}
+void gtkada_Application_set_command_line(GApplicationClass* iface, void* handler) {
+    iface->command_line = handler;
+}
+void gtkada_Application_set_local_command_line(GApplicationClass* iface, void* handler) {
+    iface->local_command_line = handler;
 }