Added typemap for wxArrayString

Added wxMimeTypesManager and wxFileType

Other updates...


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@12206 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

wxPython/src/misc2.i

@@ -30,6 +30,8 @@
 #if wxUSE_WAVE || defined(__WXMSW__)
 #include <wx/wave.h>
 #endif
+
+#include <wx/mimetype.h>
 %}
 
 //----------------------------------------------------------------------
@@ -357,18 +359,12 @@ public:
     %addmethods {
         PyObject* GetEncodings() {
             wxArrayString* arr = self->GetEncodings();
-            PyObject* list = PyList_New(0);
-            for (size_t x=0; x<arr->GetCount(); x++)
-                PyList_Append(list, PyString_FromString((*arr)[x]));
-            return list;
+            return wxArrayString2PyList_helper(arr);
         }
 
         PyObject* GetFacenames() {
             wxArrayString* arr = self->GetFacenames();
-            PyObject* list = PyList_New(0);
-            for (size_t x=0; x<arr->GetCount(); x++)
-                PyList_Append(list, PyString_FromString((*arr)[x]));
-            return list;
+            return wxArrayString2PyList_helper(arr);
         }
     }
 };
@@ -514,6 +510,21 @@ public:
     void Stop();
 };
 
+
+class wxStopWatch
+{
+public:
+    // ctor starts the stop watch
+    wxStopWatch();
+    void Start(long t = 0);
+    void Pause();
+    void Resume();
+
+    // get elapsed time since the last Start() or Pause() in milliseconds
+    long Time() const;
+};
+
+
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------
 
@@ -913,6 +924,359 @@ public:
 %}
 
 
