Gnome Tweak이 하는 일 추적하기

# Gtk.Box를 상속한다. Gtk는 UI를 커스터마이징하기 위해서 상속을 사용한다.
class AdditionalLayoutButton(Gtk.Box, Tweak):

    def __init__(self):
        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL, spacing=18,
                               valign=Gtk.Align.CENTER)
        Tweak.__init__(self, "extensions", "")

        # 버튼을 만든다.
        btn = Gtk.Button(label=_("Additional Layout Options"),halign=Gtk.Align.END)
        # 버튼이 눌렸을 때 이벤트를 등록한다.
        btn.connect("clicked", self._on_browse_clicked)
        # Box안에 버튼을 넣는다.
        self.add(btn)

        self.show_all()

def _on_browse_clicked(self, btn):
    # dialog를 만든다.
    dialog = Gtk.Window()
    dialog.set_title(_("Additional Layout Options"))
    dialog.set_type_hint(Gdk.WindowTypeHint.DIALOG)
    dialog.set_transient_for(self.main_window)
    dialog.set_modal(True)

    dialog.set_size_request(500,500)
    geometry = Gdk.Geometry()
    geometry.max_height = 500
    dialog.set_geometry_hints(None, geometry, Gdk.WindowHints.MAX_SIZE)

    # ScrolledWindow를 만든다.
    scrolled_window = Gtk.ScrolledWindow()
    scrolled_window.set_border_width(10)
    # ScrolledWindow안에 TypingTweakGroup을 만든다.
    box = TypingTweakGroup()
    scrolled_window.add_with_viewport(box)

    dialog.add(scrolled_window)
    dialog.show_all()

class TypingTweakGroup(Gtk.Box):
    # ...
    def __init__(self):
        Gtk.Box.__init__(self, orientation=Gtk.Orientation.VERTICAL, spacing=3)
        self._option_objects = []
        ok = False
        try:
            # ...
        except GSettingsMissingError:
            # ...
        except AttributeError:
            # ...
        finally:
            if ok:
                # 모든 옵션을 돌면서
                for opt in set(self._xkb_info.get_all_option_groups()) - self.XKB_OPTIONS_BLACKLIST:
                    # _XkbOption 인스턴스를 만들고,
                    obj = _XkbOption(opt, self._kbdsettings, self._xkb_info)
                    self._option_objects.append(obj)
                    # 인스턴스를 self(box)에 넣는다.
                    self.pack_start(obj, False, False, 0)
        # ...

# Gtk.Expander를 상속한다.
class _XkbOption(Gtk.Expander, Tweak):
    def __init__(self, group_id, parent_settings, xkb_info, **options):
        # ...
        Gtk.Expander.__init__(self)
        Tweak.__init__(self, desc, desc, **options)

        self.set_label(self.name)
        vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=3)
        vbox.set_margin_start(15)
        self.add(vbox)

        # ...

        model_values = []

        # ...

        # group에 있는 모든 옵션을 돌면서
        for option_id in self._xkb_info.get_options_for_group(group_id):
            desc = self._xkb_info.description_for_option(group_id, option_id)
            # model_values 변수를 채운다.
            model_values.append((option_id, desc))
            self._possible_values.append(option_id)

        # ...

        model_values.sort(key=values_cmp_py3_wrap(values_cmp))

        self._widgets = dict()
        for (val, name) in model_values:
            w = None
            # 옵션의 특징에 따라서
            if self._multiple_selection:
                # 체크박스를 만들거나
                w = Gtk.CheckButton.new()
            else:
                # 라디오버튼을 만든다.
                w = Gtk.RadioButton.new_from_widget(self._widgets.get(None))
            self._widgets[val] = w;
            vbox.add(w)
            l = Gtk.Label(label=name)
            l.set_line_wrap(True)
            w.add(l)
            # 옵션이 수정되었을 때 self._on_toggled가 호출된다.
            w._changed_id = w.connect('toggled', self._on_toggled)
            w._val = val

        self.widget_for_size_group = None
        self.reload()


    # 옵션이 변경되었을 때 호출된다.
    def _on_toggled(self, w):
        active = w.get_active()
        if not self._multiple_selection and active:
            for v in self._values:
                # 옵션을 리스트에서 없앤다.
                self._parent_settings.setting_remove_from_list(TypingTweakGroup.XKB_GSETTINGS_NAME, v)

        if w._val in self._values and not active:
            # 옵션을 리스트에서 없앤다.
            self._parent_settings.setting_remove_from_list(TypingTweakGroup.XKB_GSETTINGS_NAME, w._val)
        elif active and not w._val in self._values and w._val:
            # 옵션을 리스트에 추가한다.
            self._parent_settings.setting_add_to_list(TypingTweakGroup.XKB_GSETTINGS_NAME, w._val)

    def setting_add_to_list(self, key, value):
        """ helper function, ensures value is present in the GSettingsList at key """
        assert self._setting_check_is_list(key)

        vals = self[key]
        if value not in vals:
            vals.append(value)
            self[key] = vals
            return True

    def setting_remove_from_list(self, key, value):
        """ helper function, removes value in the GSettingsList at key (if present)"""
        assert self._setting_check_is_list(key)

        vals = self[key]
        try:
            vals.remove(value)
            self[key] = vals
            return True
        except ValueError:
            # not present
            pass

