Komisches Verhalten

stefan2008

Hallo Zusammen!

Ich habe einen eigenen e-Wörterbuch für KDE geschrieben mit GPL-Lizenz. Das Programm hat beim kompilieren kein Fehler angezeigt und schien mit der Shell-Konsole recht gut zu funktionieren. Aber mir ist aufgefallen, sobald ich die Anwendung per Dolphin mit Doppeltklick öffnen wollte, gab es keine Reaktion. Erst duch intensives suchen habe ich gemerkt, dass es etwas mit mein filestream zu tuen hat. Ich habe versucht alle Codes, die mein filestream auszukomentieren. Danach konnte ich die Anwendung per Dolphin öffnen. Das blöde ist aber, dass ich mein filestream benötige, um bestimmte Bilddateien für die Menüleiste und Audiodateien für die Aussprache benötige. Hat einer eine Idee wo sich der Fehler in den folgenden Dateien befindet? Ich finde es schon räzelhaft, dass in der Shell-Konsole kein Fehler auftritt und alles in Ordnung scheint und es auf der andere Seite Probleme mit den direckten starten bei Dolphin gibt.

filestream.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srFileStream-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srFileStream_h_
#define _srFileStream_h_

#include <wx/textfile.h>
#include <wx/string.h>

class srFileStream : public wxTextFile
{
	private:
		int lines;
		wxString label;
	public:
		srFileStream();
		~srFileStream();
		bool Close();
		bool Open(const wxString &filename);
		int GetLines();
		const wxString& ReadCell(unsigned int row, unsigned int column);
		const wxString& ReadCellItem(unsigned int row, unsigned int column, unsigned int item);
		const wxString& ReadData(const wxString &data, unsigned int line);
		const wxString& ReadLine(unsigned int line);
};

#endif

filestream.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srFileStream-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "filestream.h"

srFileStream::srFileStream()
{
}

srFileStream::~srFileStream()
{
}

bool srFileStream::Close()
{
////////////////////////////////////////////////////////////////////////////////
/// Filestream beenden
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxTextFile::Close();
	return TRUE;
	////////////////////////////////////////
}

bool srFileStream::Open(const wxString &filename)
{
////////////////////////////////////////////////////////////////////////////////
/// Filestream starten
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	if(wxFile::Exists(filename))
	{
		wxTextFile::Open(filename);
		return TRUE;
	}
	else
	{
		return FALSE;
	}
	////////////////////////////////////////
}

int srFileStream::GetLines()
{
////////////////////////////////////////////////////////////////////////////////
/// Zeilennummer auslesen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->lines = wxTextFile::GetLineCount();
	return this->lines;
	////////////////////////////////////////
}

const wxString& srFileStream::ReadCell(unsigned int row, unsigned int column)
{
////////////////////////////////////////////////////////////////////////////////
/// Eine Zelle auslesen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	unsigned int pos;
	wxString buffer = this->ReadLine(row);
	for(unsigned int c = 0; c <= column; c++)
	{
		pos = buffer.Find(wxT(";"));
		this->label = buffer.SubString(0, (pos-1));
		buffer = buffer.SubString((pos+1), buffer.Length());
	}
	return this->label;
	////////////////////////////////////////
}

const wxString& srFileStream::ReadCellItem(unsigned int row, unsigned int column,
unsigned int item)
{
////////////////////////////////////////////////////////////////////////////////
/// Einzelne Daten aus einer Zelle auslesen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	unsigned int pos;
	wxString buffer = this->ReadCell(row, column);
	for(unsigned int c = 0; c <= item; c++)
	{
		pos = buffer.Find(wxT(", "));
		this->label = buffer.SubString(0, (pos-1));
		buffer = buffer.SubString((pos+2), buffer.Length());
	}
	return this->label;
	////////////////////////////////////////
}

const wxString& srFileStream::ReadData(const wxString &data, unsigned int line)
{
////////////////////////////////////////////////////////////////////////////////
/// Pfad der gesuchten Datei auslesen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxString buffer = this->ReadLine(line);
	this->label = buffer.SubString((data.Length()+1), buffer.Length());
	return this->label;
	////////////////////////////////////////
}