+//----------------------------------------------------------------------
+
+enum wxMailcapStyle
+{
+    wxMAILCAP_STANDARD = 1,
+    wxMAILCAP_NETSCAPE = 2,
+    wxMAILCAP_KDE = 4,
+    wxMAILCAP_GNOME = 8,
+
+    wxMAILCAP_ALL = 15
+};
+
+
+
+class wxFileTypeInfo
+{
+public:
+    // ctors
+        // a normal item
+    wxFileTypeInfo(const char *mimeType,
+                   const char *openCmd,
+                   const char *printCmd,
+                   const char *desc);
+
+
+        // the array elements correspond to the parameters of the ctor above in
+        // the same order
+    %name(wxFileTypeInfoSequence)wxFileTypeInfo(const wxArrayString& sArray);
+
+        // invalid item - use this to terminate the array passed to
+        // wxMimeTypesManager::AddFallbacks
+    %name(wxNullFileTypeInfo)wxFileTypeInfo();
+
+
+    // test if this object can be used
+    bool IsValid() const;
+
+    // setters
+        // set the icon info
+    void SetIcon(const wxString& iconFile, int iconIndex = 0);
+
+        // set the short desc
+    void SetShortDesc(const wxString& shortDesc);
+
+    // accessors
+        // get the MIME type
+    const wxString& GetMimeType() const;
+        // get the open command
+    const wxString& GetOpenCommand() const;
+        // get the print command
+    const wxString& GetPrintCommand() const;
+        // get the short description (only used under Win32 so far)
+    const wxString& GetShortDesc() const;
+        // get the long, user visible description
+    const wxString& GetDescription() const;
+
+
+        // get the array of all extensions
+    //const wxArrayString& GetExtensions() const;
+    %addmethods {
+        PyObject* GetExtensions() {
+            wxArrayString& arr = (wxArrayString&)self->GetExtensions();
+            return wxArrayString2PyList_helper(arr);
+        }
+    }
+
+    int GetExtensionsCount() const;
+
+    // get the icon info
+    const wxString& GetIconFile() const;
+    int GetIconIndex() const;
+};
+
+
+
+
+class wxFileType
+{
+public:
+
+    // TODO: Make a wxPyMessageParameters with virtual GetParamValue...
+
+    // An object of this class must be passed to Get{Open|Print}Command. The
+    // default implementation is trivial and doesn't know anything at all about
+    // parameters, only filename and MIME type are used (so it's probably ok for
+    // Windows where %{param} is not used anyhow)
+    class MessageParameters
+    {
+    public:
+        // ctors
+        MessageParameters(const wxString& filename=wxPyEmptyStr,
+                          const wxString& mimetype=wxPyEmptyStr);
+
+        // accessors (called by GetOpenCommand)
+            // filename
+        const wxString& GetFileName() const;
+            // mime type
+        const wxString& GetMimeType() const;;
+
+        // override this function in derived class
+        virtual wxString GetParamValue(const wxString& name) const;
+
+        // virtual dtor as in any base class
+        virtual ~MessageParameters();
+    };
+
+
+    // ctor from static data
+    wxFileType(const wxFileTypeInfo& ftInfo);
+
+    // return the MIME type for this file type
+    %addmethods {
+        PyObject* GetMimeType() {
+            wxString str;
+            if (self->GetMimeType(&str))
+                return PyString_FromString(str.c_str());
+            else
+                RETURN_NONE();
+        }
+        PyObject* GetMimeTypes() {
+            wxArrayString arr;
+            if (self->GetMimeTypes(arr))
+                return wxArrayString2PyList_helper(arr);
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // Get all extensions associated with this file type
+    %addmethods {
+        PyObject* GetExtensions() {
+            wxArrayString arr;
+            if (self->GetExtensions(arr))
+                return wxArrayString2PyList_helper(arr);
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    %addmethods {
+        // Get the icon corresponding to this file type
+        %new wxIcon* GetIcon() {
+            wxIcon icon;
+            if (self->GetIcon(&icon))
+                return new wxIcon(icon);
+            else
+                return NULL;
+        }
+
+        // Get the icon corresponding to this file type, the name of the file
+        // where this icon resides, and its index in this file if applicable.
+        PyObject* GetIconInfo() {
+            wxIcon icon;
+            wxString iconFile;
+            int iconIndex;
+            if (self->GetIcon(&icon, &iconFile, &iconIndex)) {
+                wxPyTState* state = wxPyBeginBlockThreads();
+                PyObject* tuple = PyTuple_New(3);
+                PyTuple_SetItem(tuple, 0, wxPyConstructObject(new wxIcon(icon),
+                                                              "wxIcon", TRUE));
+                PyTuple_SetItem(tuple, 1, PyString_FromString(iconFile.c_str()));
+                PyTuple_SetItem(tuple, 2, PyInt_FromLong(iconIndex));
+                wxPyEndBlockThreads(state);
+                return tuple;
+            }
+            else
+                RETURN_NONE();
+        }
+    }
+
+    %addmethods {
+        // get a brief file type description ("*.txt" => "text document")
+        PyObject* GetDescription() {
+            wxString str;
+            if (self->GetDescription(&str))
+                return PyString_FromString(str.c_str());
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // get the command to open/execute the file of given type
+    %addmethods {
+        PyObject* GetOpenCommand(const wxString& filename,
+                                 const wxString& mimetype=wxPyEmptyStr) {
+            wxString str;
+            if (self->GetOpenCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
+                return PyString_FromString(str.c_str());
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // get the command to print the file of given type
+    %addmethods {
+        PyObject* GetPrintCommand(const wxString& filename,
+                                  const wxString& mimetype=wxPyEmptyStr) {
+            wxString str;
+            if (self->GetPrintCommand(&str, wxFileType::MessageParameters(filename, mimetype)))
+                return PyString_FromString(str.c_str());
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // Get all commands defined for this file type
+    %addmethods {
+        PyObject* GetAllCommands(const wxString& filename,
+                                 const wxString& mimetype=wxPyEmptyStr) {
+            wxArrayString verbs;
+            wxArrayString commands;
+            if (self->GetAllCommands(&verbs, &commands,
+                                     wxFileType::MessageParameters(filename, mimetype))) {
+                wxPyTState* state = wxPyBeginBlockThreads();
+                PyObject* tuple = PyTuple_New(2);
+                PyTuple_SetItem(tuple, 0, wxArrayString2PyList_helper(verbs));
+                PyTuple_SetItem(tuple, 1, wxArrayString2PyList_helper(commands));
+                wxPyEndBlockThreads(state);
+                return tuple;
+            }
+            else
+                RETURN_NONE();
+        }
+    }
+
+
+    // set an arbitrary command, ask confirmation if it already exists and
+    // overwriteprompt is TRUE
+    bool SetCommand(const wxString& cmd, const wxString& verb,
+                    bool overwriteprompt = TRUE);
+
+    bool SetDefaultIcon(const wxString& cmd = wxEmptyString, int index = 0);
+
+
+    // remove the association for this filetype from the system MIME database:
+    // notice that it will only work if the association is defined in the user
+    // file/registry part, we will never modify the system-wide settings
+    bool Unassociate();
+
+    // operations
+        // expand a string in the format of GetOpenCommand (which may contain
+        // '%s' and '%t' format specificators for the file name and mime type
+        // and %{param} constructions).
+    static wxString ExpandCommand(const wxString& command,
+                                  const MessageParameters& params);
+
+    // dtor (not virtual, shouldn't be derived from)
+    ~wxFileType();
+
+};
+
+
+
+
+class wxMimeTypesManager
+{
+public:
+    // static helper functions
+    // -----------------------
+
+        // check if the given MIME type is the same as the other one: the
+        // second argument may contain wildcards ('*'), but not the first. If
+        // the types are equal or if the mimeType matches wildcard the function
+        // returns TRUE, otherwise it returns FALSE
+    static bool IsOfType(const wxString& mimeType, const wxString& wildcard);
+
+    // ctor
+    wxMimeTypesManager();
+
+    // loads data from standard files according to the mailcap styles
+    // specified: this is a bitwise OR of wxMailcapStyle values
+    //
+    // use the extraDir parameter if you want to look for files in another
+    // directory
+    void Initialize(int mailcapStyle = wxMAILCAP_STANDARD,
+                    const wxString& extraDir = wxEmptyString);
+
+    // and this function clears all the data from the manager
+    void ClearData();
+
+    // Database lookup: all functions return a pointer to wxFileType object
+    // whose methods may be used to query it for the information you're
+    // interested in. If the return value is !NULL, caller is responsible for
+    // deleting it.
+    // get file type from file extension
+    %new wxFileType *GetFileTypeFromExtension(const wxString& ext);
+
+    // get file type from MIME type (in format <category>/<format>)
+    %new wxFileType *GetFileTypeFromMimeType(const wxString& mimeType);
+
+    // other operations: return TRUE if there were no errors or FALSE if there
+    // were some unreckognized entries (the good entries are always read anyhow)
+    //
+
+        // read in additional file (the standard ones are read automatically)
+        // in mailcap format (see mimetype.cpp for description)
+        //
+        // 'fallback' parameter may be set to TRUE to avoid overriding the
+        // settings from other, previously parsed, files by this one: normally,
+        // the files read most recently would override the older files, but with
+        // fallback == TRUE this won't happen
+    bool ReadMailcap(const wxString& filename, bool fallback = FALSE);
+
+    // read in additional file in mime.types format
+    bool ReadMimeTypes(const wxString& filename);
+
+    // enumerate all known MIME types
+    %addmethods {
+        PyObject* EnumAllFileTypes() {
+            wxArrayString arr;
+            self->EnumAllFileTypes(arr);
+            return wxArrayString2PyList_helper(arr);
+        }
+    }
+
+    // these functions can be used to provide default values for some of the
+    // MIME types inside the program itself (you may also use
+    // ReadMailcap(filenameWithDefaultTypes, TRUE /* use as fallback */) to
+    // achieve the same goal, but this requires having this info in a file).
+    //
+    void AddFallback(const wxFileTypeInfo& ft);
+
+
+    // create or remove associations
+
+        // create a new association using the fields of wxFileTypeInfo (at least
+        // the MIME type and the extension should be set)
+        // if the other fields are empty, the existing values should be left alone
+    %new wxFileType *Associate(const wxFileTypeInfo& ftInfo);
+
+        // undo Associate()
+    bool Unassociate(wxFileType *ft) ;
+
+    // dtor (not virtual, shouldn't be derived from)
+    ~wxMimeTypesManager();
+};
+
+
+%readonly
+%{
+#if 0
+%}
+extern wxMimeTypesManager* wxTheMimeTypesManager;
+%{
+#endif
+%}
+%readwrite
+
 //----------------------------------------------------------------------
 //----------------------------------------------------------------------