projects/dwt-linux: dwt/program/Program.d comparison

comparison dwt/program/Program.d @ 238:380bad9f6852

reverted char[] to String

author	Frank Benoit <benoit@tionex.de>
date	Mon, 05 May 2008 00:42:55 +0200
parents	3cb84407dc3e
children	ce446666f5a2

comparison

equal deleted inserted replaced

-:98b80b00af79
+:380bad9f6852
 * Instances of this class represent programs and
 * their associated file extensions in the operating
 * system.
 */
 public final class Program {
-char[] name;
+String name;
-char[] command;
+String command;
-char[] iconPath;
+String iconPath;
 Display display;
 /* Gnome specific
 * true if command expects a URI
 * false if expects a path
 */
 bool gnomeExpectUri;
 static int /*long*/ cdeShell;
-static const char[][] CDE_ICON_EXT = [ ".m.pm"[],   ".l.pm",   ".s.pm",   ".t.pm" ];
+static const String[] CDE_ICON_EXT = [ ".m.pm"[],   ".l.pm",   ".s.pm",   ".t.pm" ];
-static const char[][] CDE_MASK_EXT = [ ".m_m.bm"[], ".l_m.bm", ".s_m.bm", ".t_m.bm" ];
+static const String[] CDE_MASK_EXT = [ ".m_m.bm"[], ".l_m.bm", ".s_m.bm", ".t_m.bm" ];
-static const char[] DESKTOP_DATA = "Program_DESKTOP";
+static const String DESKTOP_DATA = "Program_DESKTOP";
-static const char[] ICON_THEME_DATA = "Program_GNOME_ICON_THEME";
+static const String ICON_THEME_DATA = "Program_GNOME_ICON_THEME";
 static const int DESKTOP_UNKNOWN = 0;
 static const int DESKTOP_GNOME = 1;
 static const int DESKTOP_GNOME_24 = 2;
 static const int DESKTOP_CDE = 3;
 static const int PREFERRED_ICON_SIZE = 16;
 * The workaround is to simply check that the window manager is a
 * compliant one (property _NET_SUPPORTING_WM_CHECK) and to attempt to load
 * our native library that depends on gnome-vfs.
 */
 if (desktop is DESKTOP_UNKNOWN) {
-char[] gnomeName = "_NET_SUPPORTING_WM_CHECK";
+String gnomeName = "_NET_SUPPORTING_WM_CHECK";
 int /*long*/ gnome = OS.XInternAtom(xDisplay, gnomeName.ptr, true);
 if (gnome !is OS.None && gnome_init()) {
 desktop = DESKTOP_GNOME;
 int icon_theme = cast(int)GNOME.gnome_icon_theme_new();
 display.setData(ICON_THEME_DATA, new ValueWrapperInt(icon_theme));
 */
 if (gnomeIconTheme.value !is 0) OS.g_object_unref( cast(void*)gnomeIconTheme.value);
 }
 });
 /* Check for libgnomevfs-2 version 2.4 */