const wxString& srFileStream::ReadLine(unsigned int line)
{
////////////////////////////////////////////////////////////////////////////////
/// Ganze Zeile auslesen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->label = wxTextFile::GetLine(line);
	return this->label;
	////////////////////////////////////////
}

Ist die Pathangabe absolut oder relativ ?

Mach doch mal eine Debug Ausgabe des Path .

Gruss

Das ist ja grausam, die ganzen Kommentare verhindern ein einigermaßen zügiges Lesen, sind unnötig und falsch (Filestream starten != open(), countLines() != Zeilennummer auslesen)
Außerdem ist Vererbung hier nicht der richtige Ansatz, zumal du Funktionen wahrscheinlich in ähnlicher Weise implementierst wie es eh schon der Fall ist (z.B. open() und close(), ich kenn wxWidgets nicht, bei Qt liefert open eh nen bool zurück, der bool bei close ist unnötig...)

Im übrigen, wenn du ein e-Wörterbuch für KDE geschrieben hast, suche ich wohl vergeblich die Verwendung von KDE und Qt...

Bei der Lösung des Problems solltest du dir mal das Working-Directory anschauen. Du wirst beim Starten annemhmen, dass "./" == das directory, in dem die bin liegt, ist aber beim Starten aus dem Dolphin nicht gesichert der Fall, ich tippe da auf "~/". Keine Ahnung wie du in wxWidgets das aktuelle Arbeitsverzeichnis einstellen kannst, oder den binaryPath bekommst. -> wx-Doku.

stefan2008

Es mag sein, dass nicht alle Kommentare von der Wortwahl ausgesehen zutreffend sind. Aber zumindest schreibe ich Kommentare und versuche mein Quelltext so übersichtlich und objektorentirt wie möglich zu halten. Der Kdbg zeigt im Stack-Register folgende Meldung an:

wxStringBase::operator=() from /usr/lib64/libwx_base-2.8.so.0
wxString::operator=(this=0x2312580) at /usr/include/wx-2.8/wx/string.h:660
srFileStream::ReadLine(this=0x2312520,line=1) at filestream.cpp:177
srFileStream::ReadData(this=0x2312520,data=@0x7fffe4b6c620,line=1) at filestream.cpp:104
srFrame(this=0x87d830,parent=0x0,id=-1,[...]) at frame.cpp:19
srBase::OnInit(this=0x79d290) at base.cpp:17
wxAppConsole::CallOnInit(this=0x79d290) at /usr/include/wx-2.8/wx/app.h:76
wxEntry() from /usr/lib64/libwx_base-2.8.so.0
main(argc=1,argv=@0x7fffe4b6c620) at base.cpp:8

Hier unten steht eine kleine Auswahl meiner Quelltexte fürs bessere Verständnis. Wie anfangs beschrieben, funktioniert der direckte Start per Mausklick in Dolphin nur, wenn ich die Filestream-Anweisungen auskommentiere und die anderen Dialogfenster, die auch das Filestream verwende abstelle. - Ich gebe zu, an einigen stellen könnte ich noch was verbessern, aber das Programm befindet sich noch im Bau. Die Kommentare, die hier kritisiert werden, werde ich auch bald ändern. Ich möchte mich aber erst um das Hauptproblem kömmern, was mir wichtiger erscheint.

config.dat:

#Icon
icon=/home/stefan/C++/srbib/icons/32x32/srbib.png

#Bitmap 16x16
about=/home/stefan/C++/srbib/icons/16x16/about.png
bug=/home/stefan/C++/srbib/icons/16x16/bug.png
close=/home/stefan/C++/srbib/icons/16x16/close.png
hint=/home/stefan/C++/srbib/icons/16x16/hint.png

#Bitmap 21x21
audio=/home/stefan/C++/srbib/icons/21x21/audio.png

[Bitmap 32x32]
bug=/home/stefan/C++/srbib/icons/32x32/bug.png

#Bitmap 62x75
book=/home/stefan/C++/srbib/icons/62x75/book.png