class Settings(Gio.Settings):
    '''Provide dictionary-like access to GLib.Settings.'''

    __init__ = deprecated_init(Gio.Settings.__init__,
                               arg_names=('schema', 'path', 'backend'))

    def __contains__(self, key):
        return key in self.list_keys()

    def __len__(self):
        return len(self.list_keys())

    def __iter__(self):
        for key in self.list_keys():
            yield key

    # ...

    def __setitem__(self, key, value):
        # set_value() aborts the program on an unknown key
        if key not in self:
            raise KeyError('unknown key: %r' % (key,))

        # ...
        if type_ == 'type':
            # ...
        elif type_ == 'enum':
            # ...
        elif type_ == 'range':
            # ...
        else:
            raise NotImplementedError('Cannot handle allowed type range class ' + str(type_))

        # C로 짜여진 gio의 g_settings_set_value 함수를 호출한다.
        self.set_value(key, GLib.Variant(type_str, value))

import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk

window = Gtk.Window(title="Hello World")
window.show()
window.connect("destroy", Gtk.main_quit)
Gtk.main()

# gi/repository/__init__.py 파일
from ..importer import DynamicImporter

# sys.meta_path에 DynamicImporter를 추가한다.
sys.meta_path.append(DynamicImporter('gi.repository'))

class DynamicImporter(object):

    # Note: see PEP302 for the Importer Protocol implemented below.
    # ...

    def load_module(self, fullname):
        if fullname in sys.modules:
            return sys.modules[fullname]
        # ...
        with _check_require_version(namespace, stacklevel=stacklevel):
            try:
                # get_introspection_module 함수가 introspection에서 모듈을 생성한다.
                introspection_module = get_introspection_module(namespace)
            except RepositoryError as e:
                raise ImportError(e)
            # Import all dependencies first so their init functions
            # (gdk_init, ..) in overrides get called.
            # https://bugzilla.gnome.org/show_bug.cgi?id=656314
            for dep in repository.get_immediate_dependencies(namespace):
                importlib.import_module('gi.repository.' + dep.split("-")[0])
            dynamic_module = load_overrides(introspection_module)

        dynamic_module.__file__ = '<%s>' % fullname
        dynamic_module.__loader__ = self
        sys.modules[fullname] = dynamic_module

        return dynamic_module

class IntrospectionModule(object):
    """An object which wraps an introspection typelib.

    This wrapping creates a python module like representation of the typelib
    using gi repository as a foundation. Accessing attributes of the module
    will dynamically pull them in and create wrappers for the members.
    These members are then cached on this introspection module.
    """

    # ...
    def __getattr__(self, name):
        # repository.find_by_name은 pygi-repository.c의_wrap_g_irepository_find_by_name를 부른다.
        info = repository.find_by_name(self._namespace, name)
        if not info:
            raise AttributeError("%r object has no attribute %r" % (
                                 self.__name__, name))

        # 이 뒤로는 info의 값에 맞게 Python Object를 만드는 과정이다.
        if isinstance(info, EnumInfo):
            g_type = info.get_g_type()
            wrapper = g_type.pytype

            if wrapper is None:
                # ...

                wrapper.__info__ = info
                wrapper.__module__ = 'gi.repository.' + info.get_namespace()
                # ...
                for value_info in info.get_values():
                    value_name = value_info.get_name_unescaped().translate(ascii_upper_trans)
                    setattr(wrapper, value_name, wrapper(value_info.get_value()))
                for method_info in info.get_methods():
                    setattr(wrapper, method_info.__name__, method_info)

            if g_type != TYPE_NONE:
                g_type.pytype = wrapper

        elif isinstance(info, RegisteredTypeInfo):
            # ...
        elif isinstance(info, FunctionInfo):
            wrapper = info
        elif isinstance(info, ConstantInfo):
            wrapper = info.get_value()
        else:
            raise NotImplementedError(info)

        # Cache the newly created wrapper which will then be
        # available directly on this introspection module instead of being
        # lazily constructed through the __getattr__ we are currently in.
        self.__dict__[name] = wrapper
        return wrapper

class TypingTweakGroup(Gtk.Box):

    XKB_GSETTINGS_SCHEMA = "org.gnome.desktop.input-sources"
    XKB_GSETTINGS_NAME = "xkb-options"

    # ...