-char[] buffer = "libgnomevfs-2.so.0";
+String buffer = "libgnomevfs-2.so.0";
 auto libgnomevfs = SharedLib.load(buffer );
 if (libgnomevfs !is null) {
 buffer = "gnome_vfs_url_show";
 void* gnome_vfs_url_show = libgnomevfs.getSymbol( buffer.ptr );
 if (gnome_vfs_url_show !is null) {
 * On CDE, the atom below may exist without DTWM running. If the atom
 * below is defined, the CDE database exists and the available
 * applications can be queried.
 */
 if (desktop is DESKTOP_UNKNOWN) {
-char[] cdeName = "_DT_SM_PREFERENCES";
+String cdeName = "_DT_SM_PREFERENCES";
 int /*long*/ cde = OS.XInternAtom(xDisplay, cdeName.ptr, true);
 for (int index = 0; desktop is DESKTOP_UNKNOWN && index < property.length; index++) {
 if (property[index] is OS.None) continue; /* do not match atoms that do not exist */
 if (property[index] is cde && cde_init(display)) desktop = DESKTOP_CDE;
 }
 return desktop;
 }
 // PORTING CDE not supported
 /+
-bool cde_execute(char[] fileName) {
+bool cde_execute(String fileName) {
 /* Use the character encoding for the default locale */
 char* action = toStringz(command);
 char* ptr = cast(char*)OS.g_malloc(fileName.length+1);
 ptr[ 0 .. fileName.length ] = fileName;
 ptr[ fileName.length ] = 0;
 long actionID = CDE.DtActionInvoke(cdeShell, action, args, 1, null, null, null, 1, 0, 0);
 OS.g_free(ptr);
 return actionID !is 0;
 }
-static char[] cde_getAction(char[] dataType) {
+static String cde_getAction(String dataType) {
-char[] action  = null;
+String action  = null;
-char[] actions = cde_getAttribute(dataType, CDE.DtDTS_DA_ACTION_LIST);
+String actions = cde_getAttribute(dataType, CDE.DtDTS_DA_ACTION_LIST);
 if (actions !is null) {
 int index = actions.indexOf("Open");
 if (index !is -1) {
 action = actions.substring(index, index + 4);
 } else {
 }
 }
 return action;
 }
-static char[] cde_getAttribute(char[] dataType, char[] attrName) {
+static String cde_getAttribute(String dataType, String attrName) {
 /* Use the character encoding for the default locale */
 byte[] dataTypeBuf = Converter.wcsToMbcs(null, dataType, true);
 byte[] attrNameBuf = Converter.wcsToMbcs(null, attrName, true);
 byte[] optNameBuf = null;
 int /*long*/ attrValue = CDE.DtDtsDataTypeToAttributeValue(dataTypeBuf, attrNameBuf, optNameBuf);
 int length = OS.strlen(attrValue);
 byte[] attrValueBuf = new byte[length];
 OS.memmove(attrValueBuf, attrValue, length);
 CDE.DtDtsFreeAttributeValue(attrValue);
 /* Use the character encoding for the default locale */
-return new char[](Converter.mbcsToWcs(null, attrValueBuf));
+return new String(Converter.mbcsToWcs(null, attrValueBuf));
 }
-static char[][][ char[] ] cde_getDataTypeInfo() {
+static String[][ String ] cde_getDataTypeInfo() {
-char[][][ char[] ] dataTypeInfo;
+String[][ String ] dataTypeInfo;
 int index;
 int /*long*/ dataTypeList = CDE.DtDtsDataTypeNames();
 if (dataTypeList !is 0) {
 /* For each data type name in the list */
 index = 0;
 while (dataType[0] !is 0) {
 int length = OS.strlen(dataType[0]);
 byte[] dataTypeBuf = new byte[length];
 OS.memmove(dataTypeBuf, dataType[0], length);
 /* Use the character encoding for the default locale */
-char[] dataTypeName = new char[](Converter.mbcsToWcs(null, dataTypeBuf));
+String dataTypeName = new String(Converter.mbcsToWcs(null, dataTypeBuf));
 /* The data type is valid if it is not an action, and it has an extension and an action. */
-char[] extension = cde_getExtension(dataTypeName);
+String extension = cde_getExtension(dataTypeName);
 if (!CDE.DtDtsDataTypeIsAction(dataTypeBuf) &&
 extension !is null && cde_getAction(dataTypeName) !is null) {
-char[][] exts;
+String[] exts;
 exts ~= extension;
 dataTypeInfo[ dataTypeName ] = exts;
 }
 OS.memmove(dataType, dataTypeList + (index++ * 4), 4);
 }
 }
 return dataTypeInfo;
 }
-static char[] cde_getExtension(char[] dataType) {
+static String cde_getExtension(String dataType) {
-char[] fileExt = cde_getAttribute(dataType, CDE.DtDTS_DA_NAME_TEMPLATE);
+String fileExt = cde_getAttribute(dataType, CDE.DtDTS_DA_NAME_TEMPLATE);
 if (fileExt is null || fileExt.indexOf("%s.") is -1) return null;
 int dot = fileExt.indexOf(".");
 return fileExt.substring(dot);
 }
 ImageData cde_getImageData() {
 // TODO
 return null;
 }
-static char[] cde_getMimeType(char[] extension) {
+static String cde_getMimeType(String extension) {
-char[] mimeType = null;
+String mimeType = null;
-char[][][ char[] ] mimeInfo = cde_getDataTypeInfo();
+String[][ String ] mimeInfo = cde_getDataTypeInfo();
 if (mimeInfo is null) return null;
-char[][] keys = mimeInfo.keys();
+String[] keys = mimeInfo.keys();
 int keyIdx = 0;
 while (mimeType is null && keyIdx < keys.length ) {
-char[] type = keys[ keyIdx ];
+String type = keys[ keyIdx ];
-char[][] mimeExts = mimeInfo[type];
+String[] mimeExts = mimeInfo[type];
 for (int index = 0; index < mimeExts.length; index++){
 if (extension.equals(mimeExts[index])) {
 mimeType = type;
 break;
 }
 keyIdx++;
 }
 return mimeType;
 }
-static Program cde_getProgram(Display display, char[] mimeType) {
+static Program cde_getProgram(Display display, String mimeType) {
 Program program = new Program();
 program.display = display;
 program.name = mimeType;
 program.command = cde_getAction(mimeType);
 program.iconPath = cde_getAttribute(program.name, CDE.DtDTS_DA_ICON);
 if (initOK) CDE.DtDbLoad();
 return initOK;
 }
 +/
-static char[][] parseCommand(char[] cmd) {
+static String[] parseCommand(String cmd) {
-char[][] args;
+String[] args;
 int sIndex = 0;
 int eIndex;
 while (sIndex < cmd.length) {
 /* Trim initial white space of argument. */
 while (sIndex < cmd.length && Compatibility.isWhitespace(cmd.charAt(sIndex))) {
 sIndex = eIndex + 1;
 }
 }
 }
-char[][] strings = new char[][args.length];
+String[] strings = new String[args.length];
 for (int index =0; index < args.length; index++) {
 strings[index] = args[index];
 }
 return strings;
 }
 /**
 * GNOME 2.4 - Execute the program for the given file.
 */
-bool gnome_24_execute(char[] fileName) {
+bool gnome_24_execute(String fileName) {
 char* mimeTypeBuffer = toStringz(name);
 auto ptr = GNOME.gnome_vfs_mime_get_default_application(mimeTypeBuffer);
 char* fileNameBuffer = toStringz(fileName);
 char* uri = GNOME.gnome_vfs_make_uri_from_input_with_dirs(fileNameBuffer, GNOME.GNOME_VFS_MAKE_URI_DIR_CURRENT);
 GList* list = OS.g_list_append( null, uri);
 }
 /**
 * GNOME 2.4 - Launch the default program for the given file.
 */
-static bool gnome_24_launch(char[] fileName) {
+static bool gnome_24_launch(String fileName) {
 char* fileNameBuffer = toStringz(fileName);
 char* uri = GNOME.gnome_vfs_make_uri_from_input_with_dirs(fileNameBuffer, GNOME.GNOME_VFS_MAKE_URI_DIR_CURRENT);
 int result = GNOME.gnome_vfs_url_show(uri);
 OS.g_free(uri);
 return (result is GNOME.GNOME_VFS_OK);
 }
 /**
 * GNOME 2.2 - Execute the program for the given file.
 */
-bool gnome_execute(char[] fileName) {
+bool gnome_execute(String fileName) {
 if (gnomeExpectUri) {
 /* Convert the given path into a URL */
 char* fileNameBuffer = toStringz(fileName);
 char* uri = GNOME.gnome_vfs_make_uri_from_input(fileNameBuffer);
 if (uri !is null) {
 OS.g_free(uri);
 }
 }
 /* Parse the command into its individual arguments. */
-char[][] args = parseCommand(command);
+String[] args = parseCommand(command);
 int fileArg = -1;
 int index;
 for (index = 0; index < args.length; index++) {
 int j = args[index].indexOf("%f");
 if (j !is -1) {
-char[] value = args[index];
+String value = args[index];
 fileArg = index;
 args[index] = value.substring(0, j) ~ fileName ~ value.substring(j + 2);
 }
 }
 /* If a file name was given but the command did not have "%f" */
 if ((fileName.length > 0) && (fileArg < 0)) {
-char[][] newArgs = new char[][args.length + 1];
+String[] newArgs = new String[args.length + 1];
 for (index = 0; index < args.length; index++) newArgs[index] = args[index];
 newArgs[args.length] = fileName;
 args = newArgs;
 }
 /++
 + DWT Extension
 + This is a temporary workaround until SWT will get the real implementation.
 +/
-static char[][][ char[] ] gnome24_getMimeInfo() {
+static String[][ String ] gnome24_getMimeInfo() {
 scope file = new FileConduit ("/usr/share/mime/globs");
 scope it = new LineIterator!(char)(file);
 // process file one line at a time
-char[][][ char[] ] mimeInfo;
+String[][ String ] mimeInfo;
 foreach (line; it ){
 int colon = line.indexOf(':');
 if( colon is line.length ){
 continue;
 }
 if( line.length < colon+3 || line[colon+1 .. colon+3 ] != "*." ){
 continue;
 }
-char[] mimeType = line[0..colon].dup;
+String mimeType = line[0..colon].dup;
-char[] ext      = line[colon+3 .. $].dup;
+String ext      = line[colon+3 .. $].dup;
 if( auto exts = mimeType in mimeInfo ){
 mimeInfo[ mimeType ] = *exts ~ ext;
 }
 else{
 mimeInfo[ mimeType ] = [ ext ];
 * Obtain the registered mime type information and
 * return it in a map. The key of each entry
 * in the map is the mime type name. The value is
 * a vector of the associated file extensions.
 */
-static char[][][ char[] ] gnome_getMimeInfo() {
+static String[][ String ] gnome_getMimeInfo() {
-char[][][ char[] ] mimeInfo;
+String[][ String ] mimeInfo;
 GList* mimeList = GNOME.gnome_vfs_get_registered_mime_types();
 GList* mimeElement = mimeList;
 while (mimeElement !is null) {
 char* mimePtr = cast(char*) OS.g_list_data(mimeElement);
-char[] mimeTypeBuffer = fromStringz(mimePtr).dup;
+String mimeTypeBuffer = fromStringz(mimePtr).dup;
-char[] mimeType = mimeTypeBuffer;//new char[](Converter.mbcsToWcs(null, mimeTypeBuffer));
+String mimeType = mimeTypeBuffer;//new String(Converter.mbcsToWcs(null, mimeTypeBuffer));
 GList* extensionList = GNOME.gnome_vfs_mime_get_extensions_list(mimePtr);
 if (extensionList !is null) {
-char[][] extensions;
+String[] extensions;
 GList* extensionElement = extensionList;
 while (extensionElement !is null) {
 char* extensionPtr = cast(char*) OS.g_list_data(extensionElement);
-char[] extensionBuffer = fromStringz(extensionPtr).dup;
+String extensionBuffer = fromStringz(extensionPtr).dup;
-char[] extension = extensionBuffer;
+String extension = extensionBuffer;
 extension = '.' ~ extension;
 extensions ~= extension;
 extensionElement = OS.g_list_next(extensionElement);
 }
 GNOME.gnome_vfs_mime_extensions_list_free(extensionList);
 }
 if (mimeList !is null) GNOME.gnome_vfs_mime_registered_mime_type_list_free(mimeList);
 return mimeInfo;
 }
-static char[] gnome_getMimeType(char[] extension) {
+static String gnome_getMimeType(String extension) {
-char[] mimeType = null;
+String mimeType = null;
-char[] fileName = "swt" ~ extension;
+String fileName = "swt" ~ extension;
 char* extensionBuffer = toStringz(fileName);
 char* typeName = GNOME.gnome_vfs_mime_type_from_name(extensionBuffer);
 if (typeName !is null) {
 mimeType = fromStringz(typeName).dup;
 }
 return mimeType;
 }
-static Program gnome_getProgram(Display display, char[] mimeType) {
+static Program gnome_getProgram(Display display, String mimeType) {
 Program program = null;
 char* mimeTypeBuffer = toStringz(mimeType);
 GnomeVFSMimeApplication* ptr = GNOME.gnome_vfs_mime_get_default_application(mimeTypeBuffer);
 if (ptr !is null) {
 program = new Program();
 program.display = display;
 program.name = mimeType;
 GnomeVFSMimeApplication* application = ptr;
-char[] buffer = fromStringz(application.command).dup;
+String buffer = fromStringz(application.command).dup;
 program.command = buffer;
 program.gnomeExpectUri = application.expects_uris is GNOME.GNOME_VFS_MIME_APPLICATION_ARGUMENT_TYPE_URIS;
 buffer = fromStringz( application.id) ~ \0;
 ValueWrapperInt gnomeIconTheme = cast(ValueWrapperInt)display.getData(ICON_THEME_DATA);
 *
 * @exception IllegalArgumentException <ul>
 *      <li>ERROR_NULL_ARGUMENT when extension is null</li>
 *  </ul>
 */
-public static Program findProgram(char[] extension) {
+public static Program findProgram(String extension) {
 return findProgram(Display.getCurrent(), extension);
 }
 /*
 *  API: When support for multiple displays is added, this method will
 *       become public and the original method above can be deprecated.
 */
-static Program findProgram(Display display, char[] extension) {
+static Program findProgram(Display display, String extension) {
 if (extension is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 if (extension.length is 0) return null;
 if (extension.charAt(0) !is '.') extension = "." ~ extension;
 int desktop = getDesktop(display);
-char[] mimeType = null;
+String mimeType = null;
 switch (desktop) {
 case DESKTOP_GNOME_24:
 case DESKTOP_GNOME: mimeType = gnome_getMimeType(extension); break;
 //case DESKTOP_CDE: mimeType = cde_getMimeType(extension); break;
 default:
 * that a <code>Display</code> must already exist to guarantee
 * that this method returns an appropriate result.
 *
 * @return an array of extensions
 */
-public static char[][] getExtensions() {
+public static String[] getExtensions() {
 return getExtensions(Display.getCurrent());
 }
 /*
 *  API: When support for multiple displays is added, this method will
 *       become public and the original method above can be deprecated.
 */
-static char[][] getExtensions(Display display) {
+static String[] getExtensions(Display display) {
 int desktop = getDesktop(display);
-char[][][ char[] ] mimeInfo = null;
+String[][ String ] mimeInfo = null;
 switch (desktop) {
 case DESKTOP_GNOME_24: mimeInfo = gnome24_getMimeInfo(); break;
 case DESKTOP_GNOME: mimeInfo = gnome_getMimeInfo(); break;
 //case DESKTOP_CDE: mimeInfo = cde_getDataTypeInfo(); break;
 default:
 }
 if (mimeInfo is null) return null;
 /* Create a unique set of the file extensions. */
-char[][] extensions;
+String[] extensions;
-char[][] keys = mimeInfo.keys;
+String[] keys = mimeInfo.keys;
 int keyIdx = 0;
 while ( keyIdx < keys.length ) {
-char[] mimeType = keys[ keyIdx ];
+String mimeType = keys[ keyIdx ];
-char[][] mimeExts = mimeInfo[mimeType];
+String[] mimeExts = mimeInfo[mimeType];
 for (int index = 0; index < mimeExts.length; index++){
 if (!extensions.contains(mimeExts[index])) {
 extensions ~= mimeExts[index];
 }
 }
 keyIdx++;
 }
 /* Return the list of extensions. */
-char[][] extStrings = new char[][]( extensions.length );
+String[] extStrings = new String[]( extensions.length );
 for (int index = 0; index < extensions.length; index++) {
 extStrings[index] = extensions[index];
 }
 return extStrings;
 }
 *  API: When support for multiple displays is added, this method will
 *       become public and the original method above can be deprecated.
 */
 static Program[] getPrograms(Display display) {
 int desktop = getDesktop(display);
-char[][][ char[] ] mimeInfo = null;
+String[][ String ] mimeInfo = null;
 switch (desktop) {
 case DESKTOP_GNOME_24: break;
 case DESKTOP_GNOME: mimeInfo = gnome_getMimeInfo(); break;
 //case DESKTOP_CDE: mimeInfo = cde_getDataTypeInfo(); break;
 default:
 }
 if (mimeInfo is null) return new Program[0];
 Program[] programs;
-char[][] keys = mimeInfo.keys;
+String[] keys = mimeInfo.keys;
 int keyIdx = 0;
 while ( keyIdx < keys.length ) {
-char[] mimeType = keys[ keyIdx ];
+String mimeType = keys[ keyIdx ];
 Program program = null;
 switch (desktop) {
 case DESKTOP_GNOME: program = gnome_getProgram(display, mimeType); break;
 //case DESKTOP_CDE: program = cde_getProgram(display, mimeType); break;
 default:
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT when fileName is null</li>
 * </ul>
 */
-public static bool launch(char[] fileName) {
+public static bool launch(String fileName) {
 return launch(Display.getCurrent(), fileName);
 }
 /*
 *  API: When support for multiple displays is added, this method will
 *       become public and the original method above can be deprecated.
 */
-static bool launch(Display display, char[] fileName) {
+static bool launch(Display display, String fileName) {
 if (fileName is null) DWT.error (DWT.ERROR_NULL_ARGUMENT);
 switch(getDesktop(display)) {
 case DESKTOP_GNOME_24:
 if (gnome_24_launch (fileName)) return true;
 default:
 int index = fileName.lastIndexOf('.');
 if (index !is -1) {
-char[] extension = fileName.substring (index);
+String extension = fileName.substring (index);
 Program program = Program.findProgram (display, extension);
 if (program !is null && program.execute (fileName)) return true;
 }
 break;
 }
 *
 * @exception IllegalArgumentException <ul>
 *    <li>ERROR_NULL_ARGUMENT when fileName is null</li>
 * </ul>
 */
-public bool execute(char[] fileName) {
+public bool execute(String fileName) {
 if (fileName is null) DWT.error(DWT.ERROR_NULL_ARGUMENT);
 int desktop = getDesktop(display);
 switch (desktop) {
 case DESKTOP_GNOME_24: return gnome_24_execute(fileName);
 case DESKTOP_GNOME: return gnome_execute(fileName);
 * the program has no descriptive name, this string may
 * be the executable name, path or empty.
 *
 * @return the name of the program
 */
-public char[] getName() {
+public String getName() {
 return name;
 }
 /**
 * Returns an integer hash code for the receiver. Any two
 * Returns a string containing a concise, human-readable
 * description of the receiver.
 *
 * @return a string representation of the program
 */
-public char[] toString() {
+public String toString() {
 return Format( "Program {{{}}", name );
 }
 }

Mercurial > projects > dwt-linux

comparison dwt/program/Program.d @ 238:380bad9f6852