With lockdown settings available through GSettings, widgets can handle
lockdown integration themselves without having to use EShellSettings.
Also fixed a few places where printing or save-to-disk actions were
either not properly wired up or not responding to lockdown settings,
but much more work needs done. Attachments, for example, are not
honoring the disable-save-to-disk setting at all.
This too requires the recently-added gsettings-desktop-schemas
dependency.
An easy way to broadcast application-wide alerts to shell windows.
These alerts will persist in all current and future shell windows
until responded to (either programmatically or by the user).
This is just for convenience, EActivity does not use this property.
Especially useful in async function callbacks when the operation
failed and now you have to do something useful with the GError.
With unintrusive error dialogs gone, we can cut some unnecessary bits
out of EActivity.
I'm also adding a new enum property called "state", which is one of:
E_ACTIVITY_RUNNING
E_ACTIVITY_WAITING
E_ACTIVITY_CANCELLED
E_ACTIVITY_COMPLETED
The state of an activity must be explicitly changed. In particular,
when the user cancels an activity the state should be set only after
confirming the operation has been cancelled and not when cancellation
is requested (e.g. after receiving a G_IO_ERROR_CANCELLED, not when
the GCancellable emits "cancelled"). EActivityBar and EActivityProxy
widgets have been updated to make this distinction clearer in the UI.
E_ACTIVITY_WAITING will be used when activities have to be queued and
dispatched in sequence, which I haven't written yet.
This marks the end of unintrusive error dialogs, which were too
unintrusive. We now show errors directly in the main window using
the EAlert / EAlertSink framework.
You can now amend the predefined actions in an EAlert by calling
e_alert_add_action(). Useful for adding actions from an existing
GtkUIManager.
Call e_alert_peek_actions() to obtain a combined list of predefined
and custom actions. These will typically serve as "related" actions
for GtkButtons (cf. gtk_activatable_set_related_action()).
Also, both EShellWindow and EShellView now implement EAlertSink. Use
EShellWindow for application-wide alerts, EShellView for view-specific
alerts.
Listen for "prepare-for-quit" signals from the shell and inhibit
shutdown until all the activities we're tracking are finalized.
Also, add a couple supporting functions:
gboolean e_shell_backend_is_busy (EShellBackend *shell_backend);
void e_shell_backend_cancel_all (EShellBackend *shell_backend);
These will eventually replace mail_msg_active() and mail_cancel_all().
Trying out a new interface called EAlertSink. The idea is to centralize
how errors are shown to the user. A GtkWindow subclass would implement
the EAlertSink interface, which consists of a single method:
void (*submit_alert) (EAlertSink *alert_sink, EAlert *alert);
The subclass has complete control over what to do with the EAlert,
although I imagine we'll wind up implementing various alert-handling
policies as standalone widgets such as EAlertDialog. I'd like to try
an EAlertInfoBar.
Code that would otherwise display an error dialog itself would instead
pass the EAlert to an appropriate EAlertSink and be done with it.
Nothing is final yet. Still hacking on EAlert trying to find an API
that feels right for these use cases.
EActivity now uses a GCancellable to manage cancellations, instead of
having its own redundant cancellation API. API changes are as follows:
+ e_activity_get_cancellable()
+ e_activity_set_cancellable()
- e_activity_cancel()
- e_activity_is_cancelled()
- e_activity_get_allow_cancel()
- e_activity_set_allow_cancel()
EActivity's "cancelled" signal remains, but only as a repeater for
GCancellable::cancelled signals. It should not be emitted directly.
The presence of a GCancellable implies that cancellation is allowed.
EActivity does not create its own default GCancellable, it has to be
given one.
If a CamelOperation (cast as a GCancellable) is given, EActivity will
configure itself to listen for status updates from the CamelOperation
and propagate the information to its own "primary-text" and "percent"
properties.
These changes allowed me to start cleaning up some of the incredibly
convoluted logic in mail-mt.c -- in particular, mail_operation_status()
is completely gone now. mail-mt.c is still in a transitional state --
much more significant changes coming soon.
For express mode:
- Move the search bar up to the toolbar.
- Hide the "filter" combo box and lock down the first item.
- Hide the "scope" combo box and lock down the first item.
(This is the combo box with "Current Folder" only in the mailer.)
- EShellView owns the search bar widget now instead of EShellContent.
- Insert several nasty hacks that will likely come back to bite me.
Introduce e_extensible_list_extensions(), which provides extensible
objects access to their own extensions, or a subset of them.
Convert EShellBackend to an abstract EExtension subtype. EShell will
load its extensions with e_extensible_load_extensions(), and then obtain
a list of EShellBackend extensions as follows:
shell_backends = e_extensible_list_extensions (
E_EXTENSIBLE (shell), E_TYPE_SHELL_BACKEND);
Because EShellBackend is abstract, its GType is skipped while traversing
the GType hierarchy to find EShell extensions.
The mechanism here is simple but hard to explain without leaning heavily
on object-oriented jargon. Consider this a rough draft. Illustrations
would certainly help clarify.
Replace the EVO_EXPRESS environment variable with an --express command
line option. (Note, this adds a new translatable string for --help.)
Add an EUIManager class with an "express-mode" property and custom load
functions that use our new "express" preprocessor. This replaces the UI
manager functions in e-utils.c.
(Also going to see if I can get GTK+ to add an "add_ui_from_string"
method to GtkUIManagerClass that we can override. Then we could just
call gtk_ui_manager_add_ui_from_string() and the preprocessor would
automatically do its thing and chain up.)
Add an "express-mode" read-only GObject property to EShell.
Add e_shell_configure_ui_manager() to e-shell-utils.c. For now this
just creates a one-way property binding:
EShell:express-mode -> EUIManager:express-mode
Call this immediately after e_ui_manager_new(). (EUIManager can't do
this itself because it lives too low in the dependency hierarchy and
doesn't know about EShell.)
The signal uses the name of the newly created shell view as the detail,
so for example "shell-view-created::mail" is emitted when the "mail"
view is created.
Also, add e_shell_window_peek_shell_view() to obtain a shell view if it
exists but without instantiating it.
Using these new tools, teach the templates plugin to wait for the user
to switch to the "mail" view before connecting to its "update-actions"
signal. Previously is was instantiating the "mail" view itself.
Move the search interface to a new widget: EShellSearchbar
The current search rule is now stored in EShellView, and the search
context in EShellViewClass similar to GalViewCollection (since it's
class-specific, not instance-specific).
Also add a couple new signals to EShellView: "clear-search" and
"custom-search" ("custom" refers to an advanced search or a saved
search -- something more complex than a quick search).
Still working out a few kinks. The search entry is clearly trying to
be too many things. We need a different way of indicating that you're
looking at search results. Perhaps a search results banner similar to
Nautilus.
This tells EShell where to look for EModules. Best practice is to
define the directory in your CPPFLAGS and then pass it to EShell at
instantiation time, like so:
Makefile.am:
evolution_CPPFLAGS = \
-DMODULEDIR=\""$(moduledir)"\"
...
main.c:
shell = g_object_new (
E_TYPE_SHELL, "module-directory", MODULEDIR, ...);
So Anjal can override what it needs to for its own purpose.
Also makes the EShellWindow design a little cleaner.
Methods added:
GtkWidget * (*construct_menubar) (EShellWindow *shell_window);
GtkWidget * (*construct_toolbar) (EShellWindow *shell_window);
GtkWidget * (*construct_sidebar) (EShellWindow *shell_window);
GtkWidget * (*construct_content) (EShellWindow *shell_window);
GtkWidget * (*construct_taskbar) (EShellWindow *shell_window);
EShellView * (*create_shell_view) (EShellWindow *shell_window,
const gchar *view_name);
Also added some new GObject properties to help decouple actions from
internal EShellWindow widgets created by these methods:
EShellWindow:sidebar-visible
EShellWindow:switcher-visible
EShellWindow:taskbar-visible
EShellWindow:toolbar-visible
This introduces e-shell-utils for miscellaneous utility functions
that integrate with the shell or shell settings. First function
is e_shell_run_save_dialog(), which automatically remembers the
selected folder in the file chooser dialog.
Also, kill some redundant save dialog functions, as well as some
write-this-string-to-disk functions that block.
This addresses bug #593896 but is also a cleaner design than before.
It introduces an EShellView::execute-search signal and renames the
"search-execute" action to "search-quick" to clarify that it's only
meant for the "quick" search bar in the main window.
Shell view subclasses should implement the execute_search() method to
actually execute a search.
e_shell_view_execute_search() emits the new signal.
