Weiter Zurück Inhaltsverzeichnis
Das Beispiel Tarball ist lokal installiert und Sie können es sich in Ihr Homeverzeichnis kopieren, auspacken und testen. Nachdem
Sie das Paket mit tar zxvf kscribble-1.0.tar.gz ausgepackt haben, rufen Sie "Automake und Autoconf" aus dem "Erstellen"
Menü in KDevelop auf. Dann führen Sie "Configure" aus dem gleichen Menü aus. Die Configure-Optionen sind die meiner KDE 2 und Qt
2.1 Installation, Sie müssen sie also manuell bearbeiten, so das Sie zu Ihren Pfaden passen.
$(KDEDIR)/share/apps/kdevelop/examples/kscribble-1.0.tar.gz
/***************************************************************************
main.cpp - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include <kcmdlineargs.h>
#include <kaboutdata.h>
#include <klocale.h>
#include "kscribble.h"
static const char *description =
I18N_NOOP("KDE 2 example application");
static KCmdLineOptions options[] =
{
{ "+[File]", I18N_NOOP("image file to open"), 0 },
{ 0, 0, 0 }
};
int main(int argc, char *argv[])
{
KAboutData aboutData( "kscribble", I18N_NOOP("KScribble"),
VERSION, description, KAboutData::License_GPL,
"(c) 2000, Ralf Nolden");
aboutData.addAuthor("Ralf Nolden",0, "rnolden@kdevelop.de");
KCmdLineArgs::init( argc, argv, &aboutData );
KCmdLineArgs::addCmdLineOptions( options ); // Add our own options.
KApplication app;
KImageIO::registerFormats();
if (app.isRestored())
{
RESTORE(KScribbleApp);
}
else
{
KScribbleApp *kscribble = new KScribbleApp();
kscribble->show();
KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
if (args->count())
for(int i=0;i<args->count();i++)
kscribble->openDocumentFile(args->arg(i));
else
kscribble->openDocumentFile();
args->clear();
}
return app.exec();
}
/***************************************************************************
kscribble.h - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef KSCRIBBLE_H
#define KSCRIBBLE_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
// include files for Qt
#include <qstrlist.h>
#include <qworkspace.h>
// include files for KDE
#include <kapp.h>
#include <ktmainwindow.h>
#include <kaccel.h>
#include <kimgio.h>
// forward declaration of the KScribble classes
class KScribbleDoc;
class KScribbleView;
/**
* The base class for KScribble application windows. It sets up the main
* window and reads the config file as well as providing a menubar, toolbar
* and statusbar. In initView(), your main view is created as the MDI child window manager.
* Child windows are created in createClient(), which gets a document instance as it's document to
* display whereby one document can have several views.The MDI child is an instance of KScribbleView,
* the document an instance of KScribbleDoc.
* KScribbleApp reimplements the methods that KTMainWindow provides for main window handling and supports
* full session management as well as keyboard accelerator configuration by using KAccel.
* @see KTMainWindow
* @see KApplication
* @see KConfig
* @see KAccel
*
* @author Source Framework Automatically Generated by KDevelop, (c) The KDevelop Team.
* @version KDevelop version 1.1 code generation
*/
class KScribbleApp : public KTMainWindow
{
Q_OBJECT
public:
/** construtor of KScribbleApp, calls all init functions to create the application.
* @see initMenuBar initToolBar
*/
KScribbleApp();
~KScribbleApp();
/** enables menuentries/toolbar items
*/
void enableCommand(int id_);
/** disables menuentries/toolbar items
*/
void disableCommand(int id_);
/** opens a file specified by commandline option
*/
void openDocumentFile(const char *file=0);
protected:
/** queryClose is called by KTMainWindow on each closeEvent of a window. Against the
* default implementation (only returns true), this overridden function retrieves all modified documents
* from the open document list and asks the user to select which files to save before exiting the application.
* @see KTMainWindow#queryClose
* @see KTMainWindow#closeEvent
*/
virtual bool queryClose();
/** queryExit is called by KTMainWindow when the last window of the application is going to be closed
* during the closeEvent().
* Against the default implementation that just returns true, this calls saveOptions() to save the
* settings of the last window's properties.
* @see KTMainWindow#queryExit
* @see KTMainWindow#closeEvent
*/
virtual bool queryExit();
/** saves the window properties for each open window during session end to the session config file,
* including saving the currently opened file by a temporary filename provided by KApplication.
* @see KTMainWindow#saveProperties
*/
virtual void saveProperties(KConfig *_cfg);
/** reads the session config file and restores the application's state including the last
* opened files and documents by reading the temporary files saved by saveProperties()
* @see KTMainWindow#readProperties
*/
virtual void readProperties(KConfig *_cfg);
/** event filter to catch close events for MDI child windows and is installed in createClient() on every
* child window. Closing a window calls the eventFilter first which removes the view from the connected
* documents' view list. If the last view is going to be closed, the eventFilter() tests if the document
* is modified; if yes, it asks the user to save the document. If the document title contains "Untitled",
* slotFileSaveAs() gets called to get a save name and path.
*/
virtual bool eventFilter(QObject* object, QEvent* event);
/** creates a new child window. The document that will be connected to it
* has to be created before and the instances filled, with e.g. openDocument().
* Then call createClient() to get a new MDI child window.
* @see KScribbleDoc#addView
* @see KScribbleDoc#openDocument
* @param doc pointer to the document instance that the view will
* be connected to.
*/
void createClient(KScribbleDoc* doc);
/** accepts drag events for images */
virtual void dragEnterEvent( QDragEnterEvent* );
/** accepts drops and opens a new document
* for each drop */
virtual void dropEvent( QDropEvent* );
private slots:
/** sets the main application window title each time the active MDI child window changes. */
void setWndTitle(QWidget*);
/** switch argument for slot selection by menu or toolbar ID */
void commandCallback(int id_);
/** switch argument for Statusbar help entries on slot selection. Add your ID's help
* here for toolbars and menubar entries. */
void statusCallback(int id_);
/** add a opened file to the recent file list and update recent file menu*/
void addRecentFile(const QString &file);
/** clears the document in the actual view to reuse it as the new document */
void slotFileNew();
/** open a file and load it into the document*/
void slotFileOpen();
/** opens a file from the recent files menu */
void slotFileOpenRecent(int id_);
/** save a document */
void slotFileSave();
/** save a document by a new filename*/
void slotFileSaveAs();
/** asks for saving if the file is modified, then closes the actual file and window*/
void slotFileClose();
/** print the actual file */
void slotFilePrint();
/** closes all documents and quits the application.*/
void slotFileQuit();
/** reverts the last user action for the active window */
void slotEditUndo();
/** put the marked text/object into the clipboard and remove
* it from the document
*/
void slotEditCut();
/** put the marked text/object into the clipboard
*/
void slotEditCopy();
/** paste the clipboard into the document
*/
void slotEditPaste();
/** clears the current document */
void slotEditClearAll();
/** sets the pen width */
void slotPenBrush();
/** sets the pen color */
void slotPenColor();
/** toggles the toolbar
*/
void slotViewToolBar();
/** toggles the statusbar
*/
void slotViewStatusBar();
/** creates a new view for the document in the active child window and adds the new view to the
* list of views the document maintains.
*/
void slotWindowNewWindow();
/** changes the statusbar contents for the standard label permanently, used to indicate current actions.
* @param text the text that is displayed in the statusbar
*/
void slotStatusMsg(const QString &text);
/** changes the status message of the whole statusbar for two seconds, then restores the last status.
* This is used to display statusbar messages that give information about actions for
* toolbar icons and menuentries.
* @param text the text that is displayed in the statusbar
*/
void slotStatusHelpMsg(const QString &text);
/** gets called when the window menu is activated; recreates the window menu with all opened window titles. */
void windowMenuAboutToShow();
/** activates the MDI child widget when it gets selected from the window menu. */
void windowMenuActivated( int id );
private:
/** save general Options like all bar positions and status as well as the geometry and
* the recent file list to the configuration file
*/
void saveOptions();
/** read general Options again and initialize all variables like the recent file list
*/
void readOptions();
/** initKeyAccel creates the keyboard accelerator items for the available slots and changes the menu accelerators.
* @see KAccel
*/
void initKeyAccel();
/** initMenuBar creates the menubar and inserts the menupopups as well as creating the helpMenu.
*/
void initMenuBar();
/** this creates the toolbars.
*/
void initToolBar();
/** sets up the statusbar for the main window by initialzing a statuslabel.
*/
void initStatusBar();
/** Creates the main view of the KTMainWindow instance and initializes the MDI view area including any needed
* connections.
*/
void initView();
/** contains the recently used filenames */
QStrList recentFiles;
/** the configuration object of the application */
KConfig *config;
/** the key accelerator container */
KAccel *keyAccel;
/** the recent file menu containing the last five opened files */
QPopupMenu *pRecentFileMenu;
/** the file menu */
QPopupMenu* pFileMenu;
/** the edit menu */
QPopupMenu* pEditMenu;
/** the pen menu */
QPopupMenu* pPenMenu;
/** the view menu */
QPopupMenu* pViewMenu;
/** the window menu */
QPopupMenu *pWindowMenu;
/** pWorkspace is the MDI frame widget that handles MDI child widgets. Inititalized in
* initView()
*/
QWorkspace *pWorkspace;
/** the printer instance */
QPrinter *printer;
/** a counter that gets increased each time the user creates a new document with "File"->"New" */
int untitledCount;
/** a list of all open documents. If the last window of a document gets closed, the installed eventFilter
* removes this document from the list. The document list is checked for modified documents when the user
* is about to close the application. */
QList<KScribbleDoc> *pDocList;
};
#endif // KSCRIBBLE_H
/***************************************************************************
kscribble.cpp - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
// include files for QT
#include <qdir.h>
#include <qprinter.h>
#include <qvbox.h>
#include <qwhatsthis.h>
#include <qtooltip.h>
#include <qtoolbutton.h>
#include <qimage.h>
#include <qdragobject.h>
// include files for KDE
#include <kiconloader.h>
#include <kmessagebox.h>
#include <kfiledialog.h>
#include <kcolordlg.h>
#include <kmenubar.h>
#include <klocale.h>
#include <kconfig.h>
// application specific includes
#include "kscribble.h"
#include "kscribbleview.h"
#include "kscribbledoc.h"
#include "resource.h"
#include "kpenbrushdlg.h"
KScribbleApp::KScribbleApp()
{
config=kapp->config();
printer = new QPrinter;
untitledCount=0;
pDocList = new QList<KScribbleDoc>();
pDocList->setAutoDelete(true);
setAcceptDrops(true);
///////////////////////////////////////////////////////////////////
// call inits to invoke all other construction parts
initMenuBar();
initToolBar();
initStatusBar();
initKeyAccel();
initView();
readOptions();
///////////////////////////////////////////////////////////////////
// disable menu and toolbar items at startup
disableCommand(ID_EDIT_UNDO);
}
KScribbleApp::~KScribbleApp()
{
delete printer;
}
void KScribbleApp::initKeyAccel()
{
keyAccel = new KAccel(this);
// fileMenu accelerators
keyAccel->connectItem(KStdAccel::New, this, SLOT(slotFileNew()));
keyAccel->connectItem(KStdAccel::Open, this, SLOT(slotFileOpen()));
keyAccel->connectItem(KStdAccel::Save, this, SLOT(slotFileSave()));
keyAccel->connectItem(KStdAccel::Close, this, SLOT(slotFileClose()));
keyAccel->connectItem(KStdAccel::Print, this, SLOT(slotFilePrint()));
keyAccel->connectItem(KStdAccel::Quit, this, SLOT(slotFileQuit()));
// editMenu accelerators
keyAccel->connectItem(KStdAccel::Cut, this, SLOT(slotEditCut()));
keyAccel->connectItem(KStdAccel::Copy, this, SLOT(slotEditCopy()));
keyAccel->connectItem(KStdAccel::Paste, this, SLOT(slotEditPaste()));
keyAccel->connectItem(KStdAccel::Help, this, SLOT(appHelpActivated()));
keyAccel->changeMenuAccel(pFileMenu, ID_FILE_NEW, KStdAccel::New);
keyAccel->changeMenuAccel(pFileMenu, ID_FILE_OPEN, KStdAccel::Open);
keyAccel->changeMenuAccel(pFileMenu, ID_FILE_SAVE, KStdAccel::Save);
keyAccel->changeMenuAccel(pFileMenu, ID_FILE_CLOSE, KStdAccel::Close);
keyAccel->changeMenuAccel(pFileMenu, ID_FILE_PRINT, KStdAccel::Print);
keyAccel->changeMenuAccel(pFileMenu, ID_FILE_QUIT, KStdAccel::Quit);
keyAccel->changeMenuAccel(pEditMenu, ID_EDIT_CUT, KStdAccel::Cut);
keyAccel->changeMenuAccel(pEditMenu, ID_EDIT_COPY, KStdAccel::Copy);
keyAccel->changeMenuAccel(pEditMenu, ID_EDIT_PASTE, KStdAccel::Paste);
keyAccel->readSettings();
}
void KScribbleApp::initMenuBar()
{
///////////////////////////////////////////////////////////////////
// MENUBAR
pRecentFileMenu = new QPopupMenu(this);
connect(pRecentFileMenu, SIGNAL(activated(int)), SLOT(slotFileOpenRecent(int)));
///////////////////////////////////////////////////////////////////
// menuBar entry file-Menu
pFileMenu = new QPopupMenu(this);
pFileMenu->insertItem(BarIcon("filenew"), i18n("&New"), ID_FILE_NEW);
pFileMenu->insertItem(BarIcon("fileopen"), i18n("&Open..."), ID_FILE_OPEN);
pFileMenu->insertItem(i18n("Open &recent"), pRecentFileMenu, ID_FILE_OPEN_RECENT);
pFileMenu->insertItem(i18n("&Close"), ID_FILE_CLOSE);
pFileMenu->insertSeparator();
pFileMenu->insertItem(BarIcon("filefloppy") ,i18n("&Save"), ID_FILE_SAVE);
pFileMenu->insertItem(i18n("Save &As..."), ID_FILE_SAVE_AS);
pFileMenu->insertSeparator();
pFileMenu->insertItem(BarIcon("fileprint"), i18n("&Print..."), ID_FILE_PRINT);
pFileMenu->insertSeparator();
pFileMenu->insertItem(i18n("E&xit"), ID_FILE_QUIT);
///////////////////////////////////////////////////////////////////
// menuBar entry edit-Menu
pEditMenu = new QPopupMenu(this);
pEditMenu->insertItem(BarIcon("undo"), i18n("&Undo"), ID_EDIT_UNDO);
pEditMenu->insertSeparator();
pEditMenu->insertItem(BarIcon("editcut"), i18n("Cu&t"), ID_EDIT_CUT);
pEditMenu->insertItem(BarIcon("editcopy"), i18n("&Copy"), ID_EDIT_COPY);
pEditMenu->insertItem(BarIcon("editpaste"), i18n("&Paste"), ID_EDIT_PASTE);
pEditMenu->insertItem(BarIcon("delete"),i18n("&Clear All"), ID_EDIT_CLEAR_ALL);
///////////////////////////////////////////////////////////////////
// menuBar entry pen-Menu
pPenMenu = new QPopupMenu();
pPenMenu->insertItem(i18n("&Color"), ID_PEN_COLOR);
pPenMenu->insertItem(i18n("&Brush"), ID_PEN_BRUSH);
///////////////////////////////////////////////////////////////////
// menuBar entry view-Menu
pViewMenu = new QPopupMenu(this);
pViewMenu->setCheckable(true);
pViewMenu->insertItem(i18n("&Toolbar"), ID_VIEW_TOOLBAR);
pViewMenu->insertItem(i18n("&Statusbar"), ID_VIEW_STATUSBAR);
///////////////////////////////////////////////////////////////////
// menuBar entry window-Menu
pWindowMenu = new QPopupMenu(this);
pWindowMenu->setCheckable(true);
///////////////////////////////////////////////////////////////////
// menuBar entry helpMenu
QPopupMenu* pHelpMenu = helpMenu(i18n("KScribble" VERSION "\n\n(c) 2000 by\n"
"Ralf Nolden\nRalf.Nolden@post.rwth-aachen.de"));
///////////////////////////////////////////////////////////////////
// MENUBAR CONFIGURATION
// insert your popup menus with the according menubar entries in the order
// they will appear later from left to right
menuBar()->insertItem(i18n("&File"), pFileMenu);
menuBar()->insertItem(i18n("&Edit"), pEditMenu);
menuBar()->insertItem(i18n("&Pen"), pPenMenu);
menuBar()->insertItem(i18n("&View"), pViewMenu);
menuBar()->insertItem(i18n("&Window"), pWindowMenu );
menuBar()->insertItem(i18n("&Help"), pHelpMenu);
///////////////////////////////////////////////////////////////////
// CONNECT THE MENU SLOTS WITH SIGNALS
// for execution slots and statusbar messages
connect(pFileMenu, SIGNAL(activated(int)), SLOT(commandCallback(int)));
connect(pFileMenu, SIGNAL(highlighted(int)), SLOT(statusCallback(int)));
connect(pEditMenu, SIGNAL(activated(int)), SLOT(commandCallback(int)));
connect(pEditMenu, SIGNAL(highlighted(int)), SLOT(statusCallback(int)));
connect(pPenMenu, SIGNAL(activated(int)), SLOT(commandCallback(int)));
connect(pPenMenu, SIGNAL(highlighted(int)), SLOT(statusCallback(int)));
connect(pViewMenu, SIGNAL(activated(int)), SLOT(commandCallback(int)));
connect(pViewMenu, SIGNAL(highlighted(int)), SLOT(statusCallback(int)));
connect(pWindowMenu, SIGNAL(aboutToShow() ), SLOT( windowMenuAboutToShow() ) );
connect(pWindowMenu, SIGNAL(activated(int)), SLOT(commandCallback(int)));
connect(pWindowMenu, SIGNAL(highlighted(int)), SLOT(statusCallback(int)));
}
void KScribbleApp::initToolBar()
{
///////////////////////////////////////////////////////////////////
// TOOLBAR
toolBar()->insertButton(BarIcon("filenew"), ID_FILE_NEW, true, i18n("New File"));
toolBar()->insertButton(BarIcon("fileopen"), ID_FILE_OPEN, true, i18n("Open File"));
toolBar()->insertButton(BarIcon("filefloppy"), ID_FILE_SAVE, true, i18n("Save File"));
toolBar()->insertButton(BarIcon("fileprint"), ID_FILE_PRINT, true, i18n("Print"));
toolBar()->insertSeparator();
toolBar()->insertButton(BarIcon("editcut"), ID_EDIT_CUT, true, i18n("Cut"));
toolBar()->insertButton(BarIcon("editcopy"), ID_EDIT_COPY, true, i18n("Copy"));
toolBar()->insertButton(BarIcon("editpaste"), ID_EDIT_PASTE, true, i18n("Paste"));
toolBar()->insertSeparator();
toolBar()->insertButton(BarIcon("pencolor"), ID_PEN_COLOR, true, i18n("Color") );
toolBar()->insertButton(BarIcon("penwidth"), ID_PEN_BRUSH, true, i18n("Width") );
toolBar()->insertSeparator();
toolBar()->insertButton(BarIcon("help"), ID_HELP_CONTENTS, SIGNAL(clicked()),
this, SLOT(appHelpActivated()), true,i18n("Help"));
QToolButton *btnwhat = QWhatsThis::whatsThisButton(toolBar());
QToolTip::add(btnwhat, i18n("What's this...?"));
toolBar()->insertWidget(ID_HELP_WHATS_THIS, btnwhat->sizeHint().width(), btnwhat);
///////////////////////////////////////////////////////////////////
// INSERT YOUR APPLICATION SPECIFIC TOOLBARS HERE WITH toolBar(n)
///////////////////////////////////////////////////////////////////
// CONNECT THE TOOLBAR SLOTS WITH SIGNALS - add new created toolbars by their according number
// connect for invoking the slot actions
connect(toolBar(), SIGNAL(clicked(int)), SLOT(commandCallback(int)));
// connect for the status help on holing icons pressed with the mouse button
connect(toolBar(), SIGNAL(pressed(int)), SLOT(statusCallback(int)));
}
void KScribbleApp::initStatusBar()
{
///////////////////////////////////////////////////////////////////
// STATUSBAR
// TODO: add your own items you need for displaying current application status.
statusBar()->insertItem(i18n("Ready."), ID_STATUS_MSG);
}
void KScribbleApp::initView()
{
////////////////////////////////////////////////////////////////////
// here the main view of the KTMainWindow is created by a background box and
// the QWorkspace instance for MDI view.
QVBox* view_back = new QVBox( this );
view_back->setFrameStyle( QFrame::StyledPanel | QFrame::Sunken );
pWorkspace = new QWorkspace( view_back );
connect(pWorkspace, SIGNAL(windowActivated(QWidget*)), this, SLOT(setWndTitle(QWidget*)));
setView(view_back);
}
void KScribbleApp::setWndTitle(QWidget*){
setCaption(pWorkspace->activeWindow()->caption());
}
void KScribbleApp::enableCommand(int id_)
{
///////////////////////////////////////////////////////////////////
// enable menu and toolbar functions by their ID's
menuBar()->setItemEnabled(id_, true);
toolBar()->setItemEnabled(id_, true);
}
void KScribbleApp::disableCommand(int id_)
{
///////////////////////////////////////////////////////////////////
// disable menu and toolbar functions by their ID's
menuBar()->setItemEnabled(id_, false);
toolBar()->setItemEnabled(id_, false);
}
void KScribbleApp::addRecentFile(const QString &file)
{
if(recentFiles.contains(file))
return; // it's already there
if( recentFiles.count() < 5)
recentFiles.prepend(file);
else{
recentFiles.remove(recentFiles.last());
recentFiles.prepend(file);
}
pRecentFileMenu->clear();
for ( int i =0 ; i < (int)recentFiles.count(); i++){
pRecentFileMenu->insertItem(recentFiles.at(i));
}
}
void KScribbleApp::createClient(KScribbleDoc* doc)
{
KScribbleView* w = new KScribbleView(doc, pWorkspace,0,WDestructiveClose);
w->installEventFilter(this);
doc->addView(w);
w->setIcon(kapp->miniIcon());
if ( pWorkspace->windowList().isEmpty() ) // show the very first window in maximized mode
w->showMaximized();
else
w->show();
}
void KScribbleApp::openDocumentFile(const char* file)
{
slotStatusMsg(i18n("Opening file..."));
KScribbleDoc* doc;
// check, if document already open. If yes, set the focus to the first view
for(doc=pDocList->first(); doc > 0; doc=pDocList->next())
{
if(doc->pathName()==file)
{
KScribbleView* view=doc->firstView();
view->setFocus();
return;
}
}
doc = new KScribbleDoc();
pDocList->append(doc);
doc->newDocument();
// Creates an untitled window if file is 0
if(!file)
{
untitledCount+=1;
QString fileName=QString(i18n("Untitled%1")).arg(untitledCount);
doc->setPathName(fileName);
doc->setTitle(fileName);
}
// Open the file
else
{
QString format=QImageIO::imageFormat(file);
if(!doc->openDocument(file,format))
KMessageBox::error (this,i18n("Could not open document !"), i18n("Error !"));
addRecentFile(file);
}
// create the window
createClient(doc);
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::saveOptions()
{
config->setGroup("General Options");
config->writeEntry("Geometry", size());
config->writeEntry("Show Toolbar", toolBar()->isVisible());
config->writeEntry("Show Statusbar",statusBar()->isVisible());
config->writeEntry("ToolBarPos", (int) toolBar()->barPos());
config->writeEntry("Recent Files", recentFiles);
}
void KScribbleApp::readOptions()
{
config->setGroup("General Options");
// bar status settings
bool bViewToolbar = config->readBoolEntry("Show Toolbar", true);
menuBar()->setItemChecked(ID_VIEW_TOOLBAR, bViewToolbar);
if(!bViewToolbar)
{
enableToolBar(KToolBar::Hide);
}
bool bViewStatusbar = config->readBoolEntry("Show Statusbar", true);
menuBar()->setItemChecked(ID_VIEW_STATUSBAR, bViewStatusbar);
if(!bViewStatusbar)
{
enableStatusBar(KStatusBar::Hide);
}
// bar position settings
KToolBar::BarPosition toolBarPos;
toolBarPos=(KToolBar::BarPosition) config->readNumEntry("ToolBarPos", KToolBar::Top);
toolBar()->setBarPos(toolBarPos);
// initialize the recent file list
config->readListEntry("Recent Files",recentFiles);
for (int i=0; i < (int) recentFiles.count(); i++)
{
pRecentFileMenu->insertItem(recentFiles.at(i));
}
QSize size=config->readSizeEntry("Geometry");
if(!size.isEmpty())
{
resize(size);
}
else
resize(400,350);
}
void KScribbleApp::saveProperties(KConfig *_cfg)
{
}
void KScribbleApp::readProperties(KConfig* _cfg)
{
}
bool KScribbleApp::queryClose()
{
QStringList saveFiles;
KScribbleDoc* doc;
if(pDocList->isEmpty())
return true;
for(doc=pDocList->first(); doc!=0;doc=pDocList->next()){
if(doc->isModified())
saveFiles.append(doc->title());
}
if(saveFiles.isEmpty())
return true;
switch (KMessageBox::questionYesNoList(this,
i18n("One or more documents have been modified.\nSave changes before exiting?"),saveFiles))
{
case KMessageBox::Yes:
for(doc=pDocList->first(); doc!=0;doc=pDocList->next()){
if(doc->title().contains(i18n("Untitled")))
slotFileSaveAs();
else
{
if(!doc->saveDocument(doc->pathName())){
KMessageBox::error (this,i18n("Could not save the current document !"), i18n("I/O Error !"));
return false;
}
}
}
return true;
case KMessageBox::No:
default:
return true;
}
}
bool KScribbleApp::queryExit()
{
saveOptions();
return true;
}
bool KScribbleApp::eventFilter(QObject* object, QEvent* event){
if(event->type() == QEvent::Close)
{
QCloseEvent* e=(QCloseEvent*)event;
KScribbleView* pView=(KScribbleView*)object;
KScribbleDoc* pDoc=pView->getDocument();
if(pDoc->canCloseFrame(pView))
{
pDoc->removeView(pView);
if(!pDoc->firstView())
pDocList->remove(pDoc);
e->accept();
//////////////
if(pWorkspace->windowList().count()==1)
setPlainCaption(kapp->caption());
else
setCaption(pWorkspace->activeWindow()->caption());
//////////////
}
else
e->ignore();
}
return QWidget::eventFilter( object, event ); // standard event processing
}
/////////////////////////////////////////////////////////////////////
// SLOT IMPLEMENTATION
/////////////////////////////////////////////////////////////////////
void KScribbleApp::slotFileNew()
{
slotStatusMsg(i18n("Creating new document..."));
openDocumentFile();
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFileOpen()
{
slotStatusMsg(i18n("Opening file..."));
QString fileToOpen=KFileDialog::getOpenFileName(QDir::currentDirPath(),
KImageIO::pattern(KImageIO::Reading), this, i18n("Open File..."));
if(!fileToOpen.isEmpty())
{
openDocumentFile(fileToOpen);
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFileOpenRecent(int id_)
{
slotStatusMsg(i18n("Opening file..."));
openDocumentFile(pRecentFileMenu->text(id_));
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFileSave()
{
slotStatusMsg(i18n("Saving file..."));
KScribbleView* m = (KScribbleView*)pWorkspace->activeWindow();
if( m )
{
KScribbleDoc* doc = m->getDocument();
if(doc->title().contains(i18n("Untitled")))
slotFileSaveAs();
else
if(!doc->saveDocument(doc->pathName()))
KMessageBox::error (this,i18n("Could not save the current document !"), i18n("I/O Error !"));
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFileSaveAs()
{
slotStatusMsg(i18n("Saving file with a new filename..."));
QString newName=KFileDialog::getSaveFileName(QDir::currentDirPath(),
KImageIO::pattern(KImageIO::Writing), this, i18n("Save as..."));
if(!newName.isEmpty())
{
KScribbleView* m = (KScribbleView*)pWorkspace->activeWindow();
if( m )
{
KScribbleDoc* doc = m->getDocument();
QString format=QFileInfo(newName).extension();
format=format.upper();
if(!doc->saveDocument(newName,format))
{
KMessageBox::error (this,i18n("Could not save the current document !"), i18n("I/O Error !"));
return;
}
doc->changedViewList();
setWndTitle(m);
}
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFileClose()
{
slotStatusMsg(i18n("Closing file..."));
KScribbleView* m = (KScribbleView*)pWorkspace->activeWindow();
if( m )
{
KScribbleDoc* doc=m->getDocument();
doc->closeDocument();
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFilePrint()
{
slotStatusMsg(i18n("Printing..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m )
m->print( printer );
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotFileQuit()
{
slotStatusMsg(i18n("Exiting..."));
saveOptions();
// close the first window, the list makes the next one the first again.
// This ensures that queryClose() is called on each window to ask for closing
KTMainWindow* w;
if(memberList)
{
for(w=memberList->first(); w!=0; w=memberList->first())
{
// only close the window if the closeEvent is accepted. If the user
// presses Cancel on the saveModified() dialog,
// the window and the application stay open.
if(!w->close())
break;
}
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotEditUndo()
{
slotStatusMsg(i18n("Reverting last action..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m )
// m->undo();
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotEditCut()
{
slotStatusMsg(i18n("Cutting selection..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m )
m->cutSelection();
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotEditCopy()
{
slotStatusMsg(i18n("Copying selection to clipboard..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m )
m->copySelection();
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotEditPaste()
{
slotStatusMsg(i18n("Inserting clipboard contents..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m )
m->pasteSelection();
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotEditClearAll()
{
slotStatusMsg(i18n("Clearing the document contents..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m ){
KScribbleDoc* pDoc = m->getDocument();
pDoc->editClearAll();
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotPenBrush()
{
slotStatusMsg(i18n("Setting brush width..."));
// get one window with document for a current pen width
QWidgetList windows = pWorkspace->windowList();
KScribbleView* m = (KScribbleView*)windows.at(0);
KScribbleDoc* pDoc = m->getDocument();
int curr_width=pDoc->penWidth();
// create the dialog, get the new width and set the pen width for all documents
KPenBrushDlg* dlg= new KPenBrushDlg(curr_width,this);
if(dlg->exec()){
int width=dlg->width();
for ( int i = 0; i < int(windows.count()); ++i )
{
m = (KScribbleView*)windows.at(i);
if ( m )
{
pDoc = m->getDocument();
pDoc->setPenWidth(width);
}
}
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotPenColor()
{
slotStatusMsg(i18n("Selecting pen color..."));
QColor myColor;
int result = KColorDialog::getColor( myColor, this );
if ( result == KColorDialog::Accepted )
{
QWidgetList windows = pWorkspace->windowList();
KScribbleDoc* pDoc;
KScribbleView* m;
for ( int i = 0; i < int(windows.count()); ++i )
{
m = (KScribbleView*)windows.at(i);
if ( m )
{
pDoc = m->getDocument();
pDoc->setPenColor(myColor);
}
}
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotViewToolBar()
{
slotStatusMsg(i18n("Toggle the toolbar..."));
///////////////////////////////////////////////////////////////////
// turn Toolbar on or off
if( menuBar()->isItemChecked(ID_VIEW_TOOLBAR))
{
menuBar()->setItemChecked(ID_VIEW_TOOLBAR, false);
enableToolBar(KToolBar::Hide);
}
else
{
menuBar()->setItemChecked(ID_VIEW_TOOLBAR, true);
enableToolBar(KToolBar::Show);
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotViewStatusBar()
{
slotStatusMsg(i18n("Toggle the statusbar..."));
///////////////////////////////////////////////////////////////////
//turn Statusbar on or off
if( menuBar()->isItemChecked(ID_VIEW_STATUSBAR))
{
menuBar()->setItemChecked(ID_VIEW_STATUSBAR, false);
enableStatusBar(KStatusBar::Hide);
}
else
{
menuBar()->setItemChecked(ID_VIEW_STATUSBAR, true);
enableStatusBar(KStatusBar::Show);
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotWindowNewWindow()
{
slotStatusMsg(i18n("Opening a new application window..."));
KScribbleView* m = (KScribbleView*) pWorkspace->activeWindow();
if ( m ){
KScribbleDoc* doc = m->getDocument();
createClient(doc);
}
slotStatusMsg(i18n("Ready."));
}
void KScribbleApp::slotStatusMsg(const QString &text)
{
///////////////////////////////////////////////////////////////////
// change status message permanently
statusBar()->clear();
statusBar()->changeItem(text, ID_STATUS_MSG);
}
void KScribbleApp::slotStatusHelpMsg(const QString &text)
{
///////////////////////////////////////////////////////////////////
// change status message of whole statusbar temporary (text, msec)
statusBar()->message(text, 2000);
}
void KScribbleApp::windowMenuAboutToShow()
{
pWindowMenu->clear();
pWindowMenu->insertItem(i18n("&New Window"), ID_WINDOW_NEW_WINDOW);
pWindowMenu->insertItem(i18n("&Cascade"),
pWorkspace, SLOT(cascade() ),0 , ID_WINDOW_CASCADE );
pWindowMenu->insertItem(i18n("&Tile"),
pWorkspace, SLOT(tile() ),0 , ID_WINDOW_TILE );
if ( pWorkspace->windowList().isEmpty() ) {
disableCommand(ID_WINDOW_NEW_WINDOW);
disableCommand(ID_WINDOW_CASCADE);
disableCommand(ID_WINDOW_TILE);
}
pWindowMenu->insertSeparator();
QWidgetList windows = pWorkspace->windowList();
for ( int i = 0; i < int(windows.count()); ++i ) {
int id = pWindowMenu->insertItem(QString("&%1 ").arg(i+1)+windows.at(i)->caption(),
this, SLOT( windowMenuActivated( int ) ) );
pWindowMenu->setItemParameter( id, i );
pWindowMenu->setItemChecked( id, pWorkspace->activeWindow() == windows.at(i) );
}
}
void KScribbleApp::windowMenuActivated( int id )
{
QWidget* w = pWorkspace->windowList().at( id );
if ( w )
w->setFocus();
}
void KScribbleApp::commandCallback(int id_)
{
switch (id_)
{
case ID_FILE_NEW:
slotFileNew();
break;
case ID_FILE_OPEN:
slotFileOpen();
break;
case ID_FILE_SAVE:
slotFileSave();
break;
case ID_FILE_SAVE_AS:
slotFileSaveAs();
break;
case ID_FILE_CLOSE:
slotFileClose();
break;
case ID_FILE_PRINT:
slotFilePrint();
break;
case ID_FILE_QUIT:
slotFileQuit();
break;
case ID_EDIT_CUT:
slotEditCut();
break;
case ID_EDIT_COPY:
slotEditCopy();
break;
case ID_EDIT_PASTE:
slotEditPaste();
break;
case ID_EDIT_CLEAR_ALL:
slotEditClearAll();
break;
case ID_PEN_BRUSH:
slotPenBrush();
break;
case ID_PEN_COLOR:
slotPenColor();
break;
case ID_VIEW_TOOLBAR:
slotViewToolBar();
break;
case ID_VIEW_STATUSBAR:
slotViewStatusBar();
break;
case ID_WINDOW_NEW_WINDOW:
slotWindowNewWindow();
break;
default:
break;
}
}
void KScribbleApp::statusCallback(int id_)
{
switch (id_)
{
case ID_FILE_NEW:
slotStatusHelpMsg(i18n("Creates a new document"));
break;
case ID_FILE_OPEN:
slotStatusHelpMsg(i18n("Opens an existing document"));
break;
case ID_FILE_OPEN_RECENT:
slotStatusHelpMsg(i18n("Opens a recently used file"));
break;
case ID_FILE_SAVE:
slotStatusHelpMsg(i18n("Saves the currently active document"));
break;
case ID_FILE_SAVE_AS:
slotStatusHelpMsg(i18n("Saves the currently active document as under a new filename"));
break;
case ID_FILE_CLOSE:
slotStatusHelpMsg(i18n("Closes the currently active document"));
break;
case ID_FILE_PRINT:
slotStatusHelpMsg(i18n("Prints out the actual document"));
break;
case ID_FILE_QUIT:
slotStatusHelpMsg(i18n("Quits the application"));
break;
case ID_EDIT_UNDO:
slotStatusHelpMsg(i18n("Reverts the last editing action"));
break;
case ID_EDIT_CUT:
slotStatusHelpMsg(i18n("Cuts the selected section and puts it to the clipboard"));
break;
case ID_EDIT_COPY:
slotStatusHelpMsg(i18n("Copies the selected section to the clipboard"));
break;
case ID_EDIT_PASTE:
slotStatusHelpMsg(i18n("Pastes the clipboard contents to actual position"));
break;
case ID_EDIT_CLEAR_ALL:
slotStatusHelpMsg(i18n("Clears the document contents"));
break;
case ID_PEN_BRUSH:
slotStatusHelpMsg(i18n("Sets the pen width"));
break;
case ID_PEN_COLOR:
slotStatusHelpMsg(i18n("Sets the current pen color"));
break;
case ID_VIEW_TOOLBAR:
slotStatusHelpMsg(i18n("Enables/disables the toolbar"));
break;
case ID_VIEW_STATUSBAR:
slotStatusHelpMsg(i18n("Enables/disables the statusbar"));
break;
case ID_WINDOW_NEW_WINDOW:
slotStatusHelpMsg(i18n("Opens a new view for the current document"));
break;
case ID_WINDOW_CASCADE:
slotStatusHelpMsg(i18n("Cascades all windows"));
break;
case ID_WINDOW_TILE:
slotStatusHelpMsg(i18n("Tiles all windows"));
break;
default:
break;
}
}
/** accepts drops and opens a new document
for each drop */
void KScribbleApp::dropEvent( QDropEvent* e){
QImage img;
if ( QImageDrag::decode(e, img) )
{
KScribbleDoc* doc = new KScribbleDoc();
untitledCount+=1;
QString fileName=QString(i18n("Untitled%1")).arg(untitledCount);
doc->setPathName(fileName);
doc->setTitle(fileName);
doc->newDocument();
pDocList->append(doc);
KPixmap tmp;
tmp.resize(img.size());
tmp.convertFromImage(img);
doc->setPixmap(tmp);
doc->resizeDocument(tmp.size());
doc->setModified();
createClient(doc);
}
}
/** accepts drag events for images */
void KScribbleApp::dragEnterEvent( QDragEnterEvent* e){
e->accept(QImageDrag::canDecode(e));
}
/***************************************************************************
kscribbledoc.h - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef KSCRIBBLEDOC_H
#define KSCRIBBLEDOC_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
// include files for QT
#include <qobject.h>
#include <qstring.h>
#include <qlist.h>
#include <qsize.h>
#include <qpen.h>
#include <qpoint.h>
//#include <qpixmap.h>
#include <qpointarray.h>
#include <kpixmap.h>
// forward declaration of the KScribble classes
class KScribbleView;
/** KScribbleDoc provides a document object for a document-view model.
*
* The KScribbleDoc class provides a document object that can be used in conjunction with the classes
* KScribbleApp and KScribbleView to create a document-view model for MDI (Multiple Document Interface)
* KDE 2 applications based on KApplication and KTMainWindow as main classes and QWorkspace as MDI manager widget.
* Thereby, the document object is created by the KScribbleApp instance (and kept in a document list) and contains
* the document structure with the according methods for manipulating the document
* data by KScribbleView objects. Also, KScribbleDoc contains the methods for serialization of the document data
* from and to files.
* @author Source Framework Automatically Generated by KDevelop, (c) The KDevelop Team.
* @version KDevelop version 1.1 code generation
*/
class KScribbleDoc : public QObject
{
Q_OBJECT
friend KScribbleView;
public:
/** Constructor for the fileclass of the application */
KScribbleDoc();
/** Destructor for the fileclass of the application */
~KScribbleDoc();
/** adds a view to the document which represents the document contents. Usually this is your main view. */
void addView(KScribbleView *view);
/** removes a view from the list of currently connected views */
void removeView(KScribbleView *view);
/** gets called if a view is removed or added */
void changedViewList();
/** returns the first view instance */
KScribbleView* firstView(){ return pViewList->first(); };
/** returns true, if the requested view is the last view of the document */
bool isLastView();
/** This method gets called when the user is about to close a frame window. It checks, if more than one view
* is connected to the document (then the frame can be closed), if pFrame is the last view and the document is
* modified, the user gets asked if he wants to save the document.
*/
bool canCloseFrame(KScribbleView* pFrame);
/** sets the modified flag for the document after a modifying action on the view connected to the document.*/
void setModified(bool _m=true){ modified=_m; };
/** returns if the document is modified or not. Use this to determine if your document needs
* saving by the user on closing.
*/
bool isModified(){ return modified; };
/** deletes the document's contents */
void deleteContents();
/** initializes the document generally */
bool newDocument();
/** closes the acutal document */
void closeDocument();
/** loads the document by filename and format and emits the updateViews() signal */
bool openDocument(const QString &filename, const char *format=0);
/** saves the document under filename and format.*/
bool saveDocument(const QString &filename, const char *format=0);
/** sets the path to the file connected with the document */
void setPathName(const QString &name);
/** returns the pathname of the current document file*/
const QString& pathName() const;
/** sets the filename of the document */
void setTitle(const QString &title);
/** returns the title of the document */
const QString& title() const;
/** get the current Pen */
const QPen currentPen(){ return pen;};
/** returns the pen width */
const int penWidth() { return pen.width(); }
/** returns the pen color */
const QColor penColor(){ return pen.color(); }
/** sets the pen width */
void setPenWidth( int w ){ pen.setWidth( w ); }
/** sets the pen color */
void setPenColor( const QColor &c ){ pen.setColor( c ); }
/** sets the pen style by a second toolbar */
void setPenStyle( PenStyle s){ pen.setStyle(s);}
/** clears the document contents */
void editClearAll();
/** get the document size */
const QSize docSize(){ return size;};
/** sets the pixmap contents. Used by KScribbleApp
to create a new document by drop events */
void setPixmap(KPixmap pix) { buffer=pix;};
void resizeDocument(QSize m_size) { size=m_size; };
public slots:
/** calls repaint() on all views connected to the document object and is called by the view by
* which the document has been changed.
* As this view normally repaints itself, it is excluded from the paintEvent.
*/
void updateAllViews(KScribbleView *sender);
protected:
QPen pen;
QPointArray polyline;
KPixmap buffer;
private:
/** the modified flag of the current document */
bool modified;
QString m_title;
QString m_filename;
/** the list of the views currently connected to the document */
QList<KScribbleView> *pViewList;
QSize size;
};
#endif // KSCRIBBLEDOC_H
/***************************************************************************
kscribbledoc.cpp - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
// include files for Qt
#include <qdir.h>
#include <qfileinfo.h>
#include <qwidget.h>
// include files for KDE
#include <klocale.h>
#include <kmessagebox.h>
#include <kfiledialog.h>
// application specific includes
#include "kscribbledoc.h"
#include "kscribble.h"
#include "kscribbleview.h"
KScribbleDoc::KScribbleDoc()
{
pViewList = new QList<KScribbleView>;
pViewList->setAutoDelete(false);
}
KScribbleDoc::~KScribbleDoc()
{
delete pViewList;
}
void KScribbleDoc::addView(KScribbleView *view)
{
pViewList->append(view);
changedViewList();
}
void KScribbleDoc::removeView(KScribbleView *view)
{
pViewList->remove(view);
if(!pViewList->isEmpty())
changedViewList();
else
deleteContents();
}
void KScribbleDoc::changedViewList(){
KScribbleView *w;
if((int)pViewList->count() == 1){
w=pViewList->first();
w->setCaption(m_title);
}
else{
int i;
for( i=1,w=pViewList->first(); w!=0; i++, w=pViewList->next())
w->setCaption(QString(m_title+":%1").arg(i));
}
}
bool KScribbleDoc::isLastView() {
return ((int) pViewList->count() == 1);
}
void KScribbleDoc::updateAllViews(KScribbleView *sender)
{
KScribbleView *w;
for(w=pViewList->first(); w!=0; w=pViewList->next())
{
w->update(sender);
}
}
void KScribbleDoc::setPathName(const QString &name)
{
m_filename=name;
m_title=QFileInfo(name).fileName();
}
const QString& KScribbleDoc::pathName() const
{
return m_filename;
}
void KScribbleDoc::setTitle(const QString &title)
{
m_title=title;
}
const QString &KScribbleDoc::title() const
{
return m_title;
}
void KScribbleDoc::closeDocument()
{
KScribbleView *w;
if(!isLastView())
{
for(w=pViewList->first(); w!=0; w=pViewList->next())
{
if(!w->close())
break;
}
}
if(isLastView())
{
w=pViewList->first();
w->close();
}
}
bool KScribbleDoc::newDocument()
{
/////////////////////////////////////////////////
// TODO: Add your document initialization code here
size=QSize(300,200 );
pen=QPen( Qt::black, 3 );
polyline=QPointArray(3);
buffer.resize(size);
buffer.fill( Qt::white );
/////////////////////////////////////////////////
modified=false;
return true;
}
bool KScribbleDoc::openDocument(const QString &filename, const char *format /*=0*/)
{
QFile f( filename );
// if ( !f.open( IO_ReadOnly ) )
// return false;
/////////////////////////////////////////////////
// TODO: Add your document opening code here
if(!buffer.load( filename, format ))
return false;
size=buffer.size();
/////////////////////////////////////////////////
// f.close();
modified=false;
m_filename=filename;
m_title=QFileInfo(f).fileName();
return true;
}
bool KScribbleDoc::saveDocument(const QString &filename, const char *format /*=0*/)
{
QFile f( filename );
// if ( !f.open( IO_WriteOnly ) )
// return false;
/////////////////////////////////////////////////
// TODO: Add your document saving code here
if(!buffer.save( filename, format ))
return false;
/////////////////////////////////////////////////
// f.close();
modified=false;
m_filename=filename;
m_title=QFileInfo(f).fileName();
return true;
}
void KScribbleDoc::deleteContents()
{
/////////////////////////////////////////////////
// TODO: Add implementation to delete the document contents
buffer.fill( Qt::white );
/////////////////////////////////////////////////
}
bool KScribbleDoc::canCloseFrame(KScribbleView* pFrame)
{
if(!isLastView())
return true;
bool ret=false;
if(isModified())
{
QString saveName;
switch(KMessageBox::warningYesNoCancel(pFrame, i18n("The current file has been modified.\n"
"Do you want to save it?"),title()))
{
case KMessageBox::Yes:
if(title().contains(i18n("Untitled")))
{
saveName=KFileDialog::getSaveFileName(QDir::currentDirPath(),
i18n("*|All files"), pFrame, i18n("Save as..."));
if(saveName.isEmpty())
return false;
}
else
saveName=pathName();
if(!saveDocument(saveName))
{
switch(KMessageBox::warningYesNo(pFrame,i18n("Could not save the current document !\n"
"Close anyway ?"), i18n("I/O Error !")))
{
case KMessageBox::Yes:
ret=true;
case KMessageBox::No:
ret=false;
}
}
else
ret=true;
break;
case KMessageBox::No:
ret=true;
break;
case KMessageBox::Cancel:
default:
ret=false;
break;
}
}
else
ret=true;
return ret;
}
void KScribbleDoc::editClearAll()
{
deleteContents();
setModified();
updateAllViews(0);
}
/***************************************************************************
kscribbleview.h - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef KSCRIBBLEVIEW_H
#define KSCRIBBLEVIEW_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
// include files for Qt
#include <qscrollview.h>
#include <kpixmap.h>
class KScribbleDoc;
/** The KScribbleView class provides the view widget for the document instance connected to it and is displayed
* as a MDI child window in the main view area of the KScribbleApp class instance. The KScribbleApp
* class also has an eventFilter() method that gets installed on every KScribbleView instance to
* control events of the type QEvent::Close.The document connected to the view instance keeps a list
* of all view that represent the document contents as there can be more than one view. Views get created in
* KScribbleApp::createClient() and automatically added to the list of views.
* The KScribbleView class inherits QWidget as a base. Another possible inheritance besides specialized
+ widgets could be QMainWindow so that you can easily set up the main area of your view by setting another view
* as main widget (QMainWindow::setMainWidget() ).
* NOTE: The close event always has to be empty (DON`T CALL QWidget::closeEvent(e) in closeEvent())
* because the installed event filter can only manage a forward implementation. If the QCloseEvent
* is received by the KScribbleView, the overwritten event handler has to do nothing as the eventFilter
* has set accept() or ignore() already. If QWidget::closeEvent() is called again, the default event
* handler will accept the close event and the window gets destroyed even if the installed eventFilter
* has set the event to be ignored.
* @author Source Framework Automatically Generated by KDevelop, (c) The KDevelop Team.
* @version KDevelop version 1.1 code generation
*/
class KScribbleView : public QScrollView
{
Q_OBJECT
friend KScribbleDoc;
public:
/** Constructor for the view
* @param pDoc your document instance that the view represents. Create a document
* before calling the constructor or connect an already existing document to a new MDI child widget.*/
KScribbleView(KScribbleDoc* pDoc, QWidget* parent, const char *name, int wflags);
/** Destructor for the main view */
~KScribbleView();
/** returns a pointer to the document connected to the view*/
KScribbleDoc *getDocument() const;
/** gets called to redraw the document contents if it has been modified */
void update(KScribbleView* pSender);
/** contains the implementation for printing functionality and gets called by KScribbleApp::slotFilePrint() */
void print(QPrinter *pPrinter);
/** cuts out a selection */
void cutSelection();
/** copies a selection to the clipboard */
void copySelection();
/** pastes the clipboard contents to a selection that can be inserted into the picture */
void pasteSelection();
protected:
/** overwritten QWidget::closeEvent() to catch closing views. Does nothing, as the closeEvents for
* KScribbleView's are processed by KScribbleApp::eventFilter(), so this overwitten closeEvent is necessary
* and has to be empty. Don't overwrite this method !
*/
virtual void closeEvent(QCloseEvent* );
/** overwritten to interpret key events for scrollbars */
virtual void keyPressEvent( QKeyEvent* );
/** changed from mousePressEvent() overwriting QScrollView method */
virtual void viewportMousePressEvent( QMouseEvent* );
/** changed from mouseReleaseEvent() overwriting QScrollView method */
virtual void viewportMouseReleaseEvent( QMouseEvent* );
/** On paste actions inserts the pasted clipboard contents */
virtual void viewportMouseDoubleClickEvent(QMouseEvent* e);
/** changed from mouseMoveEvent() overwriting QScrollView method */
virtual void viewportMouseMoveEvent( QMouseEvent* );
/** changed from resizeEvent() overwriting QScrollView method */
// virtual void viewportResizeEvent( QResizeEvent* );
/** changed from paintEvent() overwriting QScrollView method */
virtual void viewportPaintEvent( QPaintEvent* );
virtual void viewportDragEnterEvent ( QDragEnterEvent * );
virtual void viewportDragMoveEvent ( QDragMoveEvent * );
virtual void viewportDragLeaveEvent ( QDragLeaveEvent * );
virtual void viewportDropEvent ( QDropEvent * );
/** the document instance */
KScribbleDoc *doc;
private:
KPixmap tmp;
QRect select;
QClipboard *cb;
enum Action{IDLE=0, DRAW, SELECT, PASTE, DRAG} action;
};
#endif // KSCRIBBLEVIEW_H
/***************************************************************************
kscribbleview.cpp - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include <iostream.h>
// include files for Qt
#include <qprinter.h>
#include <qpainter.h>
#include <qdir.h>
#include <qsize.h>
#include <qclipboard.h>
#include <qimage.h>
#include <qdragobject.h>
// include files for KDE
#include <kiconloader.h>
// application specific includes
#include "kscribbleview.h"
#include "kscribbledoc.h"
#include "kscribble.h"
KScribbleView::KScribbleView(KScribbleDoc* pDoc, QWidget *parent, const char* name, int wflags)
: QScrollView(parent, name, wflags | WPaintClever | WNorthWestGravity | WRepaintNoErase)
{
cb = QApplication::clipboard();
viewport()->setAcceptDrops(true);
setDragAutoScroll(true);
doc=pDoc;
action=IDLE;
viewport()->setCursor( Qt::crossCursor );
QSize size=doc->docSize();
resizeContents(size.width(), size.height());
resize(size);
}
KScribbleView::~KScribbleView()
{
}
KScribbleDoc *KScribbleView::getDocument() const
{
return doc;
}
void KScribbleView::update(KScribbleView* pSender){
if(pSender != this)
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
void KScribbleView::print(QPrinter *pPrinter)
{
if (pPrinter->setup(this))
{
QPainter p;
p.begin(pPrinter);
///////////////////////////////
// TODO: add your printing code here
p.drawPixmap(0,0,doc->buffer);
///////////////////////////////
p.end();
}
}
/** cuts out a selection */
void KScribbleView::cutSelection(){
select=select.normalize();
QPixmap cb_pix;
cb_pix.resize(select.size());
// copy selection to cb_pix and copy to clipboard
bitBlt(&cb_pix, 0, 0,
&doc->buffer, select.x()+contentsX(), select.y()+contentsY(), cb_pix.width(), cb_pix.height());
cb->setPixmap(cb_pix);
// fill cb_pix with white and copy to selection area
cb_pix.fill(Qt::white);
bitBlt(&doc->buffer, select.x()+contentsX(), select.y()+contentsY(),
&cb_pix, 0, 0, cb_pix.width(), cb_pix.height());
action = IDLE;
doc->setModified();
doc->updateAllViews(this);
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
/** copies a selection to the clipboard */
void KScribbleView::copySelection(){
select=select.normalize();
QPixmap cb_pix;
cb_pix.resize(select.size());
// copy selection to cb_pix and copy to clipboard
bitBlt(&cb_pix, 0, 0,
&doc->buffer, select.x()+contentsX(), select.y()+contentsY(),cb_pix.width(), cb_pix.height());
cb->setPixmap(cb_pix);
action = IDLE;
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
/** pastes the clipboard contents to a selection that can be inserted into the picture */
void KScribbleView::pasteSelection(){
select=cb->pixmap().rect();
action = PASTE;
viewport()->setCursor( Qt::sizeAllCursor );
}
void KScribbleView::closeEvent(QCloseEvent* e){
// DO NOT CALL QWidget::closeEvent(e) here !!
// This will accept the closing by QCloseEvent::accept() by default.
// The installed eventFilter() in KScribbleApp takes care for closing the widget
// or ignoring the close event
}
void KScribbleView::keyPressEvent( QKeyEvent *e )
{
switch (e->key())
{
case Key_Right:
scrollBy( 10, 0 );
break;
case Key_Left:
scrollBy( -10,0);
break;
case Key_Up:
scrollBy( 0, -10 );
break;
case Key_Down:
scrollBy( 0, 10 );
break;
case Key_Home:
setContentsPos(0,0);
break;
case Key_End:
setContentsPos(0,viewport()->height()-viewport()->height());
break;
case Key_PageUp:
scrollBy( 0, -viewport()->height() );
break;
case Key_PageDown:
scrollBy( 0, viewport()->height() );
break;
}
}
void KScribbleView::viewportMousePressEvent( QMouseEvent *e )
{
if ( e->button() == LeftButton && action == IDLE)
{
action=DRAW;
doc->polyline[2] = doc->polyline[1] = doc->polyline[0] = viewportToContents(e->pos());
doc->updateAllViews(this);
}
else if ( e->button() == RightButton && action == IDLE)
{
action = SELECT;
QPoint pt=e->pos();
int x = pt.x() > contentsWidth() ? contentsWidth() : pt.x();
int y = pt.y() > contentsHeight() ? contentsHeight() : pt.y();
select.setLeft(x-1);
select.setTop(y-1);
select.setRight(x-1);
select.setBottom(y-1);
}
else if( action == SELECT )
{
action = IDLE;
select=select.normalize();
// drag
if(select.contains(e->pos(), true)) // point inside the selection
{
tmp.resize(select.size());
bitBlt(&tmp, 0, 0,
&doc->buffer, select.x()+contentsX(), select.y()+contentsY(), tmp.width(), tmp.height());
QImage img =tmp.convertToImage();
QDragObject *d = new QImageDrag( img, viewport() );
d->setPixmap(BarIcon("filenew"));
d->drag();
}
// remove selection
else
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
else if( action == PASTE )
{
if ( e->button() == RightButton )
{
action = IDLE;
viewport()->setCursor( Qt::crossCursor );
}
QPoint mv_pt (viewport()->height(), viewport()->width());
if(QRect(0,0,mv_pt.x(),mv_pt.y()).contains(e->pos()))
select.moveCenter(e->pos());
else
{
select.moveBottomRight(mv_pt);
}
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
}
void KScribbleView::viewportMouseReleaseEvent( QMouseEvent *e )
{
if ( action == DRAW )
{
action = IDLE;
doc->updateAllViews(this);
}
if ( action == SELECT)
{
QPoint pt=e->pos();
int x = pt.x() > 0 ? pt.x() : 0;
int y = pt.y() > 0 ? pt.y() : 0;
select.setRight(x);
select.setBottom(y);
QSize size=doc->docSize();
select = select.intersect(QRect(0,0,size.width(), size.height()));
}
}
/** On paste actions inserts the pasted clipboard contents
*/
void KScribbleView::viewportMouseDoubleClickEvent(QMouseEvent* e)
{
if( action == PASTE )
{
action = IDLE;
select.moveCenter(e->pos());
viewport()->setCursor( Qt::crossCursor );
QPixmap cb_pix;
cb_pix.resize(cb->pixmap().size());
cb_pix=cb->pixmap();
bitBlt( &doc->buffer, contentsX()+select.x(), contentsY()+select.y(),
&cb_pix, 0,0 , select.width(),select.height() );
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
doc->setModified();
doc->updateAllViews(this);
}
}
void KScribbleView::viewportMouseMoveEvent( QMouseEvent *e )
{
if ( action == DRAW )
{
QPainter painter;
painter.begin( &doc->buffer );
painter.setPen( doc->currentPen() );
doc->polyline[2] = doc->polyline[1];
doc->polyline[1] = doc->polyline[0];
doc->polyline[0] = viewportToContents(e->pos());
painter.drawPolyline( doc->polyline );
painter.end();
QRect r = doc->polyline.boundingRect();
r = r.normalize();
r.setLeft( r.left() - doc->penWidth() );
r.setTop( r.top() - doc->penWidth() );
r.setRight( r.right() + doc->penWidth() );
r.setBottom( r.bottom() + doc->penWidth() );
bitBlt(viewport(), r.x()-contentsX(), r.y()-contentsY() ,
&doc->buffer, r.x(), r.y(), r.width(), r.height() );
doc->setModified();
doc->updateAllViews(this);
}
if ( action == SELECT )
{
QPoint pt=e->pos();
select.setWidth(select.x()+pt.x());
select.setHeight(select.y()+pt.y());
select.setRight(pt.x());
select.setBottom(pt.y());
QSize size=doc->docSize();
select = select.intersect(QRect(0,0,size.width(), size.height()));
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
if( action == PASTE )
{
QPoint mv_pt (viewport()->height(), viewport()->width());
if(QRect(0,0,mv_pt.x(),mv_pt.y()).contains(e->pos()))
select.moveCenter(e->pos());
else
{
select.moveBottomRight(mv_pt);
}
QRect pm_rect=cb->pixmap().rect();
select.setWidth(pm_rect.width());
select.setHeight(pm_rect.height());
QSize size=doc->docSize();
select = select.intersect(QRect(0,0,size.width(), size.height()));
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
doc->setModified();
doc->updateAllViews(this);
}
}
//void KScribbleView::viewportResizeEvent( QResizeEvent *e )
//{
//}
void KScribbleView::viewportPaintEvent( QPaintEvent *e )
{
bitBlt( viewport(),0,0, &doc->buffer,contentsX() ,contentsY() );
if( action == PASTE )
{
tmp.resize(cb->pixmap().size());
tmp=cb->pixmap();
}
if( action == PASTE || action == DRAG )
{
QSize size=doc->docSize();
select = select.intersect(QRect(0,0,size.width(), size.height()));
if(select.intersects(e->rect()))
bitBlt(viewport(), select.x(), select.y(), &tmp, 0, 0, select.width(), select.height());
}
if( action == PASTE || action == DRAG || action == SELECT )
{
// if(select.intersects(e->rect()))
// {
QPainter paint_area;
paint_area.begin(viewport());
paint_area.setPen(QPen(Qt::black, 0, DashLine));
paint_area.drawRect( select );
paint_area.end();
// }
}
QScrollView::viewportPaintEvent(e);
}
void KScribbleView::viewportDragEnterEvent ( QDragEnterEvent * e)
{
e->accept(QImageDrag::canDecode(e));
action = DRAG;
}
void KScribbleView::viewportDragMoveEvent ( QDragMoveEvent * e)
{
QImage img;
if ( QImageDrag::decode(e, img) ){
tmp.resize(img.size());
tmp.convertFromImage(img);
select.setWidth(tmp.width());
select.setHeight(tmp.height());
select.moveCenter(e->pos());
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
}
void KScribbleView::viewportDragLeaveEvent ( QDragLeaveEvent * )
{
action = IDLE;
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
void KScribbleView::viewportDropEvent ( QDropEvent * e)
{
QImage img;
if ( QImageDrag::decode(e, img) )
{
tmp.resize(img.size());
tmp.convertFromImage(img);
select.setWidth(tmp.width());
select.setHeight(tmp.height());
select.moveCenter(e->pos());
bitBlt(&doc->buffer, select.x()+contentsX(), select.y()+contentsY(),
&tmp, 0, 0, tmp.width(), tmp.height());
doc->setModified();
doc->updateAllViews(this);
}
action = IDLE;
viewport()->repaint(0,0,visibleWidth(), visibleHeight(), false);
}
/***************************************************************************
kpenbrushdlg.h - description
-------------------
begin : Fri Jul 23 1999
copyright : (C) 1999 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef KPENBRUSHDLG_H
#define KPENBRUSHDLG_H
//Generated area. DO NOT EDIT!!!(begin)
#include <qwidget.h>
#include <qspinbox.h>
#include <qlabel.h>
#include <qpushbutton.h>
//Generated area. DO NOT EDIT!!!(end)
#include <qdialog.h>
#include <klocale.h>
/**
*@author Ralf Nolden
*/
class KPenBrushDlg : public QDialog {
Q_OBJECT
public:
KPenBrushDlg(int curr, QWidget *parent=0, const char *name=0);
~KPenBrushDlg();
int width() { return width_spbox->value(); };
protected slots:
void slotDefault();
protected:
void initDialog();
//Generated area. DO NOT EDIT!!!(begin)
QSpinBox *width_spbox;
QLabel *width_label;
QPushButton *default_btn;
QPushButton *ok_btn;
QPushButton *cancel_btn;
//Generated area. DO NOT EDIT!!!(end)
private:
};
#endif
/***************************************************************************
kpenbrushdlg.cpp - description
-------------------
begin : Fri Jul 23 1999
copyright : (C) 1999 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#include "kpenbrushdlg.h"
#include <qwhatsthis.h>
#include <kapp.h>
KPenBrushDlg::KPenBrushDlg(int curr, QWidget *parent, const char *name)
: QDialog(parent,name,true,WStyle_ContextHelp)
{
initDialog();
QWhatsThis::add(width_spbox,i18n("Select brush width"));
width_spbox->setValue(curr);
connect(default_btn, SIGNAL(clicked()), this, SLOT(slotDefault()));
connect(ok_btn, SIGNAL(clicked()), this, SLOT(accept()));
connect(cancel_btn, SIGNAL(clicked()), this, SLOT(reject()));
}
KPenBrushDlg::~KPenBrushDlg(){
}
void KPenBrushDlg::slotDefault(){
width_spbox->setValue(3);
}
/**********************************************************************
--- KDevelop (KDlgEdit) generated file ---
Last generated: Fri Jul 23 10:43:10 1999
DO NOT EDIT!!! This file will be automatically
regenerated by KDevelop. All changes will be lost.
**********************************************************************/
#include <kapp.h>
#include "kpenbrushdlg.h"
void KPenBrushDlg::initDialog(){
this->resize(370,210);
this->setMinimumSize(0,0);
width_spbox= new QSpinBox(this,"width_spbox");
width_spbox->setGeometry(150,50,100,25);
width_spbox->setMinimumSize(0,0);
width_spbox->setValue(1);
width_spbox->setRange(1,99);
width_label= new QLabel(this,"width_label");
width_label->setGeometry(20,50,120,25);
width_label->setMinimumSize(0,0);
width_label->setText(i18n("Pen Width:"));
default_btn= new QPushButton(this,"default");
default_btn->setGeometry(30,160,100,30);
default_btn->setMinimumSize(0,0);
default_btn->setText(i18n("Default"));
default_btn->setAutoDefault(true);
ok_btn= new QPushButton(this,"ok");
ok_btn->setGeometry(140,160,100,30);
ok_btn->setMinimumSize(0,0);
ok_btn->setText(i18n("OK"));
ok_btn->setAutoDefault(true);
cancel_btn= new QPushButton(this,"cancel");
cancel_btn->setGeometry(250,160,100,30);
cancel_btn->setMinimumSize(0,0);
cancel_btn->setText(i18n("Cancel"));
cancel_btn->setAutoDefault(true);
}
/***************************************************************************
resource.h - description
-------------------
begin : Mon Jan 31 11:05:05 CET 2000
copyright : (C) 2000 by Ralf Nolden
email : Ralf.Nolden@post.rwth-aachen.de
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef RESOURCE_H
#define RESOURCE_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
///////////////////////////////////////////////////////////////////
// resource.h -- contains macros used for commands
///////////////////////////////////////////////////////////////////
// COMMAND VALUES FOR MENUBAR AND TOOLBAR ENTRIES
///////////////////////////////////////////////////////////////////
// File-menu entries
#define ID_FILE_NEW 10010
#define ID_FILE_OPEN 10020
#define ID_FILE_OPEN_RECENT 10030
#define ID_FILE_CLOSE 10040
#define ID_FILE_SAVE 10050
#define ID_FILE_SAVE_AS 10060
#define ID_FILE_PRINT 10070
#define ID_FILE_QUIT 10080
///////////////////////////////////////////////////////////////////
// Edit-menu entries
#define ID_EDIT_UNDO 11010
#define ID_EDIT_COPY 11020
#define ID_EDIT_CUT 11030
#define ID_EDIT_PASTE 11040
#define ID_EDIT_CLEAR_ALL 11050
///////////////////////////////////////////////////////////////////
// Pen-menu entries
#define ID_PEN_COLOR 14010
#define ID_PEN_BRUSH 14020
///////////////////////////////////////////////////////////////////
// Draw-menu entries
#define ID_DRAW_FIND 15010
#define ID_DRAW_FREEHAND 15020
#define ID_DRAW_LINE 15030
#define ID_DRAW_RECT 15040
#define ID_DRAW_RECT_FILL 15050
#define ID_DRAW_CIRCLE 15060
#define ID_DRAW_CIRCLE_FILL 15070
#define ID_DRAW_ELLIPSE 15080
#define ID_DRAW_ELLIPSE_FILL 15090
#define ID_DRAW_SPRAY 15100
#define ID_DRAW_FILL 15110
#define ID_DRAW_ERASE 15120
///////////////////////////////////////////////////////////////////
// View-menu entries
#define ID_VIEW_TOOLBAR 12010
#define ID_VIEW_STATUSBAR 12020
///////////////////////////////////////////////////////////////////
// Window-menu entries
#define ID_WINDOW_NEW_WINDOW 13010
#define ID_WINDOW_CASCADE 13020
#define ID_WINDOW_TILE 13030
///////////////////////////////////////////////////////////////////
// Help-menu entries
#define ID_HELP_CONTENTS 1002
#define ID_HELP_WHATS_THIS 1003
///////////////////////////////////////////////////////////////////
// General application values
#define ID_STATUS_MSG 1001
#define TOOLS_TOOLBAR 1
#endif // RESOURCE_H
Weiter Zurück Inhaltsverzeichnis