Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added dataxpm.c to avoid name clash; removed ifdefing around wxDummyChar

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1490 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Julian Smart
1999-01-26 14:18:32 +00:00
parent 9638564219
commit 8cbd2bdeff
9 changed files with 669 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
distrib/msw/gtk.rsp
View File

@@ -1,6 +1,7 @@
install-sh
Makefile
template.mak
configure
configure.in
config.guess
config.sub

1
distrib/msw/motif.rsp
View File

@@ -1,6 +1,7 @@
install-sh
Makefile
template.mak
configure
configure.in
config.guess
config.sub

30
docs/changes.txt
View File

@@ -1,8 +1,34 @@
wxWindows 2.0 Change Log
------------------------
Beta 2, ??? 1998
--------------------------
Beta 3, January 1999
--------------------
wxGTK:
wxMSW:
- wxRegConfig DeleteAll bug fixed.
- Makefiles for more compilers.
- TWIN32 support added.
- Renamed VC++ makefiles from .nt to .vc, and
factored out program/library settings.
wxMotif:
- A few more colour fixes.
- wxGLCanvas and OpenGL samples working.
- Some compiler warnings fixed.
- wxChoice crash fix.
- Dialog Editor starting to work on Motif.
General:
- wxBusyCursor class added.
- More doc improvements.
Beta 2, January 1999
--------------------
wxGTK:

48
docs/latex/wx/frame.tex
View File

@@ -272,43 +272,6 @@ Returns TRUE if the frame is iconized.
Returns TRUE if the frame is maximized.
\membersection{wxFrame::LoadAccelerators}\label{wxframeloadaccelerators}
\func{void}{LoadAccelerators}{\param{const wxString\& }{table}}
Loads a keyboard accelerator table for this frame.
\wxheading{Parameters}
\docparam{table}{Accelerator table to load.}
\wxheading{Return value}
TRUE if the operation was successful, FALSE otherwise.
\wxheading{Remarks}
Accelerator tables map keystrokes onto control and menu identifiers, so the
programmer does not have to explicitly program this correspondence.
See the hello demo ({\tt hello.cpp} and {\tt hello.rc}) for
an example of accelerator usage. This is a fragment from {\tt hello.rc}:
\begin{verbatim}
#define HELLO_LOAD_FILE 111
menus_accel ACCELERATORS
{
"^L", HELLO_LOAD_FILE
}
\end{verbatim}
This function only works under Windows.
% huh? If you call LoadAccelerators, you need to override wxFrame::OnActivate to do nothing.
\membersection{wxFrame::Maximize}\label{wxframemaximize}
\func{void}{Maximize}{\param{const bool }{maximize}}
@@ -329,17 +292,10 @@ This function only works under Windows.
\membersection{wxFrame::OnActivate}
\func{void}{OnActivate}{\param{bool}{ active}}
\func{void}{OnActivate}{\param{wxActivateEvent\&}{ event}}
Called when a window is activated or deactivated (MS Windows
only). If the window is being activated, {\it active} is TRUE, else it
is FALSE.
If you call wxFrame::LoadAccelerators, you need to override this function e.g.
\begin{verbatim}
void OnActivate(bool) {};
\end{verbatim}
only). See also \helpref{wxActivateEvent}{wxactivateevent}.
\membersection{wxFrame::OnCreateStatusBar}\label{wxframeoncreatestatusbar}

4
docs/motif/todo.txt
View File

@@ -38,10 +38,10 @@ High Priority
- wxRadioBox doesn't show up in the controls sample, though it's
OK on other dialogs (e.g. printing sample).
- Word wrapping in wxStaticText: how?
- wxSpinButton
- wxToolTip
- Miscellaneous events.
- Use wxImage to load other formats into wxBitmaps, such as PNG, BMP.

2
docs/msw/todo.txt
View File

@@ -45,6 +45,8 @@ Implement Robert's wxClipboard.
Distribution naming?
wxToolTip
LOW PRIORITY (MEDIUM TERM)
--------------------------

5
src/motif/stattext.cpp
View File

