← Back to branch summary

~ubuntu-branches/ubuntu/natty/landscape-client/natty-updates

« back to all changes in this revision

Viewing changes to landscape/ui/view/configuration.py

  • Committer: Package Import Robot
  • Author(s): Andreas Hasenack
  • Date: 2012-03-19 09:33:34 UTC
  • mto: (1.2.10)
  • mto: This revision was merged to the branch mainline in revision 39.
  • Revision ID: package-import@ubuntu.com-20120319093334-oxjttz163vvfgq8s
Import upstream version 12.04

Show diffs side-by-side

added added

removed removed

Lines of Context:
landscape/ui/view/configuration.py
 
1
import os
 
2
 
 
3
from gi.repository import GObject, Gtk
 
4
 
 
5
from landscape.ui.constants import (
 
6
    CANONICAL_MANAGED, LOCAL_MANAGED, NOT_MANAGED)
 
7
 
 
8
 
 
9
class ClientSettingsDialog(Gtk.Dialog):
 
10
    """
 
11
    L{ClientSettingsDialog} is a subclass of Gtk.Dialog that loads the UI
 
12
    components from the associated Glade XML file and wires everything up to
 
13
    the controller.
 
14
    """
 
15
 
 
16
    GLADE_FILE = "landscape-client-settings.glade"
 
17
    NO_SERVICE_TEXT = "None"
 
18
    HOSTED_SERVICE_TEXT = "Landscape - hosted by Canonical"
 
19
    LOCAL_SERVICE_TEXT = "Landscape - dedicated server"
 
20
    REGISTER_BUTTON_TEXT = "Register"
 
21
    DISABLE_BUTTON_TEXT = "Disable"
 
22
 
 
23
    def __init__(self, controller):
 
24
        super(ClientSettingsDialog, self).__init__(
 
25
            title="Management Service",
 
26
            flags=Gtk.DialogFlags.MODAL)
 
27
        self.set_default_icon_name("preferences-management-service")
 
28
        self.set_resizable(False)
 
29
        self._initialised = False
 
30
        self.controller = controller
 
31
        self.setup_ui()
 
32
        self.load_data()
 
33
        # One extra revert to reset after loading data
 
34
        self.controller.revert()
 
35
 
 
36
    def _set_use_type_combobox_from_controller(self):
 
37
        """
 
38
        Load the persisted L{management_type} from the controller and set the
 
39
        combobox appropriately.
 
40
 
 
41
        Note that Gtk makes us jump through some hoops by having it's own model
 
42
        level to deal with here.  The conversion between paths and iters makes
 
43
        more sense if you understand that treeviews use the same model.
 
44
        """
 
45
        list_iter = self.liststore.get_iter_first()
 
46
        while (self.liststore.get(list_iter, 0)[0] !=
 
47
               self.controller.management_type):
 
48
            list_iter = self.liststore.iter_next(list_iter)
 
49
        path = self.liststore.get_path(list_iter)
 
50
        [index] = path.get_indices()
 
51
        self.use_type_combobox.set_active(index)
 
52
 
 
53
    def _set_hosted_values_from_controller(self):
 
54
        self.hosted_account_name_entry.set_text(
 
55
            self.controller.hosted_account_name)
 
56
        self.hosted_password_entry.set_text(self.controller.hosted_password)
 
57
 
 
58
    def _set_local_values_from_controller(self):
 
59
        self.local_landscape_host_entry.set_text(
 
60
            self.controller.local_landscape_host)
 
61
        self.local_password_entry.set_text(self.controller.local_password)
 
62
 
 
63
    def load_data(self):
 
64
        self._initialised = False
 
65
        self.controller.load()
 
66
        self._set_hosted_values_from_controller()
 
67
        self._set_local_values_from_controller()
 
68
        self._set_use_type_combobox_from_controller()
 
69
        self._initialised = True
 
70
 
 
71
    def make_liststore(self):
 
72
        """
 
73
        Construct the correct L{Gtk.ListStore} to drive the L{Gtk.ComboBox} for
 
74
        use-type.  This a table of:
 
75
 
 
76
           * Management type (key)
 
77
           * Text to display in the combobox
 
78
           * L{Gtk.Frame} to load when this item is selected.
 
79
        """
 
80
        liststore = Gtk.ListStore(GObject.TYPE_PYOBJECT,
 
81
                                  GObject.TYPE_STRING,
 
82
                                  GObject.TYPE_PYOBJECT)
 
83
        self.active_widget = None
 
84
        liststore.append([NOT_MANAGED, self.NO_SERVICE_TEXT,
 
85
                          self._builder.get_object("no-service-frame")])
 
86
        liststore.append([CANONICAL_MANAGED, self.HOSTED_SERVICE_TEXT,
 
87
                          self._builder.get_object("hosted-service-frame")])
 
88
        liststore.append([LOCAL_MANAGED, self.LOCAL_SERVICE_TEXT,
 
89
                          self._builder.get_object("local-service-frame")])
 
90
        return liststore
 
91
 
 
92
    def link_hosted_service_widgets(self):
 
