def __init__(self, start_sub='/r/all'):
        Gtk.Window.__init__(self, title='Reddit is Gtk+',
                            icon_name='reddit-is-a-dead-bird')
        self.add_events(Gdk.EventMask.KEY_PRESS_MASK)

        self.set_default_size(600, 600)
        screen = Gdk.Screen.get_default()
        css_provider = Gtk.CssProvider.get_default()
        css_provider.load_from_resource('/today/sam/reddit-is-gtk/style.css')
        context = Gtk.StyleContext()
        context.add_provider_for_screen(screen, css_provider,
                                        Gtk.STYLE_PROVIDER_PRIORITY_USER)


        self._paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
        self.add(self._paned)
        self._paned.show()

        self._webview = FullscreenableWebview()
        self._webview_bin = ProgressContainer(self._webview)
        self._comments = None
        self._stack = Gtk.Stack()
        self._stack.connect('notify::visible-child', self.__stack_child_cb)
        self._paned.add2(self._stack)
        self._stack.show()

        self._make_header()

        self._sublist = SubList()
        self._sublist.new_other_pane.connect(self.__new_other_pane_cb)
        self._paned.add1(self._sublist)
        self._sublist.show()
        self._sublist.goto(start_sub)

        get_reddit_api().request_failed.connect(self.__request_failed_cb)

    def __toggled_cb(self, toggle):
        self._set_label()
        self._button.props.sensitive = False

        get_reddit_api().set_subscribed(self._subreddit_name,
                                        self._button.props.active,
                                        self.__subscribe_cb)

    def __message_done_cb(self, session, msg, user_data):
        id, callback = user_data

        data = msg.props.response_body.data
        if id not in self._tokens:
            self._tokens[id] = {}
        if data is None:
            # TODO:  Show this error to the user
            print('Token refresh failed')
            from redditisgtk.api import describe_soup_transport_error
            print(data,
                  msg.props.status_code,
                  describe_soup_transport_error(msg.props.status_code, msg))
            return

        # We must keep some things we only get the 1st time, eg.
        # the refresh token
        self._tokens[id].update(json.loads(data))
        self._tokens[id]['time'] = time.time()

        self.save()
        self.token_changed.emit(self._tokens[id])
        self.sign_in_status.emit('', True)

        if callback is not None:
            callback()

        if 'username' not in self._tokens[id]:
            # api imports us, so we must wait to import them
            from redditisgtk.api import get_reddit_api
            get_reddit_api().send_request(
                'GET', '/api/v1/me', self.__whoami_cb, user_data=id)

 def read_toggled_cb(self, toggle):
     if toggle.props.active:
         get_reddit_api().read_message(self.data['name'])
         self._read.get_style_context().remove_class('unread')
         self._read.props.active = True
         self._read.props.sensitive = False
         self._read.props.label = 'Read'

    def __subscribe_toggled_cb(self, toggle):
        self._subscribe.props.label = 'Subscribing...'  \
            if self._subscribe.props.active else 'Unsubscribing...'
        self._subscribe.props.sensitive = False

        get_reddit_api().set_subscribed(self._subreddit_name,
                                        self._subscribe.props.active,
                                        self.__subscribe_cb)

    def __init__(self, parent, **kwargs):
        VScrollingPopover.__init__(self, **kwargs)
        self._parent = parent

        get_reddit_api().subs_changed.connect(self.__changed_cb)
        get_reddit_api().user_changed.connect(self.__changed_cb)
        self._parent.connect('activate', self.__changed_cb)
        self._rebuild()

    def __init__(self, parent, **kwargs):
        VScrollingPopover.__init__(self, **kwargs)
        self.get_style_context().add_class('subentry-palette')
        self._parent = parent
        self._filter = None

        get_reddit_api().subs_changed.connect(self.__changed_cb)
        get_reddit_api().user_changed.connect(self.__changed_cb)
        self._rebuild()

    def __init__(self, uri):
        Gtk.Bin.__init__(self)

        self._spinner = Gtk.Spinner()
        self.add(self._spinner)
        self._spinner.show()

        self._image = Gtk.Image()
        self.add(self._image)
        get_reddit_api().download_thumb(uri, self.__message_done_cb)

    def __init__(self, start_sub=None):
        Gtk.Window.__init__(self, title='Something For Reddit',
                            icon_name='reddit-is-a-dead-bird')
        self.add_events(Gdk.EventMask.KEY_PRESS_MASK)
        self.set_default_size(600, 600)
        self.set_wmclass("reddit-is-gtk", "Something For Reddit")

        settings = Gtk.Settings.get_default()
        screen = Gdk.Screen.get_default()
        css_provider = Gtk.CssProvider.get_default()
        if settings.props.gtk_application_prefer_dark_theme:
            css_provider.load_from_resource(
                '/today/sam/reddit-is-gtk/style.dark.css')
        else:
            css_provider.load_from_resource(
                '/today/sam/reddit-is-gtk/style.css')
        context = Gtk.StyleContext()
        context.add_provider_for_screen(screen, css_provider,
                                        Gtk.STYLE_PROVIDER_PRIORITY_USER)

        self._paned = Gtk.Paned.new(Gtk.Orientation.HORIZONTAL)
        self.add(self._paned)
        self._paned.show()

        self._webview = FullscreenableWebview()
        self._webview_bin = ProgressContainer(self._webview)
        self._comments = None
        self._stack = Gtk.Stack()
        self._stack.connect('notify::visible-child', self.__stack_child_cb)
        self._paned.add2(self._stack)
        #self._paned.child_set_property(self._stack, 'shrink', True)
        self._stack.show()

        if start_sub is None:
            start_sub = get_settings()['default-sub']
        self._sublist = SubList()
        self._sublist.new_other_pane.connect(self.__new_other_pane_cb)
        self._paned.add1(self._sublist)
        #self._paned.child_set_property(self._sublist, 'shrink', True)
        self._sublist.show()
        self._sublist.goto(start_sub)

        self._make_header(start_sub)
        left = Gtk.SizeGroup(mode=Gtk.SizeGroupMode.HORIZONTAL)
        left.add_widget(self._left_header)
        left.add_widget(self._sublist)
        self._paned.connect('notify::position',
                            self.__notify_position_cb,
                            self._header_paned)
        self._header_paned.connect('notify::position',
                                   self.__notify_position_cb,
                                   self._paned)

        get_reddit_api().request_failed.connect(self.__request_failed_cb)

    def __row_selected_cb(self, listbox, row):
        if row is None:
            return

        row.get_style_context().add_class('read')
        if 'context' in row.data:
            # We need to download first
            # TODO: Progress indicator for user
            get_reddit_api().get_list(row.data['context'],
                                      self.__got_context_list_cb)
        else:
            self._handle_activate(row.data)

 def goto(self, sub):
     '''
     Sub could be '/r/gnu+linux' or '/r/rct/hot?t=month
     or even '/message/inbox'
     '''
     if self._msg is not None:
         get_reddit_api().cancel(self._msg)
     self._sub = sub
     self.remove(self.get_child())
     self.add(self._spinner)
     self._spinner.show()
     self._spinner.start()
     self._msg = get_reddit_api().get_list(sub, self.__got_list_cb)

    def __init__(self, subreddit_name, **kwargs):
        '''
        Args:
            subreddit_name (str):  name like 'linux' or 'gnu',
                NOT with the /r/
        '''
        VScrollingPopover.__init__(self, **kwargs)
        spinner = Gtk.Spinner()
        self.set_scrolled_child(spinner)
        spinner.show()

        self._subreddit_name = subreddit_name
        get_reddit_api().get_subreddit_info(subreddit_name, self.__got_info_cb)

    def __init__(self, name):
        Gtk.ListBoxRow.__init__(self, selectable=False)

        self._name = name

        self._builder = Gtk.Builder.new_from_resource(
            '/today/sam/reddit-is-gtk/user-about.ui')
        self._g = self._builder.get_object

        self.add(self._g('box'))
        self._g('name').props.label = self._name

        get_reddit_api().get_user_info(
            self._name, self.__got_info_cb)

    def _call_access_token(self, data, id, callback=None):
        msg = Soup.Message.new(
            'POST', 'https://www.reddit.com/api/v1/access_token')
        msg.props.priority = Soup.MessagePriority.VERY_HIGH
        body = urllib.parse.urlencode(data)
        msg.set_request(
            'application/x-www-form-urlencoded',
            Soup.MemoryUse.COPY, bytes(body, 'utf8'))
        msg.props.request_headers.append(
            'Authorization', 'Basic V0NOM2pxb0oxLTByMFE6Cg==')

        # api imports us, so we must wait to import them
        from redditisgtk.api import get_reddit_api
        get_reddit_api().session.queue_message(
            msg, self.__message_done_cb, (id, callback))

    def __request_failed_cb(self, api, msg, info):
        dialog = Gtk.Dialog(use_header_bar=True)
        label = Gtk.Label(label=info)
        dialog.get_content_area().add(label)
        label.show()

        dialog.add_button('Retry', Gtk.ResponseType.ACCEPT)
        dialog.add_button(':shrug-shoulders:', Gtk.ResponseType.REJECT)
        dialog.set_default_response(Gtk.ResponseType.ACCEPT)

        dialog.props.transient_for = self
        response = dialog.run()
        if response == Gtk.ResponseType.ACCEPT:
            get_reddit_api().resend_message(msg)
        dialog.destroy()

 def __submit_clicked_cb(self, button):
     submit = self._b.get_object('submit-button')
     submit.props.label = 'Submitting...'
     submit.props.sensitive = False
     
     data = {'title': self._b.get_object('title-entry').props.text,
             'sr': self._b.get_object('sub-entry').props.text}
     stack = self._b.get_object('link-self-stack')
     if stack.props.visible_child_name == 'link':
         data['kind'] = 'link'
         data['url'] = self._b.get_object('link-entry').props.text
     else:
         data['kind'] = 'link'
         buf = self._b.get_object('self-textview').props.buffer
         data['text'] = buf.get_text(buf.get_start_iter(),
                                     buf.get_end_iter(), False)
     get_reddit_api().submit(data, self.__submit_done_cb)

    def __init__(self, button: Gtk.Widget, subreddit_name: str):
        self._button = button
        self._subreddit_name = subreddit_name

        self._button.props.active = \
            '/r/{}/'.format(subreddit_name.lower()) \
            in get_reddit_api().lower_user_subs
        self._button.connect('toggled', self.__toggled_cb)
        self._set_label()

    def vote(self, direction):
        get_reddit_api().vote(self._data['name'], direction)

        new_score = self._data['score'] + direction
        if self._data['likes'] is True:
            new_score -= 1  # Undo the previous like
        elif self._data['likes'] is False:
            new_score += 1
        if direction == 0:
            likes = None
        elif direction == +1:
            likes = True
        elif direction == -1:
            likes = False

        self._data['likes'] = likes
        self._data['score'] = new_score
        self._update_score_button()

    def _rebuild(self):
        self._box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
        self.set_scrolled_child(self._box)
        self._box.show()

        self._add_subs(self._do_filter(PREPEND_SUBS))

        # Only show suggestions if it is /r/aaa, not /r/aaa/sort
        if self._filter and len(self._filter.split('/')) == 3:
            subs = list(self._do_filter(get_reddit_api().user_subs))
            if subs:
                self._add_header('Searching Subscribed')
                self._add_subs(subs)

        sub = self._filter or self._parent.get_real_sub() or ''
        if sub.startswith('/r/'):
            by_slash = sub.split('/')
            name = by_slash[2]  # get the /r/[thing]/whatever part
            if len(by_slash) == 4:  # /r/subreddit/top?=whatever
                sort = by_slash[3]
                if '?' in sort and len(sort.split('?')) == 2:
                    type, time = sort.split('?')
                    self._add_header('Sorting Times')
                    self._add_subs(('/r/{}/{}?t={}'.format(name, type, x)
                                    for x in SORTING_TIMES))

            self._add_header('Sorting')
            self._add_subs(('/r/{}/{}'.format(name, x) for x in SORTINGS))

        if not self._filter:
            self._add_header('Subscribed')
            self._add_subs(get_reddit_api().user_subs)

        user_name = None
        if self._filter is not None:
            if self._filter.startswith('/user'):
                user_name = self._filter.split('/')[2]
        else:
            user_name = get_reddit_api().user_name

        if user_name is not None:
            self._add_header('Profile')
            self._add_subs((x.replace('USER', user_name)
                           for x in SPECIAL_SUBS))

    def __vote_toggled_cb(self, toggle, direction):
        if toggle.props.active:
            get_reddit_api().vote(self.data['name'], direction)

            new_score = self.data['score'] + direction
            if self.data['likes'] == True:
                new_score -= 1  # Undo the previous like
            elif self.data['likes'] == False:
                new_score += 1
            if direction == 0:
                likes = None
            elif direction == +1:
                likes = True
            elif direction == -1:
                likes = False

            self.data['likes'] = likes
            self.data['score'] = new_score
            self._update_score_button()