#Bitmap 128x128
hint=/home/stefan/C++/srbib/icons/128x128/hint.png

#Database
audio=/home/stefan/C++/srbib/audio/
book=/home/stefan/C++/srbib/data/book.csv
hint=/home/stefan/C++/srbib/data/hint.txt
licence=/home/stefan/C++/srbib/data/licence.txt

Makefile:

CC =		g++
CFLAGS =	`wx-config --cppflags`
CLIBS =		`wx-config --libs --gl-libs`
BINARY =	srbib.out
DEBUG =		srbib-dbg.out
OBJECTS =	aboutdlg.o base.o booklabel.o bugdlg.o filestream.o frame.o hintdlg.o licencedlg.o splitter.o
SOURCES =	aboutdlg.cpp base.cpp booklabel.cpp bugdlg.cpp filestream.cpp frame.cpp hintdlg.cpp licencedlg.cpp splitter.cpp

build:
	@echo
	@echo "Bibliothek 1.0 (Standard-Modus)"
	@echo
	@echo "Das Anwendungsprogramm 'srbib.out' wird mit den C++-Kompiler erstellt."
	@echo "Einige Komponenten der Bibliothek 'wxWidgets' werden eingebunden, um die"
	@echo "GUI zu erstellen.(C) Copyright 2009"
	@echo
	@echo "Die Objektdateien werden kompiliert ..."
	$(CC) -c $(CFLAGS) aboutdlg.cpp
	$(CC) -c $(CFLAGS) base.cpp
	$(CC) -c $(CFLAGS) booklabel.cpp
	$(CC) -c $(CFLAGS) bugdlg.cpp
	$(CC) -c $(CFLAGS) filestream.cpp
	$(CC) -c $(CFLAGS) frame.cpp
	$(CC) -c $(CFLAGS) hintdlg.cpp
	$(CC) -c $(CFLAGS) licencedlg.cpp
	$(CC) -c $(CFLAGS) splitter.cpp
	@echo
	@echo "Das Anwendungsprogramm wird gelinkt ..."
	$(CC) -o $(BINARY) $(CLIBS) $(OBJECTS) -lwx_gtk2_richtext-2.8
	@echo

debug:
	@echo
	@echo "Bibliothek 1.0 (Debug-Modus)"
	@echo
	@echo "Das Anwendungsprogramm 'srbib-dbg.out' wird mit den C++-Kompiler erstellt."
	@echo "Einige Komponenten der Bibliothek 'wxWidgets' werden eingebunden, um die"
	@echo "GUI zu erstellen.(C) Copyright 2009"
	@echo
	@echo "Die Objektdateien werden kompiliert ..."
	$(CC) -g -c $(CFLAGS) aboutdlg.cpp
	$(CC) -g -c $(CFLAGS) base.cpp
	$(CC) -g -c $(CFLAGS) booklabel.cpp
	$(CC) -g -c $(CFLAGS) bugdlg.cpp
	$(CC) -g -c $(CFLAGS) filestream.cpp
	$(CC) -g -c $(CFLAGS) frame.cpp
	$(CC) -g -c $(CFLAGS) hintdlg.cpp
	$(CC) -g -c $(CFLAGS) licencedlg.cpp
	$(CC) -g -c $(CFLAGS) splitter.cpp
	@echo
	@echo "Das Anwendungsprogramm wird gelinkt ..."
	$(CC) -g -o $(DEBUG) $(CLIBS) $(OBJECTS) -lwx_gtk2_richtext-2.8
	@echo
	@echo "Die Objektdateien werden entfernt ..."
	shred -uvn 20 aboutdlg.o
	shred -uvn 20 base.o
	shred -uvn 20 booklabel.o
	shred -uvn 20 bugdlg.o
	shred -uvn 20 filestream.o
	shred -uvn 20 frame.o
	shred -uvn 20 hintdlg.o
	shred -uvn 20 licencedlg.o
	shred -uvn 20 splitter.o
	@echo
	@echo "Das Anwendungsprogramm wird installiert ..."
	mv $(DEBUG) ../bin
	@echo

