gtk2 2.24.30 and gtk3 3.20.2
next time: write a script that copies all required files from /usr/local to the git repo...
Tom Schoonjans
27
gtk-nsis-pack/share/glib-2.0/codegen/__init__.py
Normal file
@@ -0,0 +1,27 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
import os
|
||||
|
||||
builddir = os.environ.get('UNINSTALLED_GLIB_BUILDDIR')
|
||||
|
||||
if builddir is not None:
|
||||
__path__.append(os.path.abspath(os.path.join(builddir, 'gio', 'gdbus-2.0', 'codegen')))
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/__init__.pyc
Normal file
3434
gtk-nsis-pack/share/glib-2.0/codegen/codegen.py
Normal file
BIN
gtk-nsis-pack/share/glib-2.0/codegen/codegen.pyc
Normal file
329
gtk-nsis-pack/share/glib-2.0/codegen/codegen_docbook.py
Normal file
@@ -0,0 +1,329 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
import sys
|
||||
import re
|
||||
|
||||
from . import config
|
||||
from . import utils
|
||||
from . import dbustypes
|
||||
from . import parser
|
||||
|
||||
# ----------------------------------------------------------------------------------------------------
|
||||
|
||||
class DocbookCodeGenerator:
|
||||
def __init__(self, ifaces, docbook):
|
||||
self.ifaces = ifaces
|
||||
self.docbook = docbook
|
||||
self.generate_expand_dicts()
|
||||
|
||||
def print_method_prototype(self, i, m, in_synopsis):
|
||||
max_method_len = 0
|
||||
if in_synopsis:
|
||||
for _m in i.methods:
|
||||
max_method_len = max(len(_m.name), max_method_len)
|
||||
else:
|
||||
max_method_len = max(len(m.name), max_method_len)
|
||||
|
||||
max_signature_len = 0
|
||||
if in_synopsis:
|
||||
for _m in i.methods:
|
||||
for a in _m.in_args:
|
||||
max_signature_len = max(len(a.signature), max_signature_len)
|
||||
for a in _m.out_args:
|
||||
max_signature_len = max(len(a.signature), max_signature_len)
|
||||
else:
|
||||
for a in m.in_args:
|
||||
max_signature_len = max(len(a.signature), max_signature_len)
|
||||
for a in m.out_args:
|
||||
max_signature_len = max(len(a.signature), max_signature_len)
|
||||
|
||||
if in_synopsis:
|
||||
self.out.write('<link linkend="gdbus-method-%s.%s">%s</link>%*s ('
|
||||
%(utils.dots_to_hyphens(i.name), m.name, m.name, max_method_len - len(m.name), ''))
|
||||
else:
|
||||
self.out.write('%s%*s ('
|
||||
%(m.name, max_method_len - len(m.name), ''))
|
||||
count = 0
|
||||
for a in m.in_args:
|
||||
if (count > 0):
|
||||
self.out.write(',\n%*s'%(max_method_len + 2, ''))
|
||||
self.out.write('IN %s%*s %s'%(a.signature, max_signature_len - len(a.signature), '', a.name))
|
||||
count = count + 1
|
||||
for a in m.out_args:
|
||||
if (count > 0):
|
||||
self.out.write(',\n%*s'%(max_method_len + 2, ''))
|
||||
self.out.write('OUT %s%*s %s'%(a.signature, max_signature_len - len(a.signature), '', a.name))
|
||||
count = count + 1
|
||||
self.out.write(');\n')
|
||||
|
||||
def print_signal_prototype(self, i, s, in_synopsis):
|
||||
max_signal_len = 0
|
||||
if in_synopsis:
|
||||
for _s in i.signals:
|
||||
max_signal_len = max(len(_s.name), max_signal_len)
|
||||
else:
|
||||
max_signal_len = max(len(s.name), max_signal_len)
|
||||
|
||||
max_signature_len = 0
|
||||
if in_synopsis:
|
||||
for _s in i.signals:
|
||||
for a in _s.args:
|
||||
max_signature_len = max(len(a.signature), max_signature_len)
|
||||
else:
|
||||
for a in s.args:
|
||||
max_signature_len = max(len(a.signature), max_signature_len)
|
||||
|
||||
if in_synopsis:
|
||||
self.out.write('<link linkend="gdbus-signal-%s.%s">%s</link>%*s ('
|
||||
%(utils.dots_to_hyphens(i.name), s.name, s.name, max_signal_len - len(s.name), ''))
|
||||
else:
|
||||
self.out.write('%s%*s ('
|
||||
%(s.name, max_signal_len - len(s.name), ''))
|
||||
count = 0
|
||||
for a in s.args:
|
||||
if (count > 0):
|
||||
self.out.write(',\n%*s'%(max_signal_len + 2, ''))
|
||||
self.out.write('%s%*s %s'%(a.signature, max_signature_len - len(a.signature), '', a.name))
|
||||
count = count + 1
|
||||
self.out.write(');\n')
|
||||
|
||||
def print_property_prototype(self, i, p, in_synopsis):
|
||||
max_property_len = 0
|
||||
if in_synopsis:
|
||||
for _p in i.properties:
|
||||
max_property_len = max(len(_p.name), max_property_len)
|
||||
else:
|
||||
max_property_len = max(len(p.name), max_property_len)
|
||||
|
||||
max_signature_len = 0
|
||||
if in_synopsis:
|
||||
for _p in i.properties:
|
||||
max_signature_len = max(len(_p.signature), max_signature_len)
|
||||
else:
|
||||
max_signature_len = max(len(p.signature), max_signature_len)
|
||||
|
||||
if in_synopsis:
|
||||
self.out.write('<link linkend="gdbus-property-%s.%s">%s</link>%*s'
|
||||
%(utils.dots_to_hyphens(i.name), p.name, p.name, max_property_len - len(p.name), ''))
|
||||
else:
|
||||
self.out.write('%s%*s'
|
||||
%(p.name, max_property_len - len(p.name), ''))
|
||||
if p.readable and p.writable:
|
||||
access = 'readwrite'
|
||||
elif p.readable:
|
||||
access = 'readable '
|
||||
else:
|
||||
access = 'writable '
|
||||
self.out.write(' %s %s\n'%(access, p.signature))
|
||||
|
||||
|
||||
def print_synopsis_methods(self, i):
|
||||
self.out.write(' <refsynopsisdiv role="synopsis">\n'%())
|
||||
self.out.write(' <title role="synopsis.title">Methods</title>\n'%())
|
||||
self.out.write(' <synopsis>\n'%())
|
||||
for m in i.methods:
|
||||
self.print_method_prototype(i, m, in_synopsis=True)
|
||||
self.out.write('</synopsis>\n'%())
|
||||
self.out.write(' </refsynopsisdiv>\n'%())
|
||||
|
||||
def print_synopsis_signals(self, i):
|
||||
self.out.write(' <refsect1 role="signal_proto">\n'%())
|
||||
self.out.write(' <title role="signal_proto.title">Signals</title>\n'%())
|
||||
self.out.write(' <synopsis>\n'%())
|
||||
for s in i.signals:
|
||||
self.print_signal_prototype(i, s, in_synopsis=True)
|
||||
self.out.write('</synopsis>\n'%())
|
||||
self.out.write(' </refsect1>\n'%())
|
||||
|
||||
def print_synopsis_properties(self, i):
|
||||
self.out.write(' <refsect1 role="properties">\n'%())
|
||||
self.out.write(' <title role="properties.title">Properties</title>\n'%())
|
||||
self.out.write(' <synopsis>\n'%())
|
||||
for p in i.properties:
|
||||
self.print_property_prototype(i, p, in_synopsis=True)
|
||||
self.out.write('</synopsis>\n'%())
|
||||
self.out.write(' </refsect1>\n'%())
|
||||
|
||||
def print_method(self, i, m):
|
||||
self.out.write('<refsect2 role="method" id="gdbus-method-%s.%s">\n'%(utils.dots_to_hyphens(i.name), m.name))
|
||||
self.out.write(' <title>The %s() method</title>\n'%(m.name))
|
||||
self.out.write(' <indexterm zone="gdbus-method-%s.%s"><primary sortas="%s.%s">%s.%s()</primary></indexterm>\n'%(utils.dots_to_hyphens(i.name), m.name, i.name_without_prefix, m.name, i.name, m.name))
|
||||
self.out.write('<programlisting>\n')
|
||||
self.print_method_prototype(i, m, in_synopsis=False)
|
||||
self.out.write('</programlisting>\n')
|
||||
self.out.write('%s\n'%(self.expand_paras(m.doc_string, True)))
|
||||
if m.in_args or m.out_args:
|
||||
self.out.write('<variablelist role="params">\n')
|
||||
for a in m.in_args:
|
||||
self.out.write('<varlistentry>\n'%())
|
||||
self.out.write(' <term><literal>IN %s <parameter>%s</parameter></literal>:</term>\n'%(a.signature, a.name))
|
||||
self.out.write(' <listitem>%s</listitem>\n'%(self.expand_paras(a.doc_string, True)))
|
||||
self.out.write('</varlistentry>\n'%())
|
||||
for a in m.out_args:
|
||||
self.out.write('<varlistentry>\n'%())
|
||||
self.out.write(' <term><literal>OUT %s <parameter>%s</parameter></literal>:</term>\n'%(a.signature, a.name))
|
||||
self.out.write(' <listitem>%s</listitem>\n'%(self.expand_paras(a.doc_string, True)))
|
||||
self.out.write('</varlistentry>\n'%())
|
||||
self.out.write('</variablelist>\n')
|
||||
if len(m.since) > 0:
|
||||
self.out.write('<para role="since">Since %s</para>\n'%(m.since))
|
||||
if m.deprecated:
|
||||
self.out.write('<warning><para>The %s() method is deprecated.</para></warning>'%(m.name))
|
||||
self.out.write('</refsect2>\n')
|
||||
|
||||
def print_signal(self, i, s):
|
||||
self.out.write('<refsect2 role="signal" id="gdbus-signal-%s.%s">\n'%(utils.dots_to_hyphens(i.name), s.name))
|
||||
self.out.write(' <title>The "%s" signal</title>\n'%(s.name))
|
||||
self.out.write(' <indexterm zone="gdbus-signal-%s.%s"><primary sortas="%s::%s">%s::%s</primary></indexterm>\n'%(utils.dots_to_hyphens(i.name), s.name, i.name_without_prefix, s.name, i.name, s.name))
|
||||
self.out.write('<programlisting>\n')
|
||||
self.print_signal_prototype(i, s, in_synopsis=False)
|
||||
self.out.write('</programlisting>\n')
|
||||
self.out.write('%s\n'%(self.expand_paras(s.doc_string, True)))
|
||||
if s.args:
|
||||
self.out.write('<variablelist role="params">\n')
|
||||
for a in s.args:
|
||||
self.out.write('<varlistentry>\n'%())
|
||||
self.out.write(' <term><literal>%s <parameter>%s</parameter></literal>:</term>\n'%(a.signature, a.name))
|
||||
self.out.write(' <listitem>%s</listitem>\n'%(self.expand_paras(a.doc_string, True)))
|
||||
self.out.write('</varlistentry>\n'%())
|
||||
self.out.write('</variablelist>\n')
|
||||
if len(s.since) > 0:
|
||||
self.out.write('<para role="since">Since %s</para>\n'%(s.since))
|
||||
if s.deprecated:
|
||||
self.out.write('<warning><para>The "%s" signal is deprecated.</para></warning>'%(s.name))
|
||||
self.out.write('</refsect2>\n')
|
||||
|
||||
def print_property(self, i, p):
|
||||
self.out.write('<refsect2 role="property" id="gdbus-property-%s.%s">\n'%(utils.dots_to_hyphens(i.name), p.name))
|
||||
self.out.write(' <title>The "%s" property</title>\n'%(p.name))
|
||||
self.out.write(' <indexterm zone="gdbus-property-%s.%s"><primary sortas="%s:%s">%s:%s</primary></indexterm>\n'%(utils.dots_to_hyphens(i.name), p.name, i.name_without_prefix, p.name, i.name, p.name))
|
||||
self.out.write('<programlisting>\n')
|
||||
self.print_property_prototype(i, p, in_synopsis=False)
|
||||
self.out.write('</programlisting>\n')
|
||||
self.out.write('%s\n'%(self.expand_paras(p.doc_string, True)))
|
||||
if len(p.since) > 0:
|
||||
self.out.write('<para role="since">Since %s</para>\n'%(p.since))
|
||||
if p.deprecated:
|
||||
self.out.write('<warning><para>The "%s" property is deprecated.</para></warning>'%(p.name))
|
||||
self.out.write('</refsect2>\n')
|
||||
|
||||
def expand(self, s, expandParamsAndConstants):
|
||||
for key in self.expand_member_dict_keys:
|
||||
s = s.replace(key, self.expand_member_dict[key])
|
||||
for key in self.expand_iface_dict_keys:
|
||||
s = s.replace(key, self.expand_iface_dict[key])
|
||||
if expandParamsAndConstants:
|
||||
# replace @foo with <parameter>foo</parameter>
|
||||
s = re.sub('@[a-zA-Z0-9_]*', lambda m: '<parameter>' + m.group(0)[1:] + '</parameter>', s)
|
||||
# replace e.g. %TRUE with <constant>TRUE</constant>
|
||||
s = re.sub('%[a-zA-Z0-9_]*', lambda m: '<constant>' + m.group(0)[1:] + '</constant>', s)
|
||||
return s
|
||||
|
||||
def expand_paras(self, s, expandParamsAndConstants):
|
||||
s = self.expand(s, expandParamsAndConstants).strip()
|
||||
if not s.startswith("<para"):
|
||||
s = "<para>%s</para>" % s
|
||||
return s
|
||||
|
||||
def generate_expand_dicts(self):
|
||||
self.expand_member_dict = {}
|
||||
self.expand_iface_dict = {}
|
||||
for i in self.ifaces:
|
||||
key = '#%s'%(i.name)
|
||||
value = '<link linkend="gdbus-interface-%s.top_of_page">%s</link>'%(utils.dots_to_hyphens(i.name), i.name)
|
||||
self.expand_iface_dict[key] = value
|
||||
for m in i.methods:
|
||||
key = '%s.%s()'%(i.name, m.name)
|
||||
value = '<link linkend="gdbus-method-%s.%s">%s()</link>'%(utils.dots_to_hyphens(i.name), m.name, m.name)
|
||||
self.expand_member_dict[key] = value
|
||||
for s in i.signals:
|
||||
key = '#%s::%s'%(i.name, s.name)
|
||||
value = '<link linkend="gdbus-signal-%s.%s">"%s"</link>'%(utils.dots_to_hyphens(i.name), s.name, s.name)
|
||||
self.expand_member_dict[key] = value
|
||||
for p in i.properties:
|
||||
key = '#%s:%s'%(i.name, p.name)
|
||||
value = '<link linkend="gdbus-property-%s.%s">"%s"</link>'%(utils.dots_to_hyphens(i.name), p.name, p.name)
|
||||
self.expand_member_dict[key] = value
|
||||
# Make sure to expand the keys in reverse order so e.g. #org.foo.Iface:MediaCompat
|
||||
# is evaluated before #org.foo.Iface:Media ...
|
||||
self.expand_member_dict_keys = sorted(self.expand_member_dict.keys(), reverse=True)
|
||||
self.expand_iface_dict_keys = sorted(self.expand_iface_dict.keys(), reverse=True)
|
||||
|
||||
def generate(self):
|
||||
for i in self.ifaces:
|
||||
self.out = open('%s-%s.xml'%(self.docbook, i.name), 'w')
|
||||
self.out.write(''%())
|
||||
self.out.write('<?xml version="1.0" encoding="utf-8"?>\n'%())
|
||||
self.out.write('<!DOCTYPE refentry PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN"\n'%())
|
||||
self.out.write(' "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [\n'%())
|
||||
self.out.write(']>\n'%())
|
||||
self.out.write('<refentry id="gdbus-%s">\n'%(i.name))
|
||||
self.out.write(' <refmeta>'%())
|
||||
self.out.write(' <refentrytitle role="top_of_page" id="gdbus-interface-%s.top_of_page">%s</refentrytitle>\n'%(utils.dots_to_hyphens(i.name), i.name))
|
||||
self.out.write(' <indexterm zone="gdbus-interface-%s.top_of_page"><primary sortas="%s">%s</primary></indexterm>\n'%(utils.dots_to_hyphens(i.name), i.name_without_prefix, i.name))
|
||||
self.out.write(' </refmeta>'%())
|
||||
|
||||
self.out.write(' <refnamediv>'%())
|
||||
self.out.write(' <refname>%s</refname>'%(i.name))
|
||||
self.out.write(' <refpurpose>%s</refpurpose>'%(i.doc_string_brief))
|
||||
self.out.write(' </refnamediv>'%())
|
||||
|
||||
if len(i.methods) > 0:
|
||||
self.print_synopsis_methods(i)
|
||||
if len(i.signals) > 0:
|
||||
self.print_synopsis_signals(i)
|
||||
if len(i.properties) > 0:
|
||||
self.print_synopsis_properties(i)
|
||||
|
||||
self.out.write('<refsect1 role="desc" id="gdbus-interface-%s">\n'%(utils.dots_to_hyphens(i.name)))
|
||||
self.out.write(' <title role="desc.title">Description</title>\n'%())
|
||||
self.out.write(' %s\n'%(self.expand_paras(i.doc_string, True)))
|
||||
if len(i.since) > 0:
|
||||
self.out.write(' <para role="since">Since %s</para>\n'%(i.since))
|
||||
if i.deprecated:
|
||||
self.out.write('<warning><para>The %s interface is deprecated.</para></warning>'%(i.name))
|
||||
self.out.write('</refsect1>\n'%())
|
||||
|
||||
if len(i.methods) > 0:
|
||||
self.out.write('<refsect1 role="details" id="gdbus-methods-%s">\n'%(i.name))
|
||||
self.out.write(' <title role="details.title">Method Details</title>\n'%())
|
||||
for m in i.methods:
|
||||
self.print_method(i, m)
|
||||
self.out.write('</refsect1>\n'%())
|
||||
|
||||
if len(i.signals) > 0:
|
||||
self.out.write('<refsect1 role="details" id="gdbus-signals-%s">\n'%(i.name))
|
||||
self.out.write(' <title role="details.title">Signal Details</title>\n'%())
|
||||
for s in i.signals:
|
||||
self.print_signal(i, s)
|
||||
self.out.write('</refsect1>\n'%())
|
||||
|
||||
if len(i.properties) > 0:
|
||||
self.out.write('<refsect1 role="details" id="gdbus-properties-%s">\n'%(i.name))
|
||||
self.out.write(' <title role="details.title">Property Details</title>\n'%())
|
||||
for s in i.properties:
|
||||
self.print_property(i, s)
|
||||
self.out.write('</refsect1>\n'%())
|
||||
|
||||
self.out.write('</refentry>\n')
|
||||
self.out.write('\n')
|
||||
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/codegen_docbook.pyc
Normal file
201
gtk-nsis-pack/share/glib-2.0/codegen/codegen_main.py
Normal file
@@ -0,0 +1,201 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
import sys
|
||||
import optparse
|
||||
|
||||
from . import config
|
||||
from . import utils
|
||||
from . import dbustypes
|
||||
from . import parser
|
||||
from . import codegen
|
||||
from . import codegen_docbook
|
||||
|
||||
def find_arg(arg_list, arg_name):
|
||||
for a in arg_list:
|
||||
if a.name == arg_name:
|
||||
return a
|
||||
return None
|
||||
|
||||
def find_method(iface, method):
|
||||
for m in iface.methods:
|
||||
if m.name == method:
|
||||
return m
|
||||
return None
|
||||
|
||||
def find_signal(iface, signal):
|
||||
for m in iface.signals:
|
||||
if m.name == signal:
|
||||
return m
|
||||
return None
|
||||
|
||||
def find_prop(iface, prop):
|
||||
for m in iface.properties:
|
||||
if m.name == prop:
|
||||
return m
|
||||
return None
|
||||
|
||||
def apply_annotation(iface_list, iface, method, signal, prop, arg, key, value):
|
||||
iface_obj = None
|
||||
for i in iface_list:
|
||||
if i.name == iface:
|
||||
iface_obj = i
|
||||
break
|
||||
|
||||
if iface_obj == None:
|
||||
raise RuntimeError('No interface %s'%iface)
|
||||
|
||||
target_obj = None
|
||||
|
||||
if method:
|
||||
method_obj = find_method(iface_obj, method)
|
||||
if method_obj == None:
|
||||
raise RuntimeError('No method %s on interface %s'%(method, iface))
|
||||
if arg:
|
||||
arg_obj = find_arg(method_obj.in_args, arg)
|
||||
if (arg_obj == None):
|
||||
arg_obj = find_arg(method_obj.out_args, arg)
|
||||
if (arg_obj == None):
|
||||
raise RuntimeError('No arg %s on method %s on interface %s'%(arg, method, iface))
|
||||
target_obj = arg_obj
|
||||
else:
|
||||
target_obj = method_obj
|
||||
elif signal:
|
||||
signal_obj = find_signal(iface_obj, signal)
|
||||
if signal_obj == None:
|
||||
raise RuntimeError('No signal %s on interface %s'%(signal, iface))
|
||||
if arg:
|
||||
arg_obj = find_arg(signal_obj.args, arg)
|
||||
if (arg_obj == None):
|
||||
raise RuntimeError('No arg %s on signal %s on interface %s'%(arg, signal, iface))
|
||||
target_obj = arg_obj
|
||||
else:
|
||||
target_obj = signal_obj
|
||||
elif prop:
|
||||
prop_obj = find_prop(iface_obj, prop)
|
||||
if prop_obj == None:
|
||||
raise RuntimeError('No property %s on interface %s'%(prop, iface))
|
||||
target_obj = prop_obj
|
||||
else:
|
||||
target_obj = iface_obj
|
||||
target_obj.annotations.insert(0, dbustypes.Annotation(key, value))
|
||||
|
||||
|
||||
def apply_annotations(iface_list, annotation_list):
|
||||
# apply annotations given on the command line
|
||||
for (what, key, value) in annotation_list:
|
||||
pos = what.find('::')
|
||||
if pos != -1:
|
||||
# signal
|
||||
iface = what[0:pos];
|
||||
signal = what[pos + 2:]
|
||||
pos = signal.find('[')
|
||||
if pos != -1:
|
||||
arg = signal[pos + 1:]
|
||||
signal = signal[0:pos]
|
||||
pos = arg.find(']')
|
||||
arg = arg[0:pos]
|
||||
apply_annotation(iface_list, iface, None, signal, None, arg, key, value)
|
||||
else:
|
||||
apply_annotation(iface_list, iface, None, signal, None, None, key, value)
|
||||
else:
|
||||
pos = what.find(':')
|
||||
if pos != -1:
|
||||
# property
|
||||
iface = what[0:pos];
|
||||
prop = what[pos + 1:]
|
||||
apply_annotation(iface_list, iface, None, None, prop, None, key, value)
|
||||
else:
|
||||
pos = what.find('()')
|
||||
if pos != -1:
|
||||
# method
|
||||
combined = what[0:pos]
|
||||
pos = combined.rfind('.')
|
||||
iface = combined[0:pos]
|
||||
method = combined[pos + 1:]
|
||||
pos = what.find('[')
|
||||
if pos != -1:
|
||||
arg = what[pos + 1:]
|
||||
pos = arg.find(']')
|
||||
arg = arg[0:pos]
|
||||
apply_annotation(iface_list, iface, method, None, None, arg, key, value)
|
||||
else:
|
||||
apply_annotation(iface_list, iface, method, None, None, None, key, value)
|
||||
else:
|
||||
# must be an interface
|
||||
iface = what
|
||||
apply_annotation(iface_list, iface, None, None, None, None, key, value)
|
||||
|
||||
def codegen_main():
|
||||
arg_parser = optparse.OptionParser('%prog [options]')
|
||||
arg_parser.add_option('', '--xml-files', metavar='FILE', action='append',
|
||||
help='D-Bus introspection XML file')
|
||||
arg_parser.add_option('', '--interface-prefix', metavar='PREFIX', default='',
|
||||
help='String to strip from D-Bus interface names for code and docs')
|
||||
arg_parser.add_option('', '--c-namespace', metavar='NAMESPACE', default='',
|
||||
help='The namespace to use for generated C code')
|
||||
arg_parser.add_option('', '--c-generate-object-manager', action='store_true',
|
||||
help='Generate a GDBusObjectManagerClient subclass when generating C code')
|
||||
arg_parser.add_option('', '--generate-c-code', metavar='OUTFILES',
|
||||
help='Generate C code in OUTFILES.[ch]')
|
||||
arg_parser.add_option('', '--generate-docbook', metavar='OUTFILES',
|
||||
help='Generate Docbook in OUTFILES-org.Project.IFace.xml')
|
||||
arg_parser.add_option('', '--annotate', nargs=3, action='append', metavar='WHAT KEY VALUE',
|
||||
help='Add annotation (may be used several times)')
|
||||
(opts, args) = arg_parser.parse_args();
|
||||
|
||||
all_ifaces = []
|
||||
for fname in args:
|
||||
f = open(fname, 'rb')
|
||||
xml_data = f.read()
|
||||
f.close()
|
||||
parsed_ifaces = parser.parse_dbus_xml(xml_data)
|
||||
all_ifaces.extend(parsed_ifaces)
|
||||
|
||||
if opts.annotate != None:
|
||||
apply_annotations(all_ifaces, opts.annotate)
|
||||
|
||||
for i in all_ifaces:
|
||||
i.post_process(opts.interface_prefix, opts.c_namespace)
|
||||
|
||||
docbook = opts.generate_docbook
|
||||
docbook_gen = codegen_docbook.DocbookCodeGenerator(all_ifaces, docbook);
|
||||
if docbook:
|
||||
ret = docbook_gen.generate()
|
||||
|
||||
c_code = opts.generate_c_code
|
||||
if c_code:
|
||||
h = open(c_code + '.h', 'w')
|
||||
c = open(c_code + '.c', 'w')
|
||||
gen = codegen.CodeGenerator(all_ifaces,
|
||||
opts.c_namespace,
|
||||
opts.interface_prefix,
|
||||
opts.c_generate_object_manager,
|
||||
docbook_gen,
|
||||
h, c);
|
||||
ret = gen.generate()
|
||||
h.close()
|
||||
c.close()
|
||||
|
||||
sys.exit(0)
|
||||
|
||||
if __name__ == "__main__":
|
||||
codegen_main()
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/codegen_main.pyc
Normal file
25
gtk-nsis-pack/share/glib-2.0/codegen/config.py
Normal file
@@ -0,0 +1,25 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
DATADIR = "${prefix}/share"
|
||||
DATADIR = DATADIR.replace(
|
||||
"${prefix}", "/usr/local")
|
||||
VERSION = "2.48.0"
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/config.pyc
Normal file
424
gtk-nsis-pack/share/glib-2.0/codegen/dbustypes.py
Normal file
@@ -0,0 +1,424 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
from . import utils
|
||||
|
||||
class Annotation:
|
||||
def __init__(self, key, value):
|
||||
self.key = key
|
||||
self.value = value
|
||||
self.annotations = []
|
||||
|
||||
class Arg:
|
||||
def __init__(self, name, signature):
|
||||
self.name = name
|
||||
self.signature = signature
|
||||
self.annotations = []
|
||||
self.doc_string = ''
|
||||
self.since = ''
|
||||
|
||||
def post_process(self, interface_prefix, cns, cns_upper, cns_lower, arg_number):
|
||||
if len(self.doc_string) == 0:
|
||||
self.doc_string = utils.lookup_docs(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = utils.lookup_since(self.annotations)
|
||||
|
||||
if self.name == None:
|
||||
self.name = 'unnamed_arg%d'%arg_number
|
||||
# default to GVariant
|
||||
self.ctype_in_g = 'GVariant *'
|
||||
self.ctype_in = 'GVariant *'
|
||||
self.ctype_in_dup = 'GVariant *'
|
||||
self.ctype_out = 'GVariant **'
|
||||
self.gtype = 'G_TYPE_VARIANT'
|
||||
self.free_func = 'g_variant_unref'
|
||||
self.format_in = '@' + self.signature
|
||||
self.format_out = '@' + self.signature
|
||||
self.gvariant_get = 'XXX'
|
||||
self.gvalue_get = 'g_value_get_variant'
|
||||
if not utils.lookup_annotation(self.annotations, 'org.gtk.GDBus.C.ForceGVariant'):
|
||||
if self.signature == 'b':
|
||||
self.ctype_in_g = 'gboolean '
|
||||
self.ctype_in = 'gboolean '
|
||||
self.ctype_out = 'gboolean *'
|
||||
self.gtype = 'G_TYPE_BOOLEAN'
|
||||
self.free_func = None
|
||||
self.format_in = 'b'
|
||||
self.format_out = 'b'
|
||||
self.gvariant_get = 'g_variant_get_boolean'
|
||||
self.gvalue_get = 'g_value_get_boolean'
|
||||
elif self.signature == 'y':
|
||||
self.ctype_in_g = 'guchar '
|
||||
self.ctype_in = 'guchar '
|
||||
self.ctype_out = 'guchar *'
|
||||
self.gtype = 'G_TYPE_UCHAR'
|
||||
self.free_func = None
|
||||
self.format_in = 'y'
|
||||
self.format_out = 'y'
|
||||
self.gvariant_get = 'g_variant_get_byte'
|
||||
self.gvalue_get = 'g_value_get_uchar'
|
||||
elif self.signature == 'n':
|
||||
self.ctype_in_g = 'gint '
|
||||
self.ctype_in = 'gint16 '
|
||||
self.ctype_out = 'gint16 *'
|
||||
self.gtype = 'G_TYPE_INT'
|
||||
self.free_func = None
|
||||
self.format_in = 'n'
|
||||
self.format_out = 'n'
|
||||
self.gvariant_get = 'g_variant_get_int16'
|
||||
self.gvalue_get = 'g_value_get_int'
|
||||
elif self.signature == 'q':
|
||||
self.ctype_in_g = 'guint '
|
||||
self.ctype_in = 'guint16 '
|
||||
self.ctype_out = 'guint16 *'
|
||||
self.gtype = 'G_TYPE_UINT'
|
||||
self.free_func = None
|
||||
self.format_in = 'q'
|
||||
self.format_out = 'q'
|
||||
self.gvariant_get = 'g_variant_get_uint16'
|
||||
self.gvalue_get = 'g_value_get_uint'
|
||||
elif self.signature == 'i':
|
||||
self.ctype_in_g = 'gint '
|
||||
self.ctype_in = 'gint '
|
||||
self.ctype_out = 'gint *'
|
||||
self.gtype = 'G_TYPE_INT'
|
||||
self.free_func = None
|
||||
self.format_in = 'i'
|
||||
self.format_out = 'i'
|
||||
self.gvariant_get = 'g_variant_get_int32'
|
||||
self.gvalue_get = 'g_value_get_int'
|
||||
elif self.signature == 'u':
|
||||
self.ctype_in_g = 'guint '
|
||||
self.ctype_in = 'guint '
|
||||
self.ctype_out = 'guint *'
|
||||
self.gtype = 'G_TYPE_UINT'
|
||||
self.free_func = None
|
||||
self.format_in = 'u'
|
||||
self.format_out = 'u'
|
||||
self.gvariant_get = 'g_variant_get_uint32'
|
||||
self.gvalue_get = 'g_value_get_uint'
|
||||
elif self.signature == 'x':
|
||||
self.ctype_in_g = 'gint64 '
|
||||
self.ctype_in = 'gint64 '
|
||||
self.ctype_out = 'gint64 *'
|
||||
self.gtype = 'G_TYPE_INT64'
|
||||
self.free_func = None
|
||||
self.format_in = 'x'
|
||||
self.format_out = 'x'
|
||||
self.gvariant_get = 'g_variant_get_int64'
|
||||
self.gvalue_get = 'g_value_get_int64'
|
||||
elif self.signature == 't':
|
||||
self.ctype_in_g = 'guint64 '
|
||||
self.ctype_in = 'guint64 '
|
||||
self.ctype_out = 'guint64 *'
|
||||
self.gtype = 'G_TYPE_UINT64'
|
||||
self.free_func = None
|
||||
self.format_in = 't'
|
||||
self.format_out = 't'
|
||||
self.gvariant_get = 'g_variant_get_uint64'
|
||||
self.gvalue_get = 'g_value_get_uint64'
|
||||
elif self.signature == 'd':
|
||||
self.ctype_in_g = 'gdouble '
|
||||
self.ctype_in = 'gdouble '
|
||||
self.ctype_out = 'gdouble *'
|
||||
self.gtype = 'G_TYPE_DOUBLE'
|
||||
self.free_func = None
|
||||
self.format_in = 'd'
|
||||
self.format_out = 'd'
|
||||
self.gvariant_get = 'g_variant_get_double'
|
||||
self.gvalue_get = 'g_value_get_double'
|
||||
elif self.signature == 's':
|
||||
self.ctype_in_g = 'const gchar *'
|
||||
self.ctype_in = 'const gchar *'
|
||||
self.ctype_in_dup = 'gchar *'
|
||||
self.ctype_out = 'gchar **'
|
||||
self.gtype = 'G_TYPE_STRING'
|
||||
self.free_func = 'g_free'
|
||||
self.format_in = 's'
|
||||
self.format_out = 's'
|
||||
self.gvariant_get = 'g_variant_get_string'
|
||||
self.gvalue_get = 'g_value_get_string'
|
||||
elif self.signature == 'o':
|
||||
self.ctype_in_g = 'const gchar *'
|
||||
self.ctype_in = 'const gchar *'
|
||||
self.ctype_in_dup = 'gchar *'
|
||||
self.ctype_out = 'gchar **'
|
||||
self.gtype = 'G_TYPE_STRING'
|
||||
self.free_func = 'g_free'
|
||||
self.format_in = 'o'
|
||||
self.format_out = 'o'
|
||||
self.gvariant_get = 'g_variant_get_string'
|
||||
self.gvalue_get = 'g_value_get_string'
|
||||
elif self.signature == 'g':
|
||||
self.ctype_in_g = 'const gchar *'
|
||||
self.ctype_in = 'const gchar *'
|
||||
self.ctype_in_dup = 'gchar *'
|
||||
self.ctype_out = 'gchar **'
|
||||
self.gtype = 'G_TYPE_STRING'
|
||||
self.free_func = 'g_free'
|
||||
self.format_in = 'g'
|
||||
self.format_out = 'g'
|
||||
self.gvariant_get = 'g_variant_get_string'
|
||||
self.gvalue_get = 'g_value_get_string'
|
||||
elif self.signature == 'ay':
|
||||
self.ctype_in_g = 'const gchar *'
|
||||
self.ctype_in = 'const gchar *'
|
||||
self.ctype_in_dup = 'gchar *'
|
||||
self.ctype_out = 'gchar **'
|
||||
self.gtype = 'G_TYPE_STRING'
|
||||
self.free_func = 'g_free'
|
||||
self.format_in = '^ay'
|
||||
self.format_out = '^ay'
|
||||
self.gvariant_get = 'g_variant_get_bytestring'
|
||||
self.gvalue_get = 'g_value_get_string'
|
||||
elif self.signature == 'as':
|
||||
self.ctype_in_g = 'const gchar *const *'
|
||||
self.ctype_in = 'const gchar *const *'
|
||||
self.ctype_in_dup = 'gchar **'
|
||||
self.ctype_out = 'gchar ***'
|
||||
self.gtype = 'G_TYPE_STRV'
|
||||
self.free_func = 'g_strfreev'
|
||||
self.format_in = '^as'
|
||||
self.format_out = '^as'
|
||||
self.gvariant_get = 'g_variant_get_strv'
|
||||
self.gvalue_get = 'g_value_get_boxed'
|
||||
elif self.signature == 'ao':
|
||||
self.ctype_in_g = 'const gchar *const *'
|
||||
self.ctype_in = 'const gchar *const *'
|
||||
self.ctype_in_dup = 'gchar **'
|
||||
self.ctype_out = 'gchar ***'
|
||||
self.gtype = 'G_TYPE_STRV'
|
||||
self.free_func = 'g_strfreev'
|
||||
self.format_in = '^ao'
|
||||
self.format_out = '^ao'
|
||||
self.gvariant_get = 'g_variant_get_objv'
|
||||
self.gvalue_get = 'g_value_get_boxed'
|
||||
elif self.signature == 'aay':
|
||||
self.ctype_in_g = 'const gchar *const *'
|
||||
self.ctype_in = 'const gchar *const *'
|
||||
self.ctype_in_dup = 'gchar **'
|
||||
self.ctype_out = 'gchar ***'
|
||||
self.gtype = 'G_TYPE_STRV'
|
||||
self.free_func = 'g_strfreev'
|
||||
self.format_in = '^aay'
|
||||
self.format_out = '^aay'
|
||||
self.gvariant_get = 'g_variant_get_bytestring_array'
|
||||
self.gvalue_get = 'g_value_get_boxed'
|
||||
|
||||
class Method:
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
self.in_args = []
|
||||
self.out_args = []
|
||||
self.annotations = []
|
||||
self.doc_string = ''
|
||||
self.since = ''
|
||||
self.deprecated = False
|
||||
|
||||
def post_process(self, interface_prefix, cns, cns_upper, cns_lower, containing_iface):
|
||||
if len(self.doc_string) == 0:
|
||||
self.doc_string = utils.lookup_docs(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = utils.lookup_since(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = containing_iface.since
|
||||
|
||||
name = self.name
|
||||
overridden_name = utils.lookup_annotation(self.annotations, 'org.gtk.GDBus.C.Name')
|
||||
if utils.is_ugly_case(overridden_name):
|
||||
self.name_lower = overridden_name.lower()
|
||||
else:
|
||||
if overridden_name:
|
||||
name = overridden_name
|
||||
self.name_lower = utils.camel_case_to_uscore(name).lower().replace('-', '_')
|
||||
self.name_hyphen = self.name_lower.replace('_', '-')
|
||||
|
||||
arg_count = 0
|
||||
for a in self.in_args:
|
||||
a.post_process(interface_prefix, cns, cns_upper, cns_lower, arg_count)
|
||||
arg_count += 1
|
||||
|
||||
for a in self.out_args:
|
||||
a.post_process(interface_prefix, cns, cns_upper, cns_lower, arg_count)
|
||||
arg_count += 1
|
||||
|
||||
if utils.lookup_annotation(self.annotations, 'org.freedesktop.DBus.Deprecated') == 'true':
|
||||
self.deprecated = True
|
||||
|
||||
class Signal:
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
self.args = []
|
||||
self.annotations = []
|
||||
self.doc_string = ''
|
||||
self.since = ''
|
||||
self.deprecated = False
|
||||
|
||||
def post_process(self, interface_prefix, cns, cns_upper, cns_lower, containing_iface):
|
||||
if len(self.doc_string) == 0:
|
||||
self.doc_string = utils.lookup_docs(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = utils.lookup_since(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = containing_iface.since
|
||||
|
||||
name = self.name
|
||||
overridden_name = utils.lookup_annotation(self.annotations, 'org.gtk.GDBus.C.Name')
|
||||
if utils.is_ugly_case(overridden_name):
|
||||
self.name_lower = overridden_name.lower()
|
||||
else:
|
||||
if overridden_name:
|
||||
name = overridden_name
|
||||
self.name_lower = utils.camel_case_to_uscore(name).lower().replace('-', '_')
|
||||
self.name_hyphen = self.name_lower.replace('_', '-')
|
||||
|
||||
arg_count = 0
|
||||
for a in self.args:
|
||||
a.post_process(interface_prefix, cns, cns_upper, cns_lower, arg_count)
|
||||
arg_count += 1
|
||||
|
||||
if utils.lookup_annotation(self.annotations, 'org.freedesktop.DBus.Deprecated') == 'true':
|
||||
self.deprecated = True
|
||||
|
||||
class Property:
|
||||
def __init__(self, name, signature, access):
|
||||
self.name = name
|
||||
self.signature = signature
|
||||
self.access = access
|
||||
self.annotations = []
|
||||
self.arg = Arg('value', self.signature)
|
||||
self.arg.annotations = self.annotations
|
||||
self.readable = False
|
||||
self.writable = False
|
||||
if self.access == 'readwrite':
|
||||
self.readable = True
|
||||
self.writable = True
|
||||
elif self.access == 'read':
|
||||
self.readable = True
|
||||
elif self.access == 'write':
|
||||
self.writable = True
|
||||
else:
|
||||
raise RuntimeError('Invalid access type %s'%self.access)
|
||||
self.doc_string = ''
|
||||
self.since = ''
|
||||
self.deprecated = False
|
||||
|
||||
def post_process(self, interface_prefix, cns, cns_upper, cns_lower, containing_iface):
|
||||
if len(self.doc_string) == 0:
|
||||
self.doc_string = utils.lookup_docs(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = utils.lookup_since(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = containing_iface.since
|
||||
|
||||
name = self.name
|
||||
overridden_name = utils.lookup_annotation(self.annotations, 'org.gtk.GDBus.C.Name')
|
||||
if utils.is_ugly_case(overridden_name):
|
||||
self.name_lower = overridden_name.lower()
|
||||
else:
|
||||
if overridden_name:
|
||||
name = overridden_name
|
||||
self.name_lower = utils.camel_case_to_uscore(name).lower().replace('-', '_')
|
||||
self.name_hyphen = self.name_lower.replace('_', '-')
|
||||
# don't clash with the GType getter, e.g.: GType foo_bar_get_type (void); G_GNUC_CONST
|
||||
if self.name_lower == 'type':
|
||||
self.name_lower = 'type_'
|
||||
|
||||
# recalculate arg
|
||||
self.arg.annotations = self.annotations
|
||||
self.arg.post_process(interface_prefix, cns, cns_upper, cns_lower, 0)
|
||||
|
||||
if utils.lookup_annotation(self.annotations, 'org.freedesktop.DBus.Deprecated') == 'true':
|
||||
self.deprecated = True
|
||||
|
||||
class Interface:
|
||||
def __init__(self, name):
|
||||
self.name = name
|
||||
self.methods = []
|
||||
self.signals = []
|
||||
self.properties = []
|
||||
self.annotations = []
|
||||
self.doc_string = ''
|
||||
self.doc_string_brief = ''
|
||||
self.since = ''
|
||||
self.deprecated = False
|
||||
|
||||
def post_process(self, interface_prefix, c_namespace):
|
||||
if len(self.doc_string) == 0:
|
||||
self.doc_string = utils.lookup_docs(self.annotations)
|
||||
if len(self.doc_string_brief) == 0:
|
||||
self.doc_string_brief = utils.lookup_brief_docs(self.annotations)
|
||||
if len(self.since) == 0:
|
||||
self.since = utils.lookup_since(self.annotations)
|
||||
|
||||
if len(c_namespace) > 0:
|
||||
if utils.is_ugly_case(c_namespace):
|
||||
cns = c_namespace.replace('_', '')
|
||||
cns_upper = c_namespace.upper() + '_'
|
||||
cns_lower = c_namespace.lower() + '_'
|
||||
else:
|
||||
cns = c_namespace
|
||||
cns_upper = utils.camel_case_to_uscore(c_namespace).upper() + '_'
|
||||
cns_lower = utils.camel_case_to_uscore(c_namespace).lower() + '_'
|
||||
else:
|
||||
cns = ''
|
||||
cns_upper = ''
|
||||
cns_lower = ''
|
||||
|
||||
overridden_name = utils.lookup_annotation(self.annotations, 'org.gtk.GDBus.C.Name')
|
||||
if utils.is_ugly_case(overridden_name):
|
||||
name = overridden_name.replace('_', '')
|
||||
name_with_ns = cns + name
|
||||
self.name_without_prefix = name
|
||||
self.camel_name = name_with_ns
|
||||
self.ns_upper = cns_upper
|
||||
self.name_lower = cns_lower + overridden_name.lower()
|
||||
self.name_upper = overridden_name.upper()
|
||||
|
||||
#raise RuntimeError('handle Ugly_Case ', overridden_name)
|
||||
else:
|
||||
if overridden_name:
|
||||
name = overridden_name
|
||||
else:
|
||||
name = self.name
|
||||
if name.startswith(interface_prefix):
|
||||
name = name[len(interface_prefix):]
|
||||
self.name_without_prefix = name
|
||||
name = utils.strip_dots(name)
|
||||
name_with_ns = utils.strip_dots(cns + '.' + name)
|
||||
self.camel_name = name_with_ns
|
||||
self.ns_upper = cns_upper
|
||||
self.name_lower = cns_lower + utils.camel_case_to_uscore(name)
|
||||
self.name_upper = utils.camel_case_to_uscore(name).upper()
|
||||
|
||||
self.name_hyphen = self.name_upper.lower().replace('_', '-')
|
||||
|
||||
if utils.lookup_annotation(self.annotations, 'org.freedesktop.DBus.Deprecated') == 'true':
|
||||
self.deprecated = True
|
||||
|
||||
for m in self.methods:
|
||||
m.post_process(interface_prefix, cns, cns_upper, cns_lower, self)
|
||||
|
||||
for s in self.signals:
|
||||
s.post_process(interface_prefix, cns, cns_upper, cns_lower, self)
|
||||
|
||||
for p in self.properties:
|
||||
p.post_process(interface_prefix, cns, cns_upper, cns_lower, self)
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/dbustypes.pyc
Normal file
288
gtk-nsis-pack/share/glib-2.0/codegen/parser.py
Normal file
@@ -0,0 +1,288 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
import sys
|
||||
import xml.parsers.expat
|
||||
|
||||
from . import dbustypes
|
||||
|
||||
class DBusXMLParser:
|
||||
STATE_TOP = 'top'
|
||||
STATE_NODE = 'node'
|
||||
STATE_INTERFACE = 'interface'
|
||||
STATE_METHOD = 'method'
|
||||
STATE_SIGNAL = 'signal'
|
||||
STATE_PROPERTY = 'property'
|
||||
STATE_ARG = 'arg'
|
||||
STATE_ANNOTATION = 'annotation'
|
||||
STATE_IGNORED = 'ignored'
|
||||
|
||||
def __init__(self, xml_data):
|
||||
self._parser = xml.parsers.expat.ParserCreate()
|
||||
self._parser.CommentHandler = self.handle_comment
|
||||
self._parser.CharacterDataHandler = self.handle_char_data
|
||||
self._parser.StartElementHandler = self.handle_start_element
|
||||
self._parser.EndElementHandler = self.handle_end_element
|
||||
|
||||
self.parsed_interfaces = []
|
||||
self._cur_object = None
|
||||
|
||||
self.state = DBusXMLParser.STATE_TOP
|
||||
self.state_stack = []
|
||||
self._cur_object = None
|
||||
self._cur_object_stack = []
|
||||
|
||||
self.doc_comment_last_symbol = ''
|
||||
|
||||
self._parser.Parse(xml_data)
|
||||
|
||||
COMMENT_STATE_BEGIN = 'begin'
|
||||
COMMENT_STATE_PARAMS = 'params'
|
||||
COMMENT_STATE_BODY = 'body'
|
||||
COMMENT_STATE_SKIP = 'skip'
|
||||
def handle_comment(self, data):
|
||||
comment_state = DBusXMLParser.COMMENT_STATE_BEGIN;
|
||||
lines = data.split('\n')
|
||||
symbol = ''
|
||||
body = ''
|
||||
in_para = False
|
||||
params = {}
|
||||
for line in lines:
|
||||
orig_line = line
|
||||
line = line.lstrip()
|
||||
if comment_state == DBusXMLParser.COMMENT_STATE_BEGIN:
|
||||
if len(line) > 0:
|
||||
colon_index = line.find(': ')
|
||||
if colon_index == -1:
|
||||
if line.endswith(':'):
|
||||
symbol = line[0:len(line)-1]
|
||||
comment_state = DBusXMLParser.COMMENT_STATE_PARAMS
|
||||
else:
|
||||
comment_state = DBusXMLParser.COMMENT_STATE_SKIP
|
||||
else:
|
||||
symbol = line[0:colon_index]
|
||||
rest_of_line = line[colon_index+2:].strip()
|
||||
if len(rest_of_line) > 0:
|
||||
body += '<para>' + rest_of_line + '</para>'
|
||||
comment_state = DBusXMLParser.COMMENT_STATE_PARAMS
|
||||
elif comment_state == DBusXMLParser.COMMENT_STATE_PARAMS:
|
||||
if line.startswith('@'):
|
||||
colon_index = line.find(': ')
|
||||
if colon_index == -1:
|
||||
comment_state = DBusXMLParser.COMMENT_STATE_BODY
|
||||
if not in_para:
|
||||
body += '<para>'
|
||||
in_para = True
|
||||
body += orig_line + '\n'
|
||||
else:
|
||||
param = line[1:colon_index]
|
||||
docs = line[colon_index + 2:]
|
||||
params[param] = docs
|
||||
else:
|
||||
comment_state = DBusXMLParser.COMMENT_STATE_BODY
|
||||
if len(line) > 0:
|
||||
if not in_para:
|
||||
body += '<para>'
|
||||
in_para = True
|
||||
body += orig_line + '\n'
|
||||
elif comment_state == DBusXMLParser.COMMENT_STATE_BODY:
|
||||
if len(line) > 0:
|
||||
if not in_para:
|
||||
body += '<para>'
|
||||
in_para = True
|
||||
body += orig_line + '\n'
|
||||
else:
|
||||
if in_para:
|
||||
body += '</para>'
|
||||
in_para = False
|
||||
if in_para:
|
||||
body += '</para>'
|
||||
|
||||
if symbol != '':
|
||||
self.doc_comment_last_symbol = symbol
|
||||
self.doc_comment_params = params
|
||||
self.doc_comment_body = body
|
||||
|
||||
def handle_char_data(self, data):
|
||||
#print 'char_data=%s'%data
|
||||
pass
|
||||
|
||||
def handle_start_element(self, name, attrs):
|
||||
old_state = self.state
|
||||
old_cur_object = self._cur_object
|
||||
if self.state == DBusXMLParser.STATE_IGNORED:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
elif self.state == DBusXMLParser.STATE_TOP:
|
||||
if name == DBusXMLParser.STATE_NODE:
|
||||
self.state = DBusXMLParser.STATE_NODE
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
elif self.state == DBusXMLParser.STATE_NODE:
|
||||
if name == DBusXMLParser.STATE_INTERFACE:
|
||||
self.state = DBusXMLParser.STATE_INTERFACE
|
||||
iface = dbustypes.Interface(attrs['name'])
|
||||
self._cur_object = iface
|
||||
self.parsed_interfaces.append(iface)
|
||||
elif name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
# assign docs, if any
|
||||
if 'name' in attrs and self.doc_comment_last_symbol == attrs['name']:
|
||||
self._cur_object.doc_string = self.doc_comment_body
|
||||
if 'short_description' in self.doc_comment_params:
|
||||
short_description = self.doc_comment_params['short_description']
|
||||
self._cur_object.doc_string_brief = short_description
|
||||
if 'since' in self.doc_comment_params:
|
||||
self._cur_object.since = self.doc_comment_params['since']
|
||||
|
||||
elif self.state == DBusXMLParser.STATE_INTERFACE:
|
||||
if name == DBusXMLParser.STATE_METHOD:
|
||||
self.state = DBusXMLParser.STATE_METHOD
|
||||
method = dbustypes.Method(attrs['name'])
|
||||
self._cur_object.methods.append(method)
|
||||
self._cur_object = method
|
||||
elif name == DBusXMLParser.STATE_SIGNAL:
|
||||
self.state = DBusXMLParser.STATE_SIGNAL
|
||||
signal = dbustypes.Signal(attrs['name'])
|
||||
self._cur_object.signals.append(signal)
|
||||
self._cur_object = signal
|
||||
elif name == DBusXMLParser.STATE_PROPERTY:
|
||||
self.state = DBusXMLParser.STATE_PROPERTY
|
||||
prop = dbustypes.Property(attrs['name'], attrs['type'], attrs['access'])
|
||||
self._cur_object.properties.append(prop)
|
||||
self._cur_object = prop
|
||||
elif name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
# assign docs, if any
|
||||
if 'name' in attrs and self.doc_comment_last_symbol == attrs['name']:
|
||||
self._cur_object.doc_string = self.doc_comment_body
|
||||
if 'since' in self.doc_comment_params:
|
||||
self._cur_object.since = self.doc_comment_params['since']
|
||||
|
||||
elif self.state == DBusXMLParser.STATE_METHOD:
|
||||
if name == DBusXMLParser.STATE_ARG:
|
||||
self.state = DBusXMLParser.STATE_ARG
|
||||
arg_name = None
|
||||
if 'name' in attrs:
|
||||
arg_name = attrs['name']
|
||||
arg = dbustypes.Arg(arg_name, attrs['type'])
|
||||
direction = attrs.get('direction', 'in')
|
||||
if direction == 'in':
|
||||
self._cur_object.in_args.append(arg)
|
||||
elif direction == 'out':
|
||||
self._cur_object.out_args.append(arg)
|
||||
else:
|
||||
raise RuntimeError('Invalid direction "%s"'%(direction))
|
||||
self._cur_object = arg
|
||||
elif name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
# assign docs, if any
|
||||
if self.doc_comment_last_symbol == old_cur_object.name:
|
||||
if 'name' in attrs and attrs['name'] in self.doc_comment_params:
|
||||
doc_string = self.doc_comment_params[attrs['name']]
|
||||
if doc_string != None:
|
||||
self._cur_object.doc_string = doc_string
|
||||
if 'since' in self.doc_comment_params:
|
||||
self._cur_object.since = self.doc_comment_params['since']
|
||||
|
||||
elif self.state == DBusXMLParser.STATE_SIGNAL:
|
||||
if name == DBusXMLParser.STATE_ARG:
|
||||
self.state = DBusXMLParser.STATE_ARG
|
||||
arg_name = None
|
||||
if 'name' in attrs:
|
||||
arg_name = attrs['name']
|
||||
arg = dbustypes.Arg(arg_name, attrs['type'])
|
||||
self._cur_object.args.append(arg)
|
||||
self._cur_object = arg
|
||||
elif name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
# assign docs, if any
|
||||
if self.doc_comment_last_symbol == old_cur_object.name:
|
||||
if 'name' in attrs and attrs['name'] in self.doc_comment_params:
|
||||
doc_string = self.doc_comment_params[attrs['name']]
|
||||
if doc_string != None:
|
||||
self._cur_object.doc_string = doc_string
|
||||
if 'since' in self.doc_comment_params:
|
||||
self._cur_object.since = self.doc_comment_params['since']
|
||||
|
||||
elif self.state == DBusXMLParser.STATE_PROPERTY:
|
||||
if name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
elif self.state == DBusXMLParser.STATE_ARG:
|
||||
if name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
elif self.state == DBusXMLParser.STATE_ANNOTATION:
|
||||
if name == DBusXMLParser.STATE_ANNOTATION:
|
||||
self.state = DBusXMLParser.STATE_ANNOTATION
|
||||
anno = dbustypes.Annotation(attrs['name'], attrs['value'])
|
||||
self._cur_object.annotations.append(anno)
|
||||
self._cur_object = anno
|
||||
else:
|
||||
self.state = DBusXMLParser.STATE_IGNORED
|
||||
|
||||
else:
|
||||
raise RuntimeError('Unhandled state "%s" while entering element with name "%s"'%(self.state, name))
|
||||
|
||||
self.state_stack.append(old_state)
|
||||
self._cur_object_stack.append(old_cur_object)
|
||||
|
||||
def handle_end_element(self, name):
|
||||
self.state = self.state_stack.pop()
|
||||
self._cur_object = self._cur_object_stack.pop()
|
||||
|
||||
def parse_dbus_xml(xml_data):
|
||||
parser = DBusXMLParser(xml_data)
|
||||
return parser.parsed_interfaces
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/parser.pyc
Normal file
102
gtk-nsis-pack/share/glib-2.0/codegen/utils.py
Normal file
@@ -0,0 +1,102 @@
|
||||
# -*- Mode: Python -*-
|
||||
|
||||
# GDBus - GLib D-Bus Library
|
||||
#
|
||||
# Copyright (C) 2008-2011 Red Hat, Inc.
|
||||
#
|
||||
# This library is free software; you can redistribute it and/or
|
||||
# modify it under the terms of the GNU Lesser General Public
|
||||
# License as published by the Free Software Foundation; either
|
||||
# version 2 of the License, or (at your option) any later version.
|
||||
#
|
||||
# This library is distributed in the hope that it will be useful,
|
||||
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
||||
# Lesser General Public License for more details.
|
||||
#
|
||||
# You should have received a copy of the GNU Lesser General
|
||||
# Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
||||
#
|
||||
# Author: David Zeuthen <davidz@redhat.com>
|
||||
|
||||
import distutils.version
|
||||
|
||||
def strip_dots(s):
|
||||
ret = ''
|
||||
force_upper = False
|
||||
for c in s:
|
||||
if c == '.':
|
||||
force_upper = True
|
||||
else:
|
||||
if force_upper:
|
||||
ret += c.upper()
|
||||
force_upper = False
|
||||
else:
|
||||
ret += c
|
||||
return ret
|
||||
|
||||
def dots_to_hyphens(s):
|
||||
return s.replace('.', '-')
|
||||
|
||||
def camel_case_to_uscore(s):
|
||||
ret = ''
|
||||
insert_uscore = False
|
||||
prev_was_lower = False
|
||||
initial = True;
|
||||
for c in s:
|
||||
# Keep initial underscores in camel case
|
||||
if initial and c == '_':
|
||||
ret += '_'
|
||||
continue;
|
||||
initial = False
|
||||
|
||||
if c.isupper():
|
||||
if prev_was_lower:
|
||||
insert_uscore = True
|
||||
prev_was_lower = False
|
||||
else:
|
||||
prev_was_lower = True
|
||||
if insert_uscore:
|
||||
ret += '_'
|
||||
ret += c.lower()
|
||||
insert_uscore = False
|
||||
return ret
|
||||
|
||||
def is_ugly_case(s):
|
||||
if s and s.find('_') > 0:
|
||||
return True
|
||||
return False
|
||||
|
||||
def lookup_annotation(annotations, key):
|
||||
if annotations:
|
||||
for a in annotations:
|
||||
if a.key == key:
|
||||
return a.value
|
||||
return None
|
||||
|
||||
def lookup_docs(annotations):
|
||||
s = lookup_annotation(annotations, 'org.gtk.GDBus.DocString')
|
||||
if s == None:
|
||||
return ''
|
||||
else:
|
||||
return s
|
||||
|
||||
def lookup_since(annotations):
|
||||
s = lookup_annotation(annotations, 'org.gtk.GDBus.Since')
|
||||
if s == None:
|
||||
return ''
|
||||
else:
|
||||
return s
|
||||
|
||||
def lookup_brief_docs(annotations):
|
||||
s = lookup_annotation(annotations, 'org.gtk.GDBus.DocString.Short')
|
||||
if s == None:
|
||||
return ''
|
||||
else:
|
||||
return s
|
||||
|
||||
def version_cmp_key(key):
|
||||
# If the 'since' version is empty put a 0 in its place as this will
|
||||
# allow LooseVersion to work and will always compare lower.
|
||||
v = key[0] if key[0] else '0'
|
||||
return (distutils.version.LooseVersion(v), key[1])
|
||||
BIN
gtk-nsis-pack/share/glib-2.0/codegen/utils.pyc
Normal file
261
gtk-nsis-pack/share/glib-2.0/gdb/glib.py
Normal file
@@ -0,0 +1,261 @@
|
||||
import gdb
|
||||
import sys
|
||||
|
||||
if sys.version_info[0] >= 3:
|
||||
long = int
|
||||
|
||||
# This is not quite right, as local vars may override symname
|
||||
def read_global_var (symname):
|
||||
return gdb.selected_frame().read_var(symname)
|
||||
|
||||
def g_quark_to_string (quark):
|
||||
if quark == None:
|
||||
return None
|
||||
quark = long(quark)
|
||||
if quark == 0:
|
||||
return None
|
||||
try:
|
||||
val = read_global_var ("quarks")
|
||||
max_q = long(read_global_var ("quark_seq_id"))
|
||||
except:
|
||||
try:
|
||||
val = read_global_var ("g_quarks")
|
||||
max_q = long(read_global_var ("g_quark_seq_id"))
|
||||
except:
|
||||
return None;
|
||||
if quark < max_q:
|
||||
return val[quark].string()
|
||||
return None
|
||||
|
||||
# We override the node printers too, so that node->next is not expanded
|
||||
class GListNodePrinter:
|
||||
"Prints a GList node"
|
||||
|
||||
def __init__ (self, val):
|
||||
self.val = val
|
||||
|
||||
def to_string (self):
|
||||
return "{data=%s, next=0x%x, prev=0x%x}" % (str(self.val["data"]), long(self.val["next"]), long(self.val["prev"]))
|
||||
|
||||
class GSListNodePrinter:
|
||||
"Prints a GSList node"
|
||||
|
||||
def __init__ (self, val):
|
||||
self.val = val
|
||||
|
||||
def to_string (self):
|
||||
return "{data=%s, next=0x%x}" % (str(self.val["data"]), long(self.val["next"]))
|
||||
|
||||
class GListPrinter:
|
||||
"Prints a GList"
|
||||
|
||||
class _iterator:
|
||||
def __init__(self, head, listtype):
|
||||
self.link = head
|
||||
self.listtype = listtype
|
||||
self.count = 0
|
||||
|
||||
def __iter__(self):
|
||||
return self
|
||||
|
||||
def next(self):
|
||||
if self.link == 0:
|
||||
raise StopIteration
|
||||
data = self.link['data']
|
||||
self.link = self.link['next']
|
||||
count = self.count
|
||||
self.count = self.count + 1
|
||||
return ('[%d]' % count, data)
|
||||
|
||||
__next__ = next
|
||||
|
||||
def __init__ (self, val, listtype):
|
||||
self.val = val
|
||||
self.listtype = listtype
|
||||
|
||||
def children(self):
|
||||
return self._iterator(self.val, self.listtype)
|
||||
|
||||
def to_string (self):
|
||||
return "0x%x" % (long(self.val))
|
||||
|
||||
def display_hint (self):
|
||||
return "array"
|
||||
|
||||
class GHashPrinter:
|
||||
"Prints a GHashTable"
|
||||
|
||||
class _iterator:
|
||||
def __init__(self, ht, keys_are_strings):
|
||||
self.ht = ht
|
||||
if ht != 0:
|
||||
self.keys = ht["keys"]
|
||||
self.values = ht["values"]
|
||||
self.hashes = ht["hashes"]
|
||||
self.size = ht["size"]
|
||||
self.pos = 0
|
||||
self.keys_are_strings = keys_are_strings
|
||||
self.value = None
|
||||
|
||||
def __iter__(self):
|
||||
return self
|
||||
|
||||
def next(self):
|
||||
if self.ht == 0:
|
||||
raise StopIteration
|
||||
if self.value != None:
|
||||
v = self.value
|
||||
self.value = None
|
||||
return v
|
||||
while long(self.pos) < long(self.size):
|
||||
self.pos = self.pos + 1
|
||||
if long (self.hashes[self.pos]) >= 2:
|
||||
key = self.keys[self.pos]
|
||||
val = self.values[self.pos]
|
||||
|
||||
if self.keys_are_strings:
|
||||
key = key.cast (gdb.lookup_type("char").pointer())
|
||||
|
||||
# Queue value for next result
|
||||
self.value = ('[%dv]'% (self.pos), val)
|
||||
|
||||
# Return key
|
||||
return ('[%dk]'% (self.pos), key)
|
||||
raise StopIteration
|
||||
|
||||
__next__ = next
|
||||
|
||||
def __init__ (self, val):
|
||||
self.val = val
|
||||
self.keys_are_strings = False
|
||||
try:
|
||||
string_hash = read_global_var ("g_str_hash")
|
||||
except:
|
||||
string_hash = None
|
||||
if self.val != 0 and string_hash != None and self.val["hash_func"] == string_hash:
|
||||
self.keys_are_strings = True
|
||||
|
||||
def children(self):
|
||||
return self._iterator(self.val, self.keys_are_strings)
|
||||
|
||||
def to_string (self):
|
||||
return "0x%x" % (long(self.val))
|
||||
|
||||
def display_hint (self):
|
||||
return "map"
|
||||
|
||||
def pretty_printer_lookup (val):
|
||||
# None yet, want things like hash table and list
|
||||
|
||||
type = val.type.unqualified()
|
||||
|
||||
# If it points to a reference, get the reference.
|
||||
if type.code == gdb.TYPE_CODE_REF:
|
||||
type = type.target ()
|
||||
|
||||
if type.code == gdb.TYPE_CODE_PTR:
|
||||
type = type.target().unqualified()
|
||||
t = str(type)
|
||||
if t == "GList":
|
||||
return GListPrinter(val, "GList")
|
||||
if t == "GSList":
|
||||
return GListPrinter(val, "GSList")
|
||||
if t == "GHashTable":
|
||||
return GHashPrinter(val)
|
||||
else:
|
||||
t = str(type)
|
||||
if t == "GList":
|
||||
return GListNodePrinter(val)
|
||||
if t == "GSList *":
|
||||
return GListPrinter(val, "GSList")
|
||||
return None
|
||||
|
||||
def register (obj):
|
||||
if obj == None:
|
||||
obj = gdb
|
||||
|
||||
obj.pretty_printers.append(pretty_printer_lookup)
|
||||
|
||||
class ForeachCommand (gdb.Command):
|
||||
"""Foreach on list"""
|
||||
|
||||
def __init__ (self):
|
||||
super (ForeachCommand, self).__init__ ("gforeach",
|
||||
gdb.COMMAND_DATA,
|
||||
gdb.COMPLETE_SYMBOL)
|
||||
|
||||
def valid_name (self, name):
|
||||
if not name[0].isalpha():
|
||||
return False
|
||||
return True
|
||||
|
||||
def parse_args (self, arg):
|
||||
i = arg.find(" ")
|
||||
if i <= 0:
|
||||
raise Exception ("No var specified")
|
||||
var = arg[:i]
|
||||
if not self.valid_name(var):
|
||||
raise Exception ("Invalid variable name")
|
||||
|
||||
while i < len (arg) and arg[i].isspace():
|
||||
i = i + 1
|
||||
|
||||
if arg[i:i+2] != "in":
|
||||
raise Exception ("Invalid syntax, missing in")
|
||||
|
||||
i = i + 2
|
||||
|
||||
while i < len (arg) and arg[i].isspace():
|
||||
i = i + 1
|
||||
|
||||
colon = arg.find (":", i)
|
||||
if colon == -1:
|
||||
raise Exception ("Invalid syntax, missing colon")
|
||||
|
||||
val = arg[i:colon]
|
||||
|
||||
colon = colon + 1
|
||||
while colon < len (arg) and arg[colon].isspace():
|
||||
colon = colon + 1
|
||||
|
||||
command = arg[colon:]
|
||||
|
||||
return (var, val, command)
|
||||
|
||||
def do_iter(self, arg, item, command):
|
||||
item = item.cast (gdb.lookup_type("void").pointer())
|
||||
item = long(item)
|
||||
to_eval = "set $%s = (void *)0x%x\n"%(arg, item)
|
||||
gdb.execute(to_eval)
|
||||
gdb.execute(command)
|
||||
|
||||
def slist_iterator (self, arg, container, command):
|
||||
l = container.cast (gdb.lookup_type("GSList").pointer())
|
||||
while long(l) != 0:
|
||||
self.do_iter (arg, l["data"], command)
|
||||
l = l["next"]
|
||||
|
||||
def list_iterator (self, arg, container, command):
|
||||
l = container.cast (gdb.lookup_type("GList").pointer())
|
||||
while long(l) != 0:
|
||||
self.do_iter (arg, l["data"], command)
|
||||
l = l["next"]
|
||||
|
||||
def pick_iterator (self, container):
|
||||
t = container.type.unqualified()
|
||||
if t.code == gdb.TYPE_CODE_PTR:
|
||||
t = t.target().unqualified()
|
||||
t = str(t)
|
||||
if t == "GSList":
|
||||
return self.slist_iterator
|
||||
if t == "GList":
|
||||
return self.list_iterator
|
||||
raise Exception("Invalid container type %s"%(str(container.type)))
|
||||
|
||||
def invoke (self, arg, from_tty):
|
||||
(var, container, command) = self.parse_args(arg)
|
||||
container = gdb.parse_and_eval (container)
|
||||
func = self.pick_iterator(container)
|
||||
func(var, container, command)
|
||||
|
||||
ForeachCommand ()
|
||||
295
gtk-nsis-pack/share/glib-2.0/gdb/gobject.py
Normal file
@@ -0,0 +1,295 @@
|
||||
import os.path
|
||||
import gdb
|
||||
import glib
|
||||
import sys
|
||||
|
||||
if sys.version_info[0] >= 3:
|
||||
long = int
|
||||
else:
|
||||
import itertools
|
||||
map = itertools.imap
|
||||
|
||||
# FrameDecorator is new in gdb 7.7, so we adapt to its absence.
|
||||
try:
|
||||
import gdb.FrameDecorator
|
||||
HAVE_GDB_FRAMEDECORATOR = True
|
||||
FrameDecorator = gdb.FrameDecorator.FrameDecorator
|
||||
except ImportError:
|
||||
HAVE_GDB_FRAMEDECORATOR = False
|
||||
|
||||
# This is not quite right, as local vars may override symname
|
||||
def read_global_var (symname):
|
||||
return gdb.selected_frame().read_var(symname)
|
||||
|
||||
def g_type_to_name (gtype):
|
||||
def lookup_fundamental_type (typenode):
|
||||
if typenode == 0:
|
||||
return None
|
||||
val = read_global_var ("static_fundamental_type_nodes")
|
||||
if val == None:
|
||||
return None
|
||||
return val[typenode >> 2].address()
|
||||
|
||||
gtype = long(gtype)
|
||||
typenode = gtype - gtype % 4
|
||||
if typenode > (255 << 2):
|
||||
typenode = gdb.Value(typenode).cast (gdb.lookup_type("TypeNode").pointer())
|
||||
else:
|
||||
typenode = lookup_fundamental_type (typenode)
|
||||
if typenode != None:
|
||||
return glib.g_quark_to_string (typenode["qname"])
|
||||
return None
|
||||
|
||||
def is_g_type_instance (val):
|
||||
def is_g_type_instance_helper (type):
|
||||
if str(type) == "GTypeInstance":
|
||||
return True
|
||||
|
||||
while type.code == gdb.TYPE_CODE_TYPEDEF:
|
||||
type = type.target()
|
||||
|
||||
if type.code != gdb.TYPE_CODE_STRUCT:
|
||||
return False
|
||||
|
||||
fields = type.fields()
|
||||
if len (fields) < 1:
|
||||
return False
|
||||
|
||||
first_field = fields[0]
|
||||
return is_g_type_instance_helper(first_field.type)
|
||||
|
||||
type = val.type
|
||||
if type.code != gdb.TYPE_CODE_PTR:
|
||||
return False
|
||||
type = type.target()
|
||||
return is_g_type_instance_helper (type)
|
||||
|
||||
def g_type_name_from_instance (instance):
|
||||
if long(instance) != 0:
|
||||
try:
|
||||
inst = instance.cast (gdb.lookup_type("GTypeInstance").pointer())
|
||||
klass = inst["g_class"]
|
||||
gtype = klass["g_type"]
|
||||
name = g_type_to_name (gtype)
|
||||
return name
|
||||
except RuntimeError:
|
||||
pass
|
||||
return None
|
||||
|
||||
class GTypePrettyPrinter:
|
||||
"Prints a GType instance pointer"
|
||||
|
||||
def __init__ (self, val):
|
||||
self.val = val
|
||||
|
||||
def to_string (self):
|
||||
name = g_type_name_from_instance (self.val)
|
||||
if name:
|
||||
return ("0x%x [%s]")% (long(self.val), name)
|
||||
return ("0x%x") % (long(self.val))
|
||||
|
||||
def pretty_printer_lookup (val):
|
||||
if is_g_type_instance (val):
|
||||
return GTypePrettyPrinter (val)
|
||||
|
||||
return None
|
||||
|
||||
def get_signal_name (id):
|
||||
if id == None:
|
||||
return None
|
||||
id = long(id)
|
||||
if id == 0:
|
||||
return None
|
||||
val = read_global_var ("g_signal_nodes")
|
||||
max_s = read_global_var ("g_n_signal_nodes")
|
||||
max_s = long(max_s)
|
||||
if id < max_s:
|
||||
return val[id]["name"].string()
|
||||
return None
|
||||
|
||||
def frame_name(frame):
|
||||
return str(frame.function())
|
||||
|
||||
def frame_var(frame, var):
|
||||
return frame.inferior_frame().read_var(var)
|
||||
|
||||
|
||||
class SignalFrame(FrameDecorator):
|
||||
def __init__ (self, frames):
|
||||
FrameDecorator.__init__(self, frames[-1])
|
||||
self.frame = frames[-1]
|
||||
self.frames = frames
|
||||
|
||||
def name (self):
|
||||
return "signal-emission"
|
||||
|
||||
def read_var (self, frame, name, array = None):
|
||||
try:
|
||||
v = frame_var (frame, name)
|
||||
if v == None or v.is_optimized_out:
|
||||
return None
|
||||
if array != None:
|
||||
array.append (v)
|
||||
return v
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
def read_object (self, frame, name, array = None):
|
||||
try:
|
||||
v = frame_var (frame, name)
|
||||
if v == None or v.is_optimized_out:
|
||||
return None
|
||||
v = v.cast (gdb.lookup_type("GObject").pointer())
|
||||
# Ensure this is a somewhat correct object pointer
|
||||
if v != None and g_type_name_from_instance (v):
|
||||
if array != None:
|
||||
array.append (v)
|
||||
return v
|
||||
return None
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
def append (self, array, obj):
|
||||
if obj != None:
|
||||
array.append (obj)
|
||||
|
||||
def or_join_array (self, array):
|
||||
if len(array) == 0:
|
||||
return "???"
|
||||
else:
|
||||
return ' or '.join(set(map(str, array)))
|
||||
|
||||
def get_detailed_signal_from_frame(self, frame, signal):
|
||||
detail = self.read_var (frame, "detail")
|
||||
detail = glib.g_quark_to_string (detail)
|
||||
if detail is not None:
|
||||
return signal + ":" + detail
|
||||
else:
|
||||
return detail
|
||||
|
||||
def function (self):
|
||||
instances = []
|
||||
signals = []
|
||||
|
||||
for frame in self.frames:
|
||||
name = frame_name(frame)
|
||||
if name == "signal_emit_unlocked_R":
|
||||
self.read_object (frame, "instance", instances)
|
||||
node = self.read_var (frame, "node")
|
||||
if node:
|
||||
signal = node["name"].string()
|
||||
signal = self.get_detailed_signal_from_frame(frame, signal)
|
||||
self.append(signals, signal)
|
||||
|
||||
if name == "g_signal_emitv":
|
||||
instance_and_params = self.read_var (frame, "instance_and_params")
|
||||
if instance_and_params:
|
||||
instance = instance_and_params[0]["v_pointer"].cast (gdb.Type("GObject").pointer())
|
||||
self.append (instances, instance)
|
||||
id = self.read_var (frame, "signal_id")
|
||||
signal = get_signal_name (id)
|
||||
if signal:
|
||||
signal = self.get_detailed_signal_from_frame(frame, signal)
|
||||
self.append (signals, signal)
|
||||
|
||||
if name == "g_signal_emit_valist" or name == "g_signal_emit":
|
||||
self.read_object (frame, "instance", instances)
|
||||
id = self.read_var (frame, "signal_id")
|
||||
signal = get_signal_name (id)
|
||||
if signal:
|
||||
signal = self.get_detailed_signal_from_frame(frame, signal)
|
||||
self.append (signals, signal)
|
||||
|
||||
if name == "g_signal_emit_by_name":
|
||||
self.read_object (frame, "instance", instances)
|
||||
self.read_var (frame, "detailed_signal", signals)
|
||||
break
|
||||
|
||||
instance = self.or_join_array (instances)
|
||||
signal = self.or_join_array (signals)
|
||||
|
||||
return "<emit signal %s on instance %s>" % (signal, instance)
|
||||
|
||||
def elided (self):
|
||||
return self.frames[0:-1]
|
||||
|
||||
def describe (self, stream, full):
|
||||
stream.write (" " + self.function () + "\n")
|
||||
|
||||
class GFrameDecorator:
|
||||
def __init__ (self, iter):
|
||||
self.queue = []
|
||||
self.iter = iter
|
||||
|
||||
def __iter__ (self):
|
||||
return self
|
||||
|
||||
def fill (self):
|
||||
while len(self.queue) <= 8:
|
||||
try:
|
||||
f = next(self.iter)
|
||||
self.queue.append (f)
|
||||
except StopIteration:
|
||||
return
|
||||
|
||||
def find_signal_emission (self):
|
||||
for i in range (min (len(self.queue), 3)):
|
||||
if frame_name(self.queue[i]) == "signal_emit_unlocked_R":
|
||||
return i
|
||||
return -1
|
||||
|
||||
def next (self):
|
||||
# Ensure we have enough frames for a full signal emission
|
||||
self.fill()
|
||||
|
||||
# Are we at the end?
|
||||
if len(self.queue) == 0:
|
||||
raise StopIteration
|
||||
|
||||
emission = self.find_signal_emission ()
|
||||
if emission > 0:
|
||||
start = emission
|
||||
while True:
|
||||
if start == 0:
|
||||
break
|
||||
prev_name = frame_name(self.queue[start-1])
|
||||
if prev_name.find("_marshal_") >= 0 or prev_name == "g_closure_invoke":
|
||||
start = start - 1
|
||||
else:
|
||||
break
|
||||
end = emission + 1
|
||||
while end < len(self.queue):
|
||||
if frame_name(self.queue[end]) in ["g_signal_emitv",
|
||||
"g_signal_emit_valist",
|
||||
"g_signal_emit",
|
||||
"g_signal_emit_by_name",
|
||||
"_g_closure_invoke_va"]:
|
||||
end = end + 1
|
||||
else:
|
||||
break
|
||||
|
||||
signal_frames = self.queue[start:end]
|
||||
new_frames = [SignalFrame(signal_frames)]
|
||||
self.queue[start:end] = new_frames
|
||||
|
||||
return self.queue.pop(0)
|
||||
|
||||
def __next__ (self):
|
||||
return self.next()
|
||||
|
||||
class GFrameFilter(object):
|
||||
name = 'glib'
|
||||
enabled = True
|
||||
priority = 100
|
||||
|
||||
def filter(self, iterator):
|
||||
return GFrameDecorator(iterator)
|
||||
|
||||
def register (obj):
|
||||
if obj == None:
|
||||
obj = gdb
|
||||
|
||||
if HAVE_GDB_FRAMEDECORATOR:
|
||||
filter = GFrameFilter()
|
||||
obj.frame_filters[filter.name] = filter
|
||||
obj.pretty_printers.append(pretty_printer_lookup)
|
||||
268
gtk-nsis-pack/share/glib-2.0/gettext/po/Makefile.in.in
Normal file
@@ -0,0 +1,268 @@
|
||||
# Makefile for program source directory in GNU NLS utilities package.
|
||||
# Copyright (C) 1995, 1996, 1997 by Ulrich Drepper <drepper@gnu.ai.mit.edu>
|
||||
#
|
||||
# This file file be copied and used freely without restrictions. It can
|
||||
# be used in projects which are not available under the GNU Public License
|
||||
# but which still want to provide support for the GNU gettext functionality.
|
||||
# Please note that the actual code is *not* freely available.
|
||||
#
|
||||
# - Modified by Owen Taylor <otaylor@redhat.com> to use GETTEXT_PACKAGE
|
||||
# instead of PACKAGE and to look for po2tbl in ./ not in intl/
|
||||
#
|
||||
# - Modified by jacob berkman <jacob@ximian.com> to install
|
||||
# Makefile.in.in and po2tbl.sed.in for use with glib-gettextize
|
||||
|
||||
GETTEXT_PACKAGE = @GETTEXT_PACKAGE@
|
||||
PACKAGE = @PACKAGE@
|
||||
VERSION = @VERSION@
|
||||
|
||||
SHELL = @SHELL@
|
||||
@SET_MAKE@
|
||||
|
||||
srcdir = @srcdir@
|
||||
top_srcdir = @top_srcdir@
|
||||
VPATH = @srcdir@
|
||||
|
||||
prefix = @prefix@
|
||||
exec_prefix = @exec_prefix@
|
||||
datarootdir = @datarootdir@
|
||||
datadir = @datadir@
|
||||
libdir = @libdir@
|
||||
localedir = $(libdir)/locale
|
||||
gnulocaledir = $(datadir)/locale
|
||||
gettextsrcdir = $(datadir)/glib-2.0/gettext/po
|
||||
subdir = po
|
||||
|
||||
INSTALL = @INSTALL@
|
||||
INSTALL_DATA = @INSTALL_DATA@
|
||||
MKINSTALLDIRS = mkdir -p
|
||||
|
||||
CC = @CC@
|
||||
GENCAT = @GENCAT@
|
||||
GMSGFMT = @GMSGFMT@
|
||||
MSGFMT = @MSGFMT@
|
||||
MSGFMT_OPTS = @MSGFMT_OPTS@
|
||||
XGETTEXT = @XGETTEXT@
|
||||
MSGMERGE = msgmerge
|
||||
|
||||
DEFS = @DEFS@
|
||||
CFLAGS = @CFLAGS@
|
||||
CPPFLAGS = @CPPFLAGS@
|
||||
|
||||
INCLUDES = -I.. -I$(top_srcdir)/intl
|
||||
|
||||
COMPILE = $(CC) -c $(DEFS) $(INCLUDES) $(CPPFLAGS) $(CFLAGS) $(XCFLAGS)
|
||||
|
||||
SOURCES =
|
||||
POFILES = @POFILES@
|
||||
GMOFILES = @GMOFILES@
|
||||
DISTFILES = LINGUAS ChangeLog Makefile.in.in POTFILES.in $(GETTEXT_PACKAGE).pot \
|
||||
$(POFILES) $(GMOFILES) $(SOURCES)
|
||||
|
||||
POTFILES = \
|
||||
|
||||
CATALOGS = @CATALOGS@
|
||||
CATOBJEXT = @CATOBJEXT@
|
||||
INSTOBJEXT = @INSTOBJEXT@
|
||||
|
||||
.SUFFIXES:
|
||||
.SUFFIXES: .c .o .po .pox .gmo .mo .msg .cat
|
||||
|
||||
.c.o:
|
||||
$(COMPILE) $<
|
||||
|
||||
.po.pox:
|
||||
$(MAKE) $(GETTEXT_PACKAGE).pot
|
||||
$(MSGMERGE) $< $(srcdir)/$(GETTEXT_PACKAGE).pot -o $*.pox
|
||||
|
||||
.po.mo:
|
||||
$(MSGFMT) -o $@ $<
|
||||
|
||||
.po.gmo:
|
||||
$(AM_V_GEN) file=$(srcdir)/`echo $* | sed 's,.*/,,'`.gmo \
|
||||
&& rm -f $$file && $(GMSGFMT) $(MSGFMT_OPTS) -o $$file $<
|
||||
|
||||
.po.cat:
|
||||
sed -f ../intl/po2msg.sed < $< > $*.msg \
|
||||
&& rm -f $@ && $(GENCAT) $@ $*.msg
|
||||
|
||||
|
||||
all: all-@USE_NLS@
|
||||
|
||||
all-yes: $(CATALOGS)
|
||||
all-no:
|
||||
|
||||
$(srcdir)/$(GETTEXT_PACKAGE).pot: $(POTFILES)
|
||||
$(XGETTEXT) --default-domain=$(GETTEXT_PACKAGE) \
|
||||
--msgid-bugs-address='http://bugzilla.gnome.org/enter_bug.cgi?product=glib&keywords=I18N+L10N&component=general' \
|
||||
--add-comments --keyword=_ --keyword=N_ \
|
||||
--keyword=C_:1c,2 \
|
||||
--keyword=NC_:1c,2 \
|
||||
--keyword=g_dcgettext:2 \
|
||||
--keyword=g_dngettext:2,3 \
|
||||
--keyword=g_dpgettext2:2c,3 \
|
||||
--flag=N_:1:pass-c-format \
|
||||
--flag=C_:2:pass-c-format \
|
||||
--flag=NC_:2:pass-c-format \
|
||||
--flag=g_dngettext:2:pass-c-format \
|
||||
--flag=g_strdup_printf:1:c-format \
|
||||
--flag=g_string_printf:2:c-format \
|
||||
--flag=g_string_append_printf:2:c-format \
|
||||
--flag=g_error_new:3:c-format \
|
||||
--flag=g_set_error:4:c-format \
|
||||
--flag=g_markup_printf_escaped:1:c-format \
|
||||
--flag=g_log:3:c-format \
|
||||
--flag=g_print:1:c-format \
|
||||
--flag=g_printerr:1:c-format \
|
||||
--flag=g_printf:1:c-format \
|
||||
--flag=g_fprintf:2:c-format \
|
||||
--flag=g_sprintf:2:c-format \
|
||||
--flag=g_snprintf:3:c-format \
|
||||
--flag=g_scanner_error:2:c-format \
|
||||
--flag=g_scanner_warn:2:c-format \
|
||||
$(POTFILES) \
|
||||
&& test ! -f $(GETTEXT_PACKAGE).po \
|
||||
|| ( rm -f $(srcdir)/$(GETTEXT_PACKAGE).pot \
|
||||
&& mv $(GETTEXT_PACKAGE).po $(srcdir)/$(GETTEXT_PACKAGE).pot )
|
||||
|
||||
install: install-exec install-data
|
||||
install-exec:
|
||||
install-data: install-data-@USE_NLS@
|
||||
install-data-no: all
|
||||
install-data-yes: all
|
||||
$(MKINSTALLDIRS) $(DESTDIR)$(datadir); \
|
||||
catalogs='$(CATALOGS)'; \
|
||||
for cat in $$catalogs; do \
|
||||
cat=`basename $$cat`; \
|
||||
case "$$cat" in \
|
||||
*.gmo) destdir=$(gnulocaledir);; \
|
||||
*) destdir=$(localedir);; \
|
||||
esac; \
|
||||
lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \
|
||||
dir=$(DESTDIR)$$destdir/$$lang/LC_MESSAGES; \
|
||||
$(MKINSTALLDIRS) $$dir; \
|
||||
if test -r $$cat; then \
|
||||
$(INSTALL_DATA) $$cat $$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT); \
|
||||
echo "installing $$cat as $$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT)"; \
|
||||
else \
|
||||
$(INSTALL_DATA) $(srcdir)/$$cat $$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT); \
|
||||
echo "installing $(srcdir)/$$cat as" \
|
||||
"$$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT)"; \
|
||||
fi; \
|
||||
if test -r $$cat.m; then \
|
||||
$(INSTALL_DATA) $$cat.m $$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT).m; \
|
||||
echo "installing $$cat.m as $$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT).m"; \
|
||||
else \
|
||||
if test -r $(srcdir)/$$cat.m ; then \
|
||||
$(INSTALL_DATA) $(srcdir)/$$cat.m \
|
||||
$$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT).m; \
|
||||
echo "installing $(srcdir)/$$cat as" \
|
||||
"$$dir/$(GETTEXT_PACKAGE)$(INSTOBJEXT).m"; \
|
||||
else \
|
||||
true; \
|
||||
fi; \
|
||||
fi; \
|
||||
done
|
||||
if test "$(PACKAGE)" = "glib"; then \
|
||||
$(MKINSTALLDIRS) $(DESTDIR)$(gettextsrcdir); \
|
||||
$(INSTALL_DATA) $(srcdir)/Makefile.in.in \
|
||||
$(DESTDIR)$(gettextsrcdir)/Makefile.in.in; \
|
||||
else \
|
||||
: ; \
|
||||
fi
|
||||
|
||||
# Define this as empty until I found a useful application.
|
||||
installcheck:
|
||||
|
||||
uninstall:
|
||||
catalogs='$(CATALOGS)'; \
|
||||
for cat in $$catalogs; do \
|
||||
cat=`basename $$cat`; \
|
||||
lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \
|
||||
rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE)$(INSTOBJEXT); \
|
||||
rm -f $(DESTDIR)$(localedir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE)$(INSTOBJEXT).m; \
|
||||
rm -f $(DESTDIR)$(gnulocaledir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE)$(INSTOBJEXT); \
|
||||
rm -f $(DESTDIR)$(gnulocaledir)/$$lang/LC_MESSAGES/$(GETTEXT_PACKAGE)$(INSTOBJEXT).m; \
|
||||
done
|
||||
if test "$(PACKAGE)" = "glib"; then \
|
||||
rm -f $(DESTDIR)$(gettextsrcdir)/Makefile.in.in; \
|
||||
fi
|
||||
|
||||
check: all
|
||||
|
||||
dvi info tags TAGS ID:
|
||||
|
||||
mostlyclean:
|
||||
rm -f core core.* *.pox $(GETTEXT_PACKAGE).po *.old.po cat-id-tbl.tmp
|
||||
rm -fr *.o
|
||||
|
||||
clean: mostlyclean
|
||||
|
||||
distclean: clean
|
||||
rm -f Makefile Makefile.in POTFILES *.mo *.msg *.cat *.cat.m
|
||||
|
||||
maintainer-clean: distclean
|
||||
@echo "This command is intended for maintainers to use;"
|
||||
@echo "it deletes files that may require special tools to rebuild."
|
||||
rm -f $(GMOFILES)
|
||||
|
||||
distdir = ../$(GETTEXT_PACKAGE)-$(VERSION)/$(subdir)
|
||||
dist distdir: $(DISTFILES)
|
||||
dists="$(DISTFILES)"; \
|
||||
for file in $$dists; do \
|
||||
ln $(srcdir)/$$file $(distdir) 2> /dev/null \
|
||||
|| cp -p $(srcdir)/$$file $(distdir); \
|
||||
done
|
||||
|
||||
update-po: Makefile
|
||||
$(MAKE) $(GETTEXT_PACKAGE).pot
|
||||
tmpdir=`pwd`; \
|
||||
cd $(srcdir); \
|
||||
catalogs='$(CATALOGS)'; \
|
||||
for cat in $$catalogs; do \
|
||||
cat=`basename $$cat`; \
|
||||
lang=`echo $$cat | sed 's/\$(CATOBJEXT)$$//'`; \
|
||||
echo "$$lang:"; \
|
||||
if $(MSGMERGE) $$lang.po $(GETTEXT_PACKAGE).pot -o $$tmpdir/$$lang.new.po; then \
|
||||
if cmp $$lang.po $$tmpdir/$$lang.new.po >/dev/null 2>&1; then \
|
||||
rm -f $$tmpdir/$$lang.new.po; \
|
||||
else \
|
||||
if mv -f $$tmpdir/$$lang.new.po $$lang.po; then \
|
||||
:; \
|
||||
else \
|
||||
echo "msgmerge for $$lang.po failed: cannot move $$tmpdir/$$lang.new.po to $$lang.po" 1>&2; \
|
||||
rm -f $$tmpdir/$$lang.new.po; \
|
||||
exit 1; \
|
||||
fi; \
|
||||
fi; \
|
||||
else \
|
||||
echo "msgmerge for $$cat failed!"; \
|
||||
rm -f $$tmpdir/$$lang.new.po; \
|
||||
fi; \
|
||||
done
|
||||
|
||||
# POTFILES is created from POTFILES.in by stripping comments, empty lines
|
||||
# and Intltool tags (enclosed in square brackets), and appending a full
|
||||
# relative path to them
|
||||
POTFILES: POTFILES.in
|
||||
( if test 'x$(srcdir)' != 'x.'; then \
|
||||
posrcprefix='$(top_srcdir)/'; \
|
||||
else \
|
||||
posrcprefix="../"; \
|
||||
fi; \
|
||||
rm -f $@-t $@ \
|
||||
&& (sed -e '/^#/d' \
|
||||
-e "s/^\[.*\] +//" \
|
||||
-e '/^[ ]*$$/d' \
|
||||
-e "s@.*@ $$posrcprefix& \\\\@" < $(srcdir)/$@.in \
|
||||
| sed -e '$$s/\\$$//') > $@-t \
|
||||
&& chmod a-w $@-t \
|
||||
&& mv $@-t $@ )
|
||||
|
||||
Makefile: Makefile.in.in ../config.status POTFILES
|
||||
cd .. \
|
||||
&& $(SHELL) ./config.status $(subdir)/$@.in
|
||||
|
||||
# Tell versions [3.59,3.63) of GNU make not to export all variables.
|
||||
# Otherwise a system limit (for SysV at least) may be exceeded.
|
||||
.NOEXPORT:
|
||||
@@ -12,6 +12,15 @@
|
||||
<key name='color' enum='org.gtk.Demo.Color'>
|
||||
<default>'red'</default>
|
||||
</key>
|
||||
<key name='window-size' type='(ii)'>
|
||||
<default>(-1, -1)</default>
|
||||
</key>
|
||||
<key name='maximized' type='b'>
|
||||
<default>false</default>
|
||||
</key>
|
||||
<key name='fullscreen' type='b'>
|
||||
<default>false</default>
|
||||
</key>
|
||||
</schema>
|
||||
|
||||
</schemalist>
|
||||
|
||||
|
Before Width: | Height: | Size: 779 B After Width: | Height: | Size: 727 B |
|
Before Width: | Height: | Size: 827 B After Width: | Height: | Size: 776 B |
|
After Width: | Height: | Size: 822 B |
BIN
gtk-nsis-pack/share/icons/Adwaita/16x16/devices/ebook-reader.png
Normal file
|
After Width: | Height: | Size: 717 B |
|
Before Width: | Height: | Size: 808 B After Width: | Height: | Size: 235 B |
BIN
gtk-nsis-pack/share/icons/Adwaita/16x16/emotes/emote-love.png
Normal file
|
After Width: | Height: | Size: 709 B |
|
After Width: | Height: | Size: 727 B |
|
Before Width: | Height: | Size: 793 B After Width: | Height: | Size: 770 B |
|
Before Width: | Height: | Size: 769 B After Width: | Height: | Size: 740 B |
|
Before Width: | Height: | Size: 798 B After Width: | Height: | Size: 776 B |
|
Before Width: | Height: | Size: 899 B After Width: | Height: | Size: 870 B |
|
Before Width: | Height: | Size: 745 B After Width: | Height: | Size: 754 B |
|
Before Width: | Height: | Size: 715 B After Width: | Height: | Size: 704 B |
|
Before Width: | Height: | Size: 821 B After Width: | Height: | Size: 791 B |
|
Before Width: | Height: | Size: 731 B After Width: | Height: | Size: 710 B |
|
Before Width: | Height: | Size: 744 B After Width: | Height: | Size: 728 B |
|
Before Width: | Height: | Size: 636 B After Width: | Height: | Size: 601 B |
|
Before Width: | Height: | Size: 835 B After Width: | Height: | Size: 806 B |
|
Before Width: | Height: | Size: 833 B After Width: | Height: | Size: 808 B |
|
Before Width: | Height: | Size: 857 B After Width: | Height: | Size: 835 B |
|
Before Width: | Height: | Size: 691 B After Width: | Height: | Size: 669 B |
|
Before Width: | Height: | Size: 736 B After Width: | Height: | Size: 706 B |
|
Before Width: | Height: | Size: 819 B After Width: | Height: | Size: 790 B |
|
Before Width: | Height: | Size: 773 B After Width: | Height: | Size: 690 B |
|
Before Width: | Height: | Size: 982 B After Width: | Height: | Size: 973 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1.0 KiB |
|
After Width: | Height: | Size: 1015 B |
BIN
gtk-nsis-pack/share/icons/Adwaita/22x22/devices/ebook-reader.png
Normal file
|
After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 306 B |
BIN
gtk-nsis-pack/share/icons/Adwaita/22x22/emotes/emote-love.png
Normal file
|
After Width: | Height: | Size: 941 B |
|
After Width: | Height: | Size: 1.3 KiB |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 979 B |
|
Before Width: | Height: | Size: 1019 B After Width: | Height: | Size: 959 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 995 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.1 KiB |
|
Before Width: | Height: | Size: 1016 B After Width: | Height: | Size: 991 B |
|
Before Width: | Height: | Size: 1002 B After Width: | Height: | Size: 939 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1007 B |
|
Before Width: | Height: | Size: 988 B After Width: | Height: | Size: 925 B |
|
Before Width: | Height: | Size: 992 B After Width: | Height: | Size: 927 B |
|
Before Width: | Height: | Size: 834 B After Width: | Height: | Size: 778 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1014 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 870 B After Width: | Height: | Size: 853 B |
|
Before Width: | Height: | Size: 1001 B After Width: | Height: | Size: 975 B |
|
Before Width: | Height: | Size: 1.2 KiB After Width: | Height: | Size: 1.1 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 961 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1023 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.1 KiB |
BIN
gtk-nsis-pack/share/icons/Adwaita/24x24/devices/ebook-reader.png
Normal file
|
After Width: | Height: | Size: 1017 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 303 B |
|
After Width: | Height: | Size: 1.3 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1009 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 985 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.1 KiB |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1011 B After Width: | Height: | Size: 952 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1018 B After Width: | Height: | Size: 958 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 959 B |
|
Before Width: | Height: | Size: 868 B After Width: | Height: | Size: 811 B |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1.0 KiB |
|
Before Width: | Height: | Size: 1.1 KiB After Width: | Height: | Size: 1.1 KiB |
|
Before Width: | Height: | Size: 928 B After Width: | Height: | Size: 904 B |
|
Before Width: | Height: | Size: 1.0 KiB After Width: | Height: | Size: 1012 B |
|
Before Width: | Height: | Size: 1.2 KiB After Width: | Height: | Size: 1.2 KiB |
|
Before Width: | Height: | Size: 1.2 KiB After Width: | Height: | Size: 977 B |
|
Before Width: | Height: | Size: 44 KiB After Width: | Height: | Size: 38 KiB |
|
Before Width: | Height: | Size: 53 KiB After Width: | Height: | Size: 44 KiB |
|
After Width: | Height: | Size: 43 KiB |
BIN
gtk-nsis-pack/share/icons/Adwaita/256x256/emotes/emote-love.png
Normal file
|
After Width: | Height: | Size: 28 KiB |
|
After Width: | Height: | Size: 40 KiB |
|
Before Width: | Height: | Size: 48 KiB After Width: | Height: | Size: 37 KiB |
|
Before Width: | Height: | Size: 48 KiB After Width: | Height: | Size: 38 KiB |
|
Before Width: | Height: | Size: 48 KiB After Width: | Height: | Size: 37 KiB |
|
Before Width: | Height: | Size: 50 KiB After Width: | Height: | Size: 39 KiB |