~ubuntu-branches/ubuntu/lucid/tomboy/lucid-proposed

                // TODO: Extract most of the code here and build GenericSyncServiceAddin

                // that supports a field, a username, and password.  This could be useful

                // in quickly building SshSyncServiceAddin, FtpSyncServiceAddin, etc.

                private Entry pathEntry;

                private string path;

                private bool initialized = false;

                /// <summary>

                /// Called as soon as Tomboy needs to do anything with the service

                /// </summary>

                {

                        initialized = true;

                }

                public override void Shutdown ()

                {

                        // Do nothing for now

                }

                public override bool Initialized {

                }

 

 

                public override SyncServer CreateSyncServer ()

                {

                        SyncServer server = null;

                        string syncPath;

                        if (GetConfigSettings (out syncPath)) {

                                path = syncPath;

                        } else {

                                throw new InvalidOperationException ("FileSystemSyncServiceAddin.CreateSyncServer () called without being configured");

                        }

                        return server;

                }

                public override void PostSyncCleanup ()

                {

                        // Nothing to do

                }

                /// <summary>

                /// Creates a Gtk.Widget that's used to configure the service.  This

                /// will be used in the Synchronization Preferences.  Preferences should

                public override Gtk.Widget CreatePreferencesControl ()

                {

                        Gtk.Table table = new Gtk.Table (1, 3, false);

                        // Read settings out of gconf

                        string syncPath;

                        if (GetConfigSettings (out syncPath) == false)

                                syncPath = string.Empty;

 

                        l.Xalign = 1;

                        table.Attach (l, 0, 1, 0, 1);

                        pathEntry = new Entry ();

                        pathEntry.Text = syncPath;

                        table.Attach (pathEntry, 1, 2, 0, 1);

                        Image browseImage = new Image (Stock.Open, IconSize.Button);

                        HBox browseBox = new HBox (false, 0);

                        browseBox.PackStart (browseImage);

                        Button browseButton = new Button ();

                        browseButton.Add (browseBox);

                        browseButton.Clicked += OnBrowseButtonClicked;

                        table.Attach (browseButton, 2, 3, 0, 1, AttachOptions.Shrink, AttachOptions.Expand, 0, 0);

                        table.ShowAll ();

                        return table;

                }

                private void OnBrowseButtonClicked (object sender, EventArgs args)

                {

                        FileChooserDialog chooserDlg =

                        chooserDlg.DefaultResponse = ResponseType.Cancel;

                        chooserDlg.SetFilename (pathEntry.Text);

                        ResponseType response = (ResponseType) chooserDlg.Run ();

                        if (response == ResponseType.Ok)

                                pathEntry.Text = chooserDlg.Filename;

                        chooserDlg.Destroy ();

                }

                /// <summary>

                /// The Addin should verify and check the connection to the service

                /// when this is called.  If verification and connection is successful,

                public override bool SaveConfiguration ()

                {

                        string syncPath = pathEntry.Text.Trim ();

                        if (syncPath == string.Empty) {

                                // TODO: Figure out a way to send the error back to the client

                                Logger.Debug ("The path is empty");

                                throw new TomboySyncException (Catalog.GetString ("Folder path field is empty."));

                        }

                        // Attempt to create the path and fail if we can't

                        if (Directory.Exists (syncPath) == false) {

                                try {

                                } catch (Exception e) {

                                        Logger.Debug ("Could not create \"{0}\": {1}", path, e.Message);

                                        throw new TomboySyncException (Catalog.GetString ("Specified folder path does not exist, " +

                                }

                        } else {

                                // Test creating/writing/deleting a file

                                string testPathBase = Path.Combine (syncPath, "test");

                                string testPath = testPathBase;

                                int count = 0;

                                // Get unique new file name

                                while (File.Exists (testPath))

                                        testPath = testPathBase + (++count).ToString ();

                                // Test ability to create and write

                                string testLine = "Testing write capabilities.";

                                using (FileStream fs = File.Create (testPath)) {

                                        StreamWriter writer = new StreamWriter (fs);

                                        writer.WriteLine (testLine);

                                }

                                // Test ability to read

                                bool testFileFound = false;

                                foreach (string filePath in Directory.GetFiles (syncPath))

                                if (!testFileFound)

                                        ; // TODO: Throw TomboySyncException

                                using (StreamReader reader = new StreamReader (testPath)) {

                                        if (reader.ReadLine () != testLine)

                                                ; // TODO: Throw TomboySyncException

                                }

                                // Test ability to delete

                                File.Delete (testPath);

                        }

                        path = syncPath;

                        // TODO: Try to create and delete a file.  If it fails, this should fail

                        Preferences.Set (Preferences.SYNC_LOCAL_PATH, path);

                        return true;

                }

 

                {

                        Preferences.Set (Preferences.SYNC_LOCAL_PATH, string.Empty);

                }

                /// <summary>

                /// Returns whether the addin is configured enough to actually be used.

                /// </summary>

                {

                        get {

                                string syncPath = Preferences.Get (Preferences.SYNC_LOCAL_PATH) as String;

                                if (syncPath != null && syncPath != string.Empty) {

                                        return true;

                                }

                                return false;

                        }

                }

                /// <summary>

                /// The name that will be shown in the preferences to distinguish

                /// between this and other SyncServiceAddins.

                                return "local";

                        }

                }

                /// <summary>

                /// Returns true if the addin has all the supporting libraries installed

                /// on the machine or false if the proper environment is not available.

                /// </summary>

                public override bool IsSupported

                {

                }

                #region Private Methods

                /// <summary>

                /// Get config settings

                        if (syncPath != null && syncPath != string.Empty) {

                                return true;

                        }

                        return false;

                }

                #endregion // Private Methods