deinstall:
	@echo
	@echo "Die Objektdateien werden entfernt ..."
	shred -uvn 20 ../obj/aboutdlg.o
	shred -uvn 20 ../obj/base.o
	shred -uvn 20 ../obj/booklabel.o
	shred -uvn 20 ../obj/bugdlg.o
	shred -uvn 20 ../obj/filestream.o
	shred -uvn 20 ../obj/frame.o
	shred -uvn 20 ../obj/hintdlg.o
	shred -uvn 20 ../obj/licencedlg.o
	shred -uvn 20 ../obj/splitter.o
	@echo "Das Anwendungsprogramm wird entfernt ..."
	shred -uvn 20 ../bin/$(BINARY)
	@echo

delete:
	shred -uvn 20 ../bin/$(DEBUG)

install:
	@echo
	@echo "Die Objektdateien werden installiert ..."
	mv aboutdlg.o ../obj
	mv base.o ../obj
	mv booklabel.o ../obj
	mv bugdlg.o ../obj
	mv filestream.o ../obj
	mv frame.o ../obj
	mv hintdlg.o ../obj
	mv licencedlg.o ../obj
	mv splitter.o ../obj
	@echo
	@echo "Das Anwendungsprogramm wird installiert ..."
	mv $(BINARY) ../bin
	@echo

remove:
	@echo
	@echo "Die Objektdateien werden entfernt ..."
	shred -uvn 20 aboutdlg.o
	shred -uvn 20 base.o
	shred -uvn 20 booklabel.o
	shred -uvn 20 bugdlg.o
	shred -uvn 20 filestream.o
	shred -uvn 20 frame.o
	shred -uvn 20 hintdlg.o
	shred -uvn 20 licencedlg.o
	shred -uvn 20 splitter.o
	@echo "Das Anwendungsprogramm wird entfernt ..."
	shred -uvn 20 $(BINARY)
	@echo

refresh:
	@echo
	@echo "Alte Dateien werden entfernt ..."
	shred -uvn 20 *~
	@echo

base.h:

////////////////////////////////////////////////////////////////////////////////
/// Die wxWidgets-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srBase_h_
#define _srBase_h_

#include <iostream>
#include <wx/app.h>

class srBase : public wxApp
{
	public:
		virtual bool OnInit();
};

#endif

base.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die wxWidgets-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "base.h"
#include "frame.h"

IMPLEMENT_APP(srBase)

bool srBase::OnInit()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	srFrame *frame = new srFrame(NULL);
	this->SetTopWindow(frame);

	if(this->argc > 1)
	{
		wxString option = argv[1];
		switch(argc)
		{
			case 2:
				if(option == wxT("--ausgabe"))
				{
					std::cout << "Ausgabe 1.0\n";
				}
				else
				{
					if(option == wxT("--autor"))
					{
						std::cout << "***@web.de>\n";
					}
					else
					{
						  if(option == wxT("--hilfe"))
						  {
							  std::cout << "Aufruf: ./srbib.out [Option]\n\nBibliothek 1.0\n\n";
							  std::cout << "Allgemeine Optionen:\n  --autor\tAutor-Information anzeigen\n";
							  std::cout << "  --ausgabe\tAusgabe-Informationen anzeigen\n";
							  std::cout << "  --hilfe\tHilfe zu verfügbaren Optionen anzeigen\n";
						  }
						  else
						  {
							  std::cout << "HINWEIS: Die angebene Option wurde nicht erkannt!\n";
						  }
					}
				}
				break;
			default:
				std::cout << "HINWEIS: Nur eine Option ist erlaubt!\n";
		}
		frame->Destroy();
	}
	else
	{
		frame->Show(TRUE);
	}

	return TRUE;
	////////////////////////////////////////
}

default.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srDefines-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srDefines_h_
#define _srDefines_h_