93
        self.hosted_account_name_entry = self._builder.get_object(
 
94
            "hosted-account-name-entry")
 
95
        self.hosted_account_name_entry.connect(
 
96
            "changed", self.on_changed_event, "hosted_account_name")
 
97
 
 
98
        self.hosted_password_entry = self._builder.get_object(
 
99
            "hosted-password-entry")
 
100
        self.hosted_password_entry.connect(
 
101
            "changed", self.on_changed_event, "hosted_password")
 
102
 
 
103
    def link_local_service_widgets(self):
 
104
        self.local_landscape_host_entry = self._builder.get_object(
 
105
            "local-landscape-host-entry")
 
106
        self.local_landscape_host_entry.connect(
 
107
            "changed", self.on_changed_event, "local_landscape_host")
 
108
 
 
109
        self.local_password_entry = self._builder.get_object(
 
110
            "local-password-entry")
 
111
        self.local_password_entry.connect(
 
112
            "changed", self.on_changed_event, "local_password")
 
113
 
 
114
    def link_use_type_combobox(self, liststore):
 
115
        self.use_type_combobox = self._builder.get_object("use-type-combobox")
 
116
        self.use_type_combobox.connect("changed", self.on_combo_changed)
 
117
        self.use_type_combobox.set_model(liststore)
 
118
        cell = Gtk.CellRendererText()
 
119
        self.use_type_combobox.pack_start(cell, True)
 
120
        self.use_type_combobox.add_attribute(cell, 'text', 1)
 
121
 
 
122
    def cancel_response(self, widget):
 
123
        self.response(Gtk.ResponseType.CANCEL)
 
124
 
 
125
    def register_response(self, widget):
 
126
        self.response(Gtk.ResponseType.OK)
 
127
 
 
128
    def set_button_text(self, management_type):
 
129
        [alignment] = self.register_button.get_children()
 
130
        [hbox] = alignment.get_children()
 
131
        [image, label] = hbox.get_children()
 
132
        if management_type == NOT_MANAGED:
 
133
            label.set_text(self.DISABLE_BUTTON_TEXT)
 
134
        else:
 
135
            label.set_text(self.REGISTER_BUTTON_TEXT)
 
136
 
 
137
    def setup_buttons(self):
 
138
        self.revert_button = Gtk.Button(stock=Gtk.STOCK_REVERT_TO_SAVED)
 
139
        self.action_area.pack_start(self.revert_button, True, True, 0)
 
140
        self.revert_button.connect("clicked", self.revert)
 
141
        self.revert_button.show()
 
142
        self.cancel_button = Gtk.Button(stock=Gtk.STOCK_CANCEL)
 
143
        self.action_area.pack_start(self.cancel_button, True, True, 0)
 
144
        self.cancel_button.show()
 
145
        self.cancel_button.connect("clicked", self.cancel_response)
 
146
        self.register_button = Gtk.Button(stock=Gtk.STOCK_OK)
 
147
        self.action_area.pack_start(self.register_button, True, True, 0)
 
148
        self.register_button.show()
 
149
        self.register_button.connect("clicked", self.register_response)
 
150
 
 
151
    def setup_ui(self):
 
152
        self._builder = Gtk.Builder()
 
153
        self._builder.add_from_file(
 
154
            os.path.join(
 
155
                os.path.dirname(__file__), "ui", self.GLADE_FILE))
 
156
        content_area = self.get_content_area()
 
157
        content_area.set_spacing(12)
 
158
        self.set_border_width(12)
 
159
        self._vbox = self._builder.get_object("toplevel-vbox")
 
160
        self._vbox.unparent()
 
161
        content_area.pack_start(self._vbox, expand=True, fill=True, padding=12)
 
162
        self.liststore = self.make_liststore()
 
163
        self.link_use_type_combobox(self.liststore)
 
164
        self.link_hosted_service_widgets()
 
165
        self.link_local_service_widgets()
 
166
        self.setup_buttons()
 
167
 
 
168
    def on_combo_changed(self, combobox):
 
169
        list_iter = self.liststore.get_iter(combobox.get_active())
 
170
        if not self.active_widget is None:
 
171
            self._vbox.remove(self.active_widget)
 
172
        [management_type] = self.liststore.get(list_iter, 0)
 
173
        self.set_button_text(management_type)
 
174
        if self._initialised:
 
175
            self.controller.management_type = management_type
 
176
            self.controller.modify()
 
177
        [self.active_widget] = self.liststore.get(list_iter, 2)
 
178
        self.active_widget.unparent()
 
179
        self._vbox.add(self.active_widget)
 
180
 
 
181
    def on_changed_event(self, widget, attribute):
 
182
        setattr(self.controller, attribute, widget.get_text())
 
183
        self.controller.modify()
 
184
 
 
185
    def quit(self, *args):
 
186
        self.destroy()
 
187
 
 
188
    def revert(self, button):
 
189
        self.controller.revert()
 
190
        self.load_data()
 
191
        # One extra revert to reset after loading data
 
192
        self.controller.revert()