@@ -51,7 +51,10 @@ bool wxStaticText::Create(wxWindow *parent, wxWindowID id,
Widget parentWidget = (Widget) parent->GetClientWidget();
XmString text = XmStringCreateSimple (label1);
// Use XmStringCreateLtoR(), since XmStringCreateSimple
// doesn't obey separators.
// XmString text = XmStringCreateSimple (label1);
XmString text = XmStringCreateLtoR (label1, XmSTRING_DEFAULT_CHARSET);
XmFontList fontList = (XmFontList) m_windowFont.GetFontList(1.0, XtDisplay(parentWidget));

3
src/msw/app.cpp
View File

@@ -260,7 +260,8 @@ bool wxApp::Initialize()
// This is to foil optimizations in Visual C++ that
// throw out dummy.obj.
#if 0 && defined(_MSC_VER) && !defined(WXMAKINGDLL)
// PLEASE DO NOT ALTER THIS.
#if defined(_MSC_VER) && !defined(WXMAKINGDLL)
extern char wxDummyChar;
if (wxDummyChar) wxDummyChar++;
#endif

627
src/xpm/dataxpm.c Normal file
View File

@@ -0,0 +1,627 @@
/*
* Copyright (C) 1989-94 GROUPE BULL
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to
* deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* GROUPE BULL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
* AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of GROUPE BULL shall not be
* used in advertising or otherwise to promote the sale, use or other dealings
* in this Software without prior written authorization from GROUPE BULL.
*/
/*****************************************************************************\
* data.c: *
* *
* XPM library *
* IO utilities *
* *
* Developed by Arnaud Le Hors *
\*****************************************************************************/
/* Official version number */
static char *RCS_Version = "$XpmVersion: 3.4b $";
/* Internal version number */
static char *RCS_Id = "$Id$";
#include "xpm34p.h"
#ifdef VMS
#include "sys$library:stat.h"
#include "sys$library:ctype.h"
#else
#include <sys/types.h>
#include <sys/stat.h>
#include <ctype.h>
#endif
#include <string.h>
LFUNC(ParseComment, int, (xpmData * mdata));
static int
ParseComment(xpmData *mdata)
{
if (mdata->type == XPMBUFFER) {
register char c;
register unsigned int n = 0;
unsigned int notend;
char *s, *s2;
s = mdata->Comment;
*s = mdata->Bcmt[0];
/* skip the string beginning comment */
s2 = mdata->Bcmt;
do {
c = *mdata->cptr++;
*++s = c;
n++;
s2++;
} while (c == *s2 && *s2 != '\0' && c && c != mdata->Bos);
if (*s2 != '\0') {
/* this wasn't the beginning of a comment */
mdata->cptr -= n;
return 0;
}
/* store comment */
mdata->Comment[0] = *s;
s = mdata->Comment;
notend = 1;
n = 0;
while (notend) {
s2 = mdata->Ecmt;
while (*s != *s2 && c && c != mdata->Bos) {
c = *mdata->cptr++;
*++s = c;
n++;
}
mdata->CommentLength = n;
do {
c = *mdata->cptr++;
n++;
*++s = c;
s2++;
} while (c == *s2 && *s2 != '\0' && c && c != mdata->Bos);
if (*s2 == '\0') {
/* this is the end of the comment */
notend = 0;
mdata->cptr--;
}
}
return 0;
} else {
FILE *file = mdata->stream.file;
register int c;
register unsigned int n = 0, a;
unsigned int notend;
char *s, *s2;
s = mdata->Comment;
*s = mdata->Bcmt[0];
/* skip the string beginning comment */
s2 = mdata->Bcmt;
do {
c = getc(file);
*++s = c;
n++;
s2++;
} while (c == *s2 && *s2 != '\0'
&& c != EOF && c != mdata->Bos);
if (*s2 != '\0') {
/* this wasn't the beginning of a comment */
/* put characters back in the order that we got them */
for (a = n; a > 0; a--, s--)
ungetc(*s, file);
return 0;
}
/* store comment */
mdata->Comment[0] = *s;
s = mdata->Comment;
notend = 1;
n = 0;
while (notend) {
s2 = mdata->Ecmt;
while (*s != *s2 && c != EOF && c != mdata->Bos) {
c = getc(file);
*++s = c;
n++;
}
mdata->CommentLength = n;
do {
c = getc(file);
n++;
*++s = c;
s2++;
} while (c == *s2 && *s2 != '\0'
&& c != EOF && c != mdata->Bos);
if (*s2 == '\0') {
/* this is the end of the comment */
notend = 0;
ungetc(*s, file);
}
}
return 0;
}
}
/*
* skip to the end of the current string and the beginning of the next one
*/
int
xpmNextString(xpmData *mdata)
{
if (!mdata->type)
mdata->cptr = (mdata->stream.data)[++mdata->line];
else if (mdata->type == XPMBUFFER) {
register char c;
/* get to the end of the current string */
if (mdata->Eos)
while ((c = *mdata->cptr++) && c != mdata->Eos);
/*
* then get to the beginning of the next string looking for possible
* comment
*/
if (mdata->Bos) {
while ((c = *mdata->cptr++) && c != mdata->Bos)
if (mdata->Bcmt && c == mdata->Bcmt[0])
ParseComment(mdata);
} else if (mdata->Bcmt) { /* XPM2 natural */
while ((c = *mdata->cptr++) == mdata->Bcmt[0])
ParseComment(mdata);
mdata->cptr--;
}
} else {
register int c;
FILE *file = mdata->stream.file;
/* get to the end of the current string */
if (mdata->Eos)
while ((c = getc(file)) != mdata->Eos && c != EOF);
/*
* then get to the beginning of the next string looking for possible
* comment
*/
if (mdata->Bos) {
while ((c = getc(file)) != mdata->Bos && c != EOF)
if (mdata->Bcmt && c == mdata->Bcmt[0])
ParseComment(mdata);
} else if (mdata->Bcmt) { /* XPM2 natural */
while ((c = getc(file)) == mdata->Bcmt[0])
ParseComment(mdata);
ungetc(c, file);
}
}
return 0;
}
/*
* skip whitespace and compute the following unsigned int,
* returns 1 if one is found and 0 if not
*/
int
xpmNextUI(xpmData *mdata, unsigned int *ui_return)
{
char buf[BUFSIZ];
int l;
l = xpmNextWord(mdata, buf, BUFSIZ);
return atoui(buf, l, ui_return);
}
/*
* skip whitespace and return the following word
*/
unsigned int
xpmNextWord(xpmData *mdata, char *buf, unsigned int buflen)
{
register unsigned int n = 0;
int c;
if (!mdata->type || mdata->type == XPMBUFFER) {
while (isspace(c = *mdata->cptr) && c != mdata->Eos)
mdata->cptr++;
do {
c = *mdata->cptr++;
*buf++ = c;
n++;
} while (!isspace(c) && c != mdata->Eos && n < buflen);
n--;
mdata->cptr--;
} else {
FILE *file = mdata->stream.file;
while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
while (!isspace(c) && c != mdata->Eos && c != EOF && n < buflen) {
*buf++ = c;
n++;
c = getc(file);
}
ungetc(c, file);
}
return (n);
}
/*
* return end of string - WARNING: malloc!
*/
int
xpmGetString(xpmData *mdata, char **sptr, unsigned int *l)
{
unsigned int i, n = 0;
int c;
char *p, *q, buf[BUFSIZ];
if (!mdata->type || mdata->type == XPMBUFFER) {
if (mdata->cptr) {
char *start;
while (isspace(c = *mdata->cptr) && c != mdata->Eos)
mdata->cptr++;
start = mdata->cptr;
while ((c = *mdata->cptr) && c != mdata->Eos)
mdata->cptr++;
n = mdata->cptr - start + 1;
p = (char *) XpmMalloc(n);
if (!p)
return (XpmNoMemory);
strncpy(p, start, n);
if (mdata->type) /* XPMBUFFER */
p[n - 1] = '\0';
}
} else {
FILE *file = mdata->stream.file;
while ((c = getc(file)) != EOF && isspace(c) && c != mdata->Eos);
if (c == EOF)
return (XpmFileInvalid);
p = NULL;
i = 0;
q = buf;
p = (char *) XpmMalloc(1);
while (c != mdata->Eos && c != EOF) {
if (i == BUFSIZ) {
/* get to the end of the buffer */
/* malloc needed memory */
q = (char *) XpmRealloc(p, n + i);
if (!q) {
XpmFree(p);
return (XpmNoMemory);
}
p = q;
q += n;
/* and copy what we already have */
strncpy(q, buf, i);
n += i;
i = 0;
q = buf;
}
*q++ = c;
i++;
c = getc(file);
}
if (c == EOF) {
XpmFree(p);
return (XpmFileInvalid);
}
if (n + i != 0) {
/* malloc needed memory */
q = (char *) XpmRealloc(p, n + i + 1);
if (!q) {
XpmFree(p);
return (XpmNoMemory);
}
p = q;
q += n;
/* and copy the buffer */
strncpy(q, buf, i);
n += i;
p[n++] = '\0';
} else {
*p = '\0';
n = 1;
}
ungetc(c, file);
}
*sptr = p;
*l = n;
return (XpmSuccess);
}
/*
* get the current comment line
*/
int
xpmGetCmt(xpmData *mdata, char **cmt)
{
if (!mdata->type)
*cmt = NULL;
else if (mdata->CommentLength) {
*cmt = (char *) XpmMalloc(mdata->CommentLength + 1);
strncpy(*cmt, mdata->Comment, mdata->CommentLength);
(*cmt)[mdata->CommentLength] = '\0';
mdata->CommentLength = 0;
} else
*cmt = NULL;
return 0;
}
/*
* open the given file to be read as an xpmData which is returned.
*/
int
xpmReadFile(char *filename, xpmData *mdata)
{
#ifdef ZPIPE
char *compressfile, buf[BUFSIZ];
struct stat status;
#endif
if (!filename) {
mdata->stream.file = (stdin);
mdata->type = XPMFILE;
} else {
#ifdef ZPIPE
if (((int) strlen(filename) > 2) &&
!strcmp(".Z", filename + (strlen(filename) - 2))) {
mdata->type = XPMPIPE;
sprintf(buf, "uncompress -c %s", filename);
if (!(mdata->stream.file = popen(buf, "r")))
return (XpmOpenFailed);
} else if (((int) strlen(filename) > 3) &&
!strcmp(".gz", filename + (strlen(filename) - 3))) {
mdata->type = XPMPIPE;
sprintf(buf, "gunzip -qc %s", filename);
if (!(mdata->stream.file = popen(buf, "r")))
return (XpmOpenFailed);
} else {
if (!(compressfile = (char *) XpmMalloc(strlen(filename) + 4)))
return (XpmNoMemory);
strcpy(compressfile, filename);
strcat(compressfile, ".Z");
if (!stat(compressfile, &status)) {
sprintf(buf, "uncompress -c %s", compressfile);
if (!(mdata->stream.file = popen(buf, "r"))) {
XpmFree(compressfile);
return (XpmOpenFailed);
}
mdata->type = XPMPIPE;
} else {
strcpy(compressfile, filename);
strcat(compressfile, ".gz");
if (!stat(compressfile, &status)) {
sprintf(buf, "gunzip -c %s", compressfile);
if (!(mdata->stream.file = popen(buf, "r"))) {
XpmFree(compressfile);
return (XpmOpenFailed);
}
mdata->type = XPMPIPE;
} else {
#endif
if (!(mdata->stream.file = fopen(filename, "r"))) {
#ifdef ZPIPE
XpmFree(compressfile);
#endif
return (XpmOpenFailed);
}
mdata->type = XPMFILE;
#ifdef ZPIPE
}
}
XpmFree(compressfile);
}
#endif
}
mdata->CommentLength = 0;
return (XpmSuccess);
}
/*
* open the given file to be written as an xpmData which is returned
*/
int
xpmWriteFile(char *filename, xpmData *mdata)
{
#ifdef ZPIPE
char buf[BUFSIZ];
#endif
if (!filename) {
mdata->stream.file = (stdout);
mdata->type = XPMFILE;
} else {
#ifdef ZPIPE
if ((int) strlen(filename) > 2
&& !strcmp(".Z", filename + (strlen(filename) - 2))) {
sprintf(buf, "compress > %s", filename);
if (!(mdata->stream.file = popen(buf, "w")))
return (XpmOpenFailed);
mdata->type = XPMPIPE;
} else if ((int) strlen(filename) > 3
&& !strcmp(".gz", filename + (strlen(filename) - 3))) {
sprintf(buf, "gzip -q > %s", filename);
if (!(mdata->stream.file = popen(buf, "w")))
return (XpmOpenFailed);
mdata->type = XPMPIPE;
} else {
#endif
if (!(mdata->stream.file = fopen(filename, "w")))
return (XpmOpenFailed);
mdata->type = XPMFILE;
#ifdef ZPIPE
}
#endif
}
return (XpmSuccess);
}
/*
* open the given array to be read or written as an xpmData which is returned
*/
void
xpmOpenArray(char **data, xpmData *mdata)
{
mdata->type = XPMARRAY;
mdata->stream.data = data;
mdata->cptr = *data;
mdata->line = 0;
mdata->CommentLength = 0;
mdata->Bcmt = mdata->Ecmt = NULL;
mdata->Bos = mdata->Eos = '\0';
mdata->format = 0; /* this can only be Xpm 2 or 3 */
}
/*
* open the given buffer to be read or written as an xpmData which is returned
*/
void
xpmOpenBuffer(char *buffer, xpmData *mdata)
{
mdata->type = XPMBUFFER;
mdata->cptr = buffer;
mdata->CommentLength = 0;
}
/*
* close the file related to the xpmData if any
*/
int
xpmDataClose(xpmData *mdata)
{
switch (mdata->type) {
case XPMARRAY:
case XPMBUFFER:
break;
case XPMFILE:
if (mdata->stream.file != (stdout) && mdata->stream.file != (stdin))
fclose(mdata->stream.file);
break;
#ifdef ZPIPE
case XPMPIPE:
pclose(mdata->stream.file);
break;
#endif
}
return 0;
}
xpmDataType xpmDataTypes[] =
{
"", "!", "\n", '\0', '\n', "", "", "", "", /* Natural type */
"C", "/*", "*/", '"', '"', ",\n", "static char *", "[] = {\n", "};\n",
"Lisp", ";", "\n", '"', '"', "\n", "(setq ", " '(\n", "))\n",
#ifdef VMS
NULL
#else
NULL, NULL, NULL, 0, 0, NULL, NULL, NULL, NULL
#endif
};
/*
* parse xpm header
*/
int
xpmParseHeader(xpmData *mdata)
{
char buf[BUFSIZ];
int l, n = 0;
if (mdata->type) {
mdata->Bos = '\0';
mdata->Eos = '\n';
mdata->Bcmt = mdata->Ecmt = NULL;
l = xpmNextWord(mdata, buf, BUFSIZ);
if (l == 7 && !strncmp("#define", buf, 7)) {
/* this maybe an XPM 1 file */
char *ptr;
l = xpmNextWord(mdata, buf, BUFSIZ);
if (!l)
return (XpmFileInvalid);
ptr = strchr(buf, '_');
if (!ptr || strncmp("_format", ptr, l - (ptr - buf)))
return XpmFileInvalid;
/* this is definitely an XPM 1 file */
mdata->format = 1;
n = 1; /* handle XPM1 as mainly XPM2 C */
} else {
/*
* skip the first word, get the second one, and see if this is
* XPM 2 or 3
*/
l = xpmNextWord(mdata, buf, BUFSIZ);
if ((l == 3 && !strncmp("XPM", buf, 3)) ||
(l == 4 && !strncmp("XPM2", buf, 4))) {
if (l == 3)
n = 1; /* handle XPM as XPM2 C */
else {
/* get the type key word */
l = xpmNextWord(mdata, buf, BUFSIZ);
/*
* get infos about this type
*/
while (xpmDataTypes[n].type
&& strncmp(xpmDataTypes[n].type, buf, l))
n++;
}
mdata->format = 0;
} else
/* nope this is not an XPM file */
return XpmFileInvalid;
}
if (xpmDataTypes[n].type) {
if (n == 0) { /* natural type */
mdata->Bcmt = xpmDataTypes[n].Bcmt;
mdata->Ecmt = xpmDataTypes[n].Ecmt;
xpmNextString(mdata); /* skip the end of the headerline */
mdata->Bos = xpmDataTypes[n].Bos;
mdata->Eos = xpmDataTypes[n].Eos;
} else {
mdata->Bcmt = xpmDataTypes[n].Bcmt;
mdata->Ecmt = xpmDataTypes[n].Ecmt;
if (!mdata->format) { /* XPM 2 or 3 */
mdata->Bos = xpmDataTypes[n].Bos;
mdata->Eos = '\0';
/* get to the beginning of the first string */
xpmNextString(mdata);
mdata->Eos = xpmDataTypes[n].Eos;
} else /* XPM 1 skip end of line */
xpmNextString(mdata);
}
} else
/* we don't know about that type of XPM file... */
return XpmFileInvalid;
}
return XpmSuccess;
}