enum
{
	srID_ABOUT,
	srID_BACK,
	srID_BITMAP,
	srID_BOOKLABEL,
	srID_BUG,
	srID_CLOSE,
	srID_DIALOG,
	srID_HINT,
	srID_HYPERLINK,
	srID_LISTBOX,
	srID_NEXT,
	srID_NOTEBOOK,
	srID_OK,
	srID_PANEL,
	srID_RICHTEXTCTRL,
	srID_SPLITTERWINDOW,
	srID_STATBITMAP,
	srID_STATLINE,
	srID_STATTEXT,
	srID_TEXT
};

#endif

frame.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srFrame-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srFrame_h_
#define _srFrame_h_

#include <wx/colour.h>
#include <wx/font.h>
#include <wx/frame.h>
#include <wx/gdicmn.h>
#include <wx/settings.h>
#include <wx/string.h>

#include <wx/bitmap.h>
#include <wx/event.h>
#include <wx/icon.h>
#include <wx/image.h>
#include <wx/menu.h>
#include <wx/msgdlg.h>
#include <wx/panel.h>
#include <wx/sizer.h>
#include <wx/statusbr.h>
#include "aboutdlg.h"
#include "bugdlg.h"
#include "defines.h"
#include "filestream.h"
#include "hintdlg.h"
#include "splitter.h"

class srFrame : public wxFrame
{
	private:
		srAboutDialog *srAbout;
		srBugDialog *srBug;
		srFileStream *srFile;
		srHintDialog *srHint;
		srSplitterWindow *srSplitter;
		wxBoxSizer *srBoxSizer;
		wxMenuBar *srMenuBar;
		wxMenu *srMenu[2];
		wxMenuItem *srMenuItem[4];
		wxStatusBar *srStatusBar;
	protected:
		virtual void OnClose(wxCloseEvent &event);
		virtual void OnQuit(wxCommandEvent &event);
		virtual void OnShowAbout(wxCommandEvent &event);
		virtual void OnShowBug(wxCommandEvent &event);
		virtual void OnShowHint(wxCommandEvent &event);
	public:
		srFrame(wxWindow *parent, wxWindowID id = wxID_ANY, const wxString &title =
		wxT("Bibliothek 1.0"), const wxPoint &pos = wxDefaultPosition,
		const wxSize &size = wxSize(640, 480), long style = wxDEFAULT_FRAME_STYLE,
		const wxString &name = wxT("srFrame"));
		~srFrame();
		int GetHeight();
		int GetWidth();
};

#endif

frame.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srFrame-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "frame.h"

