← Back to branch summary

~ubuntu-branches/ubuntu/precise/gnome-do/precise-backports

« back to all changes in this revision

Viewing changes to Do/src/Do.Core/DoAction.cs

  • Committer: Bazaar Package Importer
  • Author(s): Christopher James Halse Rogers, Christopher James Halse Rogers, Iain Lane
  • Date: 2009-02-04 15:30:25 UTC
  • mfrom: (1.1.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20090204153025-dhb2pm7dgbtmoib6
Tags: 0.8.0-1~ubuntu1
https://launchpad.net/bugs/323048
https://launchpad.net/bugs/288517
https://launchpad.net/bugs/294808
https://launchpad.net/bugs/305419
http://bugs.debian.org/510836
http://bugs.debian.org/510973
https://launchpad.net/bugs/291654
[ Christopher James Halse Rogers ]
* New upstream release.  (LP: #323048)
  + Fixes text input problems (LP: #288517)
  + No longer grabs plugins from internet repositories (LP: #294808)
  + Preferences dialog is resizable (LP: #305419)
* Build against gtk, gnome mono packages from Experimental. (Closes: #510836)
* debian/control:
  + Bump versioned dep on libgtk2.0-cil to ensure
    Gdk.Screen.IsComposited exists (Closes: #510973)
  + Add libwnck2.20-cil build-dep
  + gnome-sharp2 transition.
* debian/patches/04_fix_locale_dir
* debian/patches/05_fix_localised_theme_setting
* debian/patches/06_expand_homedir_in_open
  + Drop; fixed in new upstream  
* debian/patches/02_use_cli_for_wrapper
  + Update for new upstream
  + Add dpatch comments
* debian/gnome-do.1
  + Fix broken formatting (LP: #291654).  Thank you to Frédéric Grosshans
    for spotting it, and the patch.
  + Update for new version.

[ Iain Lane ]
* Tag pkg-cli-apps SVN revision into Jaunty, to get in before Feature
  Freeze. Should be a sync after the next Debian upload.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Do/src/Do.Core/DoAction.cs
1
 
/* DoAction.cs
2
 
 *
3
 
 * GNOME Do is the legal property of its developers. Please refer to the
4
 
 * COPYRIGHT file distributed with this
5
 
 * source distribution.
6
 
 *
7
 
 * This program is free software: you can redistribute it and/or modify
8
 
 * it under the terms of the GNU General Public License as published by
9
 
 * the Free Software Foundation, either version 3 of the License, or
10
 
 * (at your option) any later version.
11
 
 *
12
 
 * This program is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 *
17
 
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
19
 
 */
20
 
 
21
 
using System;
22
 
using System.Threading;
23
 
 
24
 
using Do.Universe;
25
 
 
26
 
namespace Do.Core {
27
 
 
28
 
        public class DoAction : DoObject, IAction {
29
 
 
30
 
                public DoAction (IAction action):
31
 
                        base (action)
32
 
                {
33
 
                }
34
 
        
35
 
                public Type [] SupportedItemTypes
36
 
                {
37
 
                        get {
38
 
                                Type [] types = null;
39
 
                                try {
40
 
                                        types = (Inner as IAction).SupportedItemTypes;
41
 
                                } catch (Exception e) {
42
 
                                        LogError ("SupportedItemTypes", e);
43
 
                                } finally {
44
 
                                        types = types ?? Type.EmptyTypes;
45
 
                                }
46
 
                                return types;
47
 
                        }
48
 
                }
49
 
 
50
 
                public Type [] SupportedModifierItemTypes
51
 
                {
52
 
                        get {
53
 
                                Type [] types = null;
54
 
                                try {
55
 
                                        types = (Inner as IAction).SupportedModifierItemTypes;
56
 
                                } catch (Exception e) {
57
 
                                        LogError ("SupportedModifierItemTypes", e);
58
 
                                } finally {
59
 
                                        types = types ?? Type.EmptyTypes;
60
 
                                }
61
 
                                return types;
62
 
                        }
63
 
                }
64
 
                
65
 
                public bool ModifierItemsOptional
66
 
                {
67
 
                        get {
68
 
                                bool optional = true;
69
 
                                try {
70
 
                                        optional = (Inner as IAction).ModifierItemsOptional;
71
 
                                } catch (Exception e) {
72
 
                                        LogError ("ModifierItemsOptional", e);
73
 
                                }
74
 
                                return optional;
75
 
                        }
76
 
                }
77
 
                
78
 
                public IItem [] DynamicModifierItemsForItem (IItem item)
79
 
                {
80
 
                        IAction action = Inner as IAction;
81
 
                        IItem [] modItems;
82
 
                        
83
 
                        modItems = null;
84
 
                        item = EnsureIItem (item);
85
 
                        try {
86
 
                                modItems = action.DynamicModifierItemsForItem (item);
87
 
                        } catch (Exception e) {
88
 
                                LogError ("DynamicModifierItemsForItem", e);
89
 
                        } finally {
90
 
                                modItems = modItems ?? new IItem [0];
91
 
                        }
92
 
                        return EnsureDoItemArray (modItems);
93
 
                }
94
 
 
95
 
                public bool SupportsItem (IItem item)
96
 
                {
97
 
                        IAction action = Inner as IAction;
98
 
                        bool supports = false;
99
 
                        
100
 
                        item = EnsureIItem (item);
101
 
                        if (!IObjectTypeCheck (item, SupportedItemTypes))
102
 
                                return false;
103
 
 
104
 
                        try {
105
 
                                supports = action.SupportsItem (item);
106
 
                        } catch (Exception e) {
107
 
                                LogError ("SupportsItem", e);
108
 
                        }
109
 
                        return supports;
110
 
                }
111
 
 
112
 
                public bool SupportsModifierItemForItems (IItem [] items, IItem modItem)
113
 
                {
114
 
                        IAction action = Inner as IAction;
115
 
                        bool supports = false;
116
 
 
117
 
                        items = EnsureIItemArray (items);
118
 
                        modItem = EnsureIItem (modItem);
119
 
                        if (!IObjectTypeCheck (modItem, SupportedModifierItemTypes))
120
 
                                return false;
121
 
 
122
 
                        try {
123
 
                                supports = action.SupportsModifierItemForItems (items, modItem);
124
 
                        } catch (Exception e) {
125
 
                                LogError ("SupportsModifierItemForItems", e);
126
 
                        }
127
 
                        return supports;
128
 
                }
129
 
 
130
 
                public IItem [] Perform (IItem [] items, IItem [] modItems)
131
 
                {
132
 
                        IAction action = Inner as IAction;
133
 
                        IItem [] resultItems = null;
134
 
                        
135
 
                        items = EnsureIItemArray (items);
136
 
                        modItems = EnsureIItemArray (modItems);
137
 
                        
138
 
                        try {
139
 
                                resultItems = action.Perform (items, modItems);
140
 
                        } catch (Exception e) {
141
 
                                LogError ("Perform", e);
142
 
                        } finally {
143
 
                                resultItems = resultItems ?? new IItem [0];
144
 
                        }
145
 
                        resultItems = EnsureDoItemArray (resultItems);
146
 
                        
147
 
                        // If we have results to feed back into the window, do so in a new
148
 
                        // iteration.
149
 
                        if (resultItems.Length > 0) {
150
 
                                GLib.Timeout.Add (10, delegate {
151
 
                                        Do.Controller.SummonWithObjects (resultItems);
152
 
                                        return false;
153
 
                                });
154
 
                        }
155
 
                        return resultItems;
156
 
                }
157
 
                
158
 
        }       
159
 
}