srFrame::srFrame(wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size, long style, const wxString &name)
: wxFrame(parent, id, title, pos, size, style, name)
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srFile = new srFileStream();
	this->srFile->Open(wxT("config.dat"));

	this->SetIcon(wxIcon(srFile->ReadData(wxT("icon"), 1)));

	this->srAbout = new srAboutDialog(this);
	this->srBug = new srBugDialog(this);
	this->srHint = new srHintDialog(this);

	this->SetSizeHints(wxDefaultSize, wxDefaultSize);
	this->srBoxSizer = new wxBoxSizer(wxVERTICAL);

	this->srSplitter = new srSplitterWindow(this, srID_SPLITTERWINDOW);

	this->srBoxSizer->Add(srSplitter, 1, wxEXPAND, 5);

	this->SetSizer(srBoxSizer);
	this->Layout();
	////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// Das Menübar
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srMenuBar = new wxMenuBar();

	this->srMenu[0] = new wxMenu();
	this->srMenu[1] = new wxMenu();

	this->srMenuItem[0] = new wxMenuItem(this->srMenu[0], srID_CLOSE,
	wxString(wxT("B&eenden\tCtrl+Q")), wxT("Anwendungsprogramm beenden"), wxITEM_NORMAL);
	this->srMenuItem[1] = new wxMenuItem(this->srMenu[1], srID_HINT,
	wxString(wxT("&Tipp des Tages\tCtrl+T")), wxT("Tipp des Tages anzeigen"), wxITEM_NORMAL);
	this->srMenuItem[2] = new wxMenuItem(this->srMenu[1], srID_BUG,
	wxString(wxT("&Probleme oder Wünsche berichten ...\tCtrl+W")), wxT("Problembericht einschicken"),
	wxITEM_NORMAL);
	this->srMenuItem[3] = new wxMenuItem(this->srMenu[1], srID_ABOUT,
	wxString(wxT("Über Stefan &Rauch Bibliothek\tCtrl+R")),
	wxT("Informationen über Bibliothek anzeigen"), wxITEM_NORMAL);

	this->srMenuItem[0]->SetBitmap(wxBitmap(srFile->ReadData(wxT("close"), 6)));
	this->srMenuItem[1]->SetBitmap(wxBitmap(srFile->ReadData(wxT("hint"), 7)));
	this->srMenuItem[2]->SetBitmap(wxBitmap(srFile->ReadData(wxT("bug"), 5)));
	this->srMenuItem[3]->SetBitmap(wxBitmap(srFile->ReadData(wxT("about"), 4)));

	this->srMenu[0]->Append(this->srMenuItem[0]);
	this->srMenu[1]->Append(this->srMenuItem[1]);
	this->srMenu[1]->Append(this->srMenuItem[2]);
	this->srMenu[1]->AppendSeparator();
	this->srMenu[1]->Append(this->srMenuItem[3]);

	this->srMenuBar->Append(this->srMenu[0], wxT("&Datei"));
	this->srMenuBar->Append(this->srMenu[1], wxT("&?"));

	this->SetMenuBar(this->srMenuBar);
	////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// Das Statusbar
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxString buffer;
	buffer.Printf(wxT("%d Einträge"), this->srSplitter->GetItems());

	this->srStatusBar = this->CreateStatusBar(1, wxST_SIZEGRIP, wxID_ANY);
	this->srStatusBar->SetStatusText(buffer, 0);
	////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// Die Connect-Ereignisse
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->Connect(wxEVT_CLOSE_WINDOW, wxCloseEventHandler(srFrame::OnClose));
	this->Connect(srID_CLOSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnQuit));
	this->Connect(srID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnShowAbout));
	this->Connect(srID_BUG, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnShowBug));
	this->Connect(srID_HINT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnShowHint));
	////////////////////////////////////////
}

srFrame::~srFrame()
{
////////////////////////////////////////////////////////////////////////////////
/// Filestream beenden
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srFile->Close();
	////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/// Die Disconnect-Ereignisse
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->Disconnect(srID_HINT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnShowHint));
	this->Disconnect(srID_BUG, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnShowBug));
	this->Disconnect(srID_ABOUT, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnShowAbout));
	this->Disconnect(srID_CLOSE, wxEVT_COMMAND_MENU_SELECTED, wxCommandEventHandler(srFrame::OnQuit));
	this->Disconnect(wxEVT_CLOSE_WINDOW, wxCloseEventHandler(srFrame::OnClose));
	////////////////////////////////////////
}

int srFrame::GetHeight()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Hoehen-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->GetSize().y;
	////////////////////////////////////////
}

int srFrame::GetWidth()
{
////////////////////////////////////////////////////////////////////////////////
/// Der Breiten-Akzessor
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	return this->GetSize().x;
	////////////////////////////////////////
}

void srFrame::OnClose(wxCloseEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// Anwendungsprogramm beenden
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	if(event.CanVeto())
	{
		wxMessageDialog *msgDialog = new wxMessageDialog(this,
		wxT("Wollen Sie das Anwendungsprogramm von\nwirklich beenden?"),
		wxT("Eine Frage an Sie"), (wxYES_NO|wxNO_DEFAULT|wxICON_QUESTION));

		int result = msgDialog->ShowModal();
		msgDialog->Destroy();

		if(result == wxID_NO)
		{
			event.Veto();
		}
		else
		{
			this->Destroy();
		}
	}
	else
	{
		this->Destroy();
	}
	////////////////////////////////////////
}

void srFrame::OnQuit(wxCommandEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// Anwendungsprogramm verlassen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->Close();
	////////////////////////////////////////
}

void srFrame::OnShowAbout(wxCommandEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// Informaionen über Bibliothek anzeigen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srAbout->ShowModal();
	////////////////////////////////////////
}

void srFrame::OnShowBug(wxCommandEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// Problembericht einschicken
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srBug->ShowModal();
	////////////////////////////////////////
}

void srFrame::OnShowHint(wxCommandEvent &event)
{
////////////////////////////////////////////////////////////////////////////////
/// Tipp des Tages anzeigen
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	this->srHint->ShowModal();
	////////////////////////////////////////
}

Nochmal:

unruhestifter schrieb:

Bei der Lösung des Problems solltest du dir mal das Working-Directory anschauen. Du wirst beim Starten annemhmen, dass "./" == das directory, in dem die bin liegt, ist aber beim Starten aus dem Dolphin nicht gesichert der Fall, ich tippe da auf "~/". Keine Ahnung wie du in wxWidgets das aktuelle Arbeitsverzeichnis einstellen kannst, oder den binaryPath bekommst. -> wx-Doku.

Ich hab keine Ahnung wie du an diese Infos per wxWidgets rankommst. Mit Qt schaut das so aus:

#include <QApplication>
#include <QDir>
#include <QLabel>
#include <QString>

int main( int argc, char** argv)
{
    QApplication app(argc, argv);
    QString msg = "application path: " + QApplication::applicationDirPath();
    msg += "<br>current workingdir: " + QDir::currentPath();
    QLabel lbl(msg);
    lbl.show();
    return app.exec();
}

Ausgabe wenn ich es in der Konsole starte:

application path: /home/unruhestifter/Programmieren/C++/tests/c-plusplus-forum/249239_workingDir
current workingdir: /home/unruhestifter/Programmieren/C++/tests/c-plusplus-forum/249239_workingDir

Und aus dem Filemanager:

application path: /home/unruhestifter/Programmieren/C++/tests/c-plusplus-forum/249239_workingDir
current workingdir: /home/unruhestifter/Documents

Und genau das ist dein Problem!! Du musst dir aus dem applicationDirPath * deiner Config/Resourcen usw den absoluten Pfad zur Datei zusammenkleben. Denn deine Resourcen werden durch Klick im Dolphin in deinem Default-Document-Directory (hier ~/Documents) gesucht!

Das war jetzt eigentlich zu ausfühtlich, hoffe es ist aber angekommen.

Im übrigen ist es unklug, alle Member, die nicht unbedingt als Pointer vorliegen müssen als normale auto-Variablen zu nehmen. Und wenn manpointer nimmt sollte man sie auch im Destruktor geordnet über den Jordan schicken.

Und mit übermäßigem Gebrauch an Kommentaren wird dein Source auch nicht verständlicher. Methoden sollten selbsterklärend sein, lediglich Besonderheiten oder Seiteneffekte sind erwähnenswert.

Und eigentlich ist das Ableiten (um es zu wiederholen) von wxTextFile unnötig, nimm das doch als Member deiner Klasse und operier auf diesem Objekt. Ableitung ist hier (aus meinen Augen) fehl am Platz, es handelt sich um keine wirkliche Spezialisierung.

Und jetzt hab ich die Anregungen hinten angestellt und den Tip vorne weg, dass du den auch wirklich liest

Um dir die Suche zu ersparen:
http://docs.wxwidgets.org/stable/wx_filefunctions.html#wxgetcwd
http://docs.wxwidgets.org/stable/wx_wxstandardpaths.html#wxstandardpathsgetexecutablepath

stefan2008

Du hast Recht, Dolphin sucht im Dokumentenverzeichnis nach. Damit habe ich überhaupt nicht gerechnet. Jetzt ergibt das Ganze für mich ein Sinn. Danke für deine Mühe! Ich sehe, es gibt noch einige Dinge, die ich bachten muss. Als dankeschön, findest Du unten die Quelltexte für den Testprogramm (für das wxWidgets-Framework).

base.h:

////////////////////////////////////////////////////////////////////////////////
/// Die wxWidgets-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srBase_h_
#define _srBase_h_

#include <iostream>
#include <wx/app.h>

class srBase : public wxApp
{
	public:
		virtual bool OnInit();
};

#endif

base.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die wxWidgets-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include "base.h"
#include "frame.h"

IMPLEMENT_APP(srBase)

bool srBase::OnInit()
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	srFrame *frame = new srFrame(NULL);
	this->SetTopWindow(frame);
	frame->Show(TRUE);
	return TRUE;
	////////////////////////////////////////
}

frame.h:

////////////////////////////////////////////////////////////////////////////////
/// Die srFrame-Schablone
////////////////////////////////////////////////////////////////////////////////

#ifndef _srFrame_h_
#define _srFrame_h_

#include <wx/colour.h>
#include <wx/font.h>
#include <wx/frame.h>
#include <wx/gdicmn.h>
#include <wx/settings.h>
#include <wx/string.h>

#include <wx/panel.h>
#include <wx/sizer.h>
#include <wx/stattext.h>

#include <wx/filefn.h>
#include <wx/stdpaths.h>
#include <wx/string.h>

class srFrame : public wxFrame
{
	private:
		wxBoxSizer *srBoxSizer[2];
		wxStaticText *srStaticText[2];
		wxPanel *srPanel;
	public:
		srFrame(wxWindow *parent, wxWindowID id = wxID_ANY, const wxString &title =
		wxT("Dolphin Test"), const wxPoint &pos = wxDefaultPosition,
		const wxSize &size = wxSize(640, 480), long style = wxDEFAULT_FRAME_STYLE,
		const wxString &name = wxT("srFrame"));
		~srFrame();
};

#endif

frame.cpp:

////////////////////////////////////////////////////////////////////////////////
/// Die srFrame-Implementierung
////////////////////////////////////////////////////////////////////////////////

#include "frame.h"

srFrame::srFrame(wxWindow *parent, wxWindowID id, const wxString &title,
const wxPoint &pos, const wxSize &size, long style, const wxString &name)
: wxFrame(parent, id, title, pos, size, style, name)
{
////////////////////////////////////////////////////////////////////////////////
/// Die Konfiguration
////////////////////////////////////////////////////////////////////////////////

	////////////////////////////////////////
	wxString buffer;
	wxStandardPaths stdpath;
	this->SetSizeHints(wxDefaultSize, wxDefaultSize);
	this->srBoxSizer[0] = new wxBoxSizer(wxVERTICAL);
	this->srBoxSizer[1] = new wxBoxSizer(wxVERTICAL);

	this->srPanel = new wxPanel(this, wxID_ANY);

	this->srStaticText[0] = new wxStaticText(srPanel, wxID_ANY, wxEmptyString);
	this->srStaticText[1] = new wxStaticText(srPanel, wxID_ANY, wxEmptyString);

	this->srStaticText[0]->Wrap(-1);
	this->srStaticText[1]->Wrap(-1);

	buffer.Printf(wxT("Binary Path: %s"), stdpath.GetExecutablePath().c_str());
	this->srStaticText[0]->SetLabel(buffer);

	buffer.Printf(wxT("Current Path: %s"), wxGetCwd().c_str());
	this->srStaticText[1]->SetLabel(buffer);

	this->srBoxSizer[1]->Add(srStaticText[0], 0, wxEXPAND, 5);
	this->srBoxSizer[1]->Add(srStaticText[1], 0, wxEXPAND, 5);

	this->srPanel->SetSizer(srBoxSizer[1]);
	this->srPanel->Layout();

	this->srBoxSizer[1]->Fit(srPanel);

	this->srBoxSizer[0]->Add(srPanel, 1, wxEXPAND, 5);

	this->SetSizer(srBoxSizer[0]);
	this->Layout();
	////////////////////////////////////////
}

srFrame::~srFrame()
{
}

Jetzt muss ich nur noch herraus finden, welches Pfad unter Microsfot Windows als Standard definiert ist, damit ich später meine Quelltexte entsprechend mit MinGW weitergeben kann. Microsoft Windows habe ich schon seit 2 Jahre nicht mehr benutzt. Auf mein Notebook ist nur Linux drauf, deshalb kann ich es nicht einschätzen wie es mit Microsfot Windows ausschaut.