1 | /* This file is part of the KDE project |
2 | Copyright (C) 1998, 1999, 2000 Torben Weis <weis@kde.org> |
3 | Copyright (C) 2002 - 2011 Dag Andersen <danders@get2net.dk> |
4 | Copyright (C) 2012 Dag Andersen <danders@get2net.dk> |
5 | |
6 | This library is free software; you can redistribute it and/or |
7 | modify it under the terms of the GNU Library General Public |
8 | License as published by the Free Software Foundation; either |
9 | version 2 of the License, or (at your option) any later version. |
10 | |
11 | This library is distributed in the hope that it will be useful, |
12 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | Library General Public License for more details. |
15 | |
16 | You should have received a copy of the GNU Library General Public License |
17 | along with this library; see the file COPYING.LIB. If not, write to |
18 | the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, |
19 | * Boston, MA 02110-1301, USA. |
20 | */ |
21 | |
22 | #include "kptview.h" |
23 | |
24 | #include <kmessagebox.h> |
25 | |
26 | #include "KoDocumentInfo.h" |
27 | #include "KoMainWindow.h" |
28 | #include <KoIcon.h> |
29 | |
30 | #include <QApplication> |
31 | #include <QLabel> |
32 | #include <QString> |
33 | #include <QStringList> |
34 | #include <QSize> |
35 | #include <QStackedWidget> |
36 | #include <QVBoxLayout> |
37 | #include <QTreeWidget> |
38 | #include <QTreeWidgetItem> |
39 | #include <QPrinter> |
40 | #include <QPrintDialog> |
41 | #include <QProgressBar> |
42 | #include <QSortFilterProxyModel> |
43 | #include <QDomDocument> |
44 | #include <QDomElement> |
45 | #include <kundo2command.h> |
46 | #include <QTimer> |
47 | #include <QDockWidget> |
48 | |
49 | #include <kaction.h> |
50 | #include <kactioncollection.h> |
51 | #include <kactionmenu.h> |
52 | #include <kmenu.h> |
53 | #include <kstandardaction.h> |
54 | #include <klocale.h> |
55 | #include <kdebug.h> |
56 | #include <ktoolbar.h> |
57 | #include <kstandardshortcut.h> |
58 | #include <kaccelgen.h> |
59 | #include <kconfigdialogmanager.h> |
60 | #include <kstatusbar.h> |
61 | #include <kxmlguifactory.h> |
62 | #include <kdesktopfile.h> |
63 | #include <ktoggleaction.h> |
64 | #include <ktemporaryfile.h> |
65 | #include <kfiledialog.h> |
66 | #include <kparts/event.h> |
67 | #include <kparts/partmanager.h> |
68 | #include <kconfigdialog.h> |
69 | #include <ktoolinvocation.h> |
70 | #include <krun.h> |
71 | #include <kstandarddirs.h> |
72 | #include <kservicetypetrader.h> |
73 | |
74 | #include <KoDocumentEntry.h> |
75 | #include <KoTemplateCreateDia.h> |
76 | #include <KoProgressUpdater.h> |
77 | #include <KoPart.h> |
78 | |
79 | #include "kptviewbase.h" |
80 | #include "kptaccountsview.h" |
81 | #include "kptaccountseditor.h" |
82 | #include "kptcalendareditor.h" |
83 | #include "kptfactory.h" |
84 | #include "kptmilestoneprogressdialog.h" |
85 | #include "kpttaskdescriptiondialog.h" |
86 | #include "kptnode.h" |
87 | #include "kptmaindocument.h" |
88 | #include "kptproject.h" |
89 | #include "kptmainprojectdialog.h" |
90 | #include "kpttask.h" |
91 | #include "kptsummarytaskdialog.h" |
92 | #include "kpttaskdialog.h" |
93 | #include "kpttaskprogressdialog.h" |
94 | #include "kptganttview.h" |
95 | #include "kpttaskeditor.h" |
96 | #include "kptdependencyeditor.h" |
97 | #include "kptperteditor.h" |
98 | #include "kptdatetime.h" |
99 | #include "kptcommand.h" |
100 | #include "kptrelation.h" |
101 | #include "kptrelationdialog.h" |
102 | #include "kptresourceappointmentsview.h" |
103 | #include "kptresourceeditor.h" |
104 | #include "kptscheduleeditor.h" |
105 | #include "kptresourcedialog.h" |
106 | #include "kptresource.h" |
107 | #include "kptstandardworktimedialog.h" |
108 | #include "kptwbsdefinitiondialog.h" |
109 | #include "kptresourceassignmentview.h" |
110 | #include "kpttaskstatusview.h" |
111 | #include "kptsplitterview.h" |
112 | #include "kptpertresult.h" |
113 | #include "kpttaskdefaultpanel.h" |
114 | #include "kptworkpackageconfigpanel.h" |
115 | #include "kptcolorsconfigpanel.h" |
116 | #include "kptinsertfiledlg.h" |
117 | #include "kpthtmlview.h" |
118 | #include "reports/reportview.h" |
119 | #include "reports/reportdata.h" |
120 | #include "about/aboutpage.h" |
121 | #include "kptlocaleconfigmoneydialog.h" |
122 | #include "kptflatproxymodel.h" |
123 | #include "kpttaskstatusmodel.h" |
124 | |
125 | #include "kptviewlistdialog.h" |
126 | #include "kptviewlistdocker.h" |
127 | #include "kptviewlist.h" |
128 | #include "kptschedulesdocker.h" |
129 | #include "kptdebug.h" |
130 | |
131 | #include "plansettings.h" |
132 | #include "kptprintingcontrolprivate.h" |
133 | |
134 | // #include "KPtViewAdaptor.h" |
135 | |
136 | #include <assert.h> |
137 | |
138 | namespace KPlato |
139 | { |
140 | |
141 | //------------------------------- |
142 | ConfigDialog::ConfigDialog(QWidget *parent, const QString& name, KConfigSkeleton *config ) |
143 | : KConfigDialog( parent, name, config ), |
144 | m_config( config ) |
145 | { |
146 | KConfigDialogManager::changedMap()->insert("KRichTextWidget" , SIGNAL(textChanged()) ); |
147 | } |
148 | |
149 | bool ConfigDialog::hasChanged() |
150 | { |
151 | QRegExp kcfg( "kcfg_*" ); |
152 | foreach ( KRichTextWidget *w, findChildren<KRichTextWidget*>( kcfg ) ) { |
153 | KConfigSkeletonItem *item = m_config->findItem( w->objectName().mid(5) ); |
154 | if ( ! item->isEqual( w->toHtml() ) ) { |
155 | return true; |
156 | } |
157 | } |
158 | return false; |
159 | } |
160 | |
161 | void ConfigDialog::updateSettings() |
162 | { |
163 | bool changed = false; |
164 | QRegExp kcfg( "kcfg_*" ); |
165 | foreach ( KRichTextWidget *w, findChildren<KRichTextWidget*>( kcfg ) ) { |
166 | KConfigSkeletonItem *item = m_config->findItem( w->objectName().mid(5) ); |
167 | if ( ! item ) { |
168 | kWarning() << "The setting '" << w->objectName().mid(5) << "' has disappeared!" ; |
169 | continue; |
170 | } |
171 | if ( ! item->isEqual( QVariant( w->toHtml() ) ) ) { |
172 | item->setProperty( QVariant( w->toHtml() ) ); |
173 | changed = true; |
174 | } |
175 | } |
176 | if ( changed ) { |
177 | m_config->writeConfig(); |
178 | } |
179 | } |
180 | |
181 | void ConfigDialog::updateWidgets() |
182 | { |
183 | QRegExp kcfg( "kcfg_*" ); |
184 | foreach ( KRichTextWidget *w, findChildren<KRichTextWidget*>( kcfg ) ) { |
185 | KConfigSkeletonItem *item = m_config->findItem( w->objectName().mid(5) ); |
186 | if ( ! item ) { |
187 | kWarning() << "The setting '" << w->objectName().mid(5) << "' has disappeared!" ; |
188 | continue; |
189 | } |
190 | if ( ! item->isEqual( QVariant( w->toHtml() ) ) ) { |
191 | w->setHtml( item->property().toString() ); |
192 | } |
193 | } |
194 | } |
195 | |
196 | void ConfigDialog::updateWidgetsDefault() |
197 | { |
198 | bool usedefault = m_config->useDefaults( true ); |
199 | updateWidgets(); |
200 | m_config->useDefaults( usedefault ); |
201 | } |
202 | |
203 | bool ConfigDialog::isDefault() |
204 | { |
205 | bool bUseDefaults = m_config->useDefaults(true); |
206 | bool result = !hasChanged(); |
207 | m_config->useDefaults(bUseDefaults); |
208 | return result; |
209 | } |
210 | |
211 | //------------------------------------ |
212 | View::View(KoPart *part, MainDocument *doc, QWidget *parent) |
213 | : KoView(part, doc, parent), |
214 | m_currentEstimateType( Estimate::Use_Expected ), |
215 | m_scheduleActionGroup( new QActionGroup( this ) ), |
216 | m_trigged( false ), |
217 | m_nextScheduleManager( 0 ), |
218 | m_readWrite( false ), |
219 | m_partpart (part) |
220 | { |
221 | //kDebug(planDbg()); |
222 | |
223 | doc->registerView( this ); |
224 | |
225 | setComponentData( Factory::global() ); |
226 | if ( !doc->isReadWrite() ) |
227 | setXMLFile( "plan_readonly.rc" ); |
228 | else |
229 | setXMLFile( "plan.rc" ); |
230 | |
231 | // new ViewAdaptor( this ); |
232 | |
233 | m_sp = new QSplitter( this ); |
234 | QVBoxLayout *layout = new QVBoxLayout( this ); |
235 | layout->setMargin(0); |
236 | layout->addWidget( m_sp ); |
237 | |
238 | ViewListDocker *docker = 0; |
239 | if ( mainWindow() == 0 ) { |
240 | // Don't use docker if embedded |
241 | m_viewlist = new ViewListWidget(doc, m_sp); |
242 | m_viewlist->setProject( &( getProject() ) ); |
243 | connect( m_viewlist, SIGNAL(selectionChanged(ScheduleManager*)), SLOT(slotSelectionChanged(ScheduleManager*)) ); |
244 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), m_viewlist, SLOT(setSelectedSchedule(ScheduleManager*)) ); |
245 | connect( m_viewlist, SIGNAL(updateViewInfo(ViewListItem*)), SLOT(slotUpdateViewInfo(ViewListItem*)) ); |
246 | } else { |
247 | ViewListDockerFactory vl(this); |
248 | docker = dynamic_cast<ViewListDocker *>(mainWindow()->createDockWidget(&vl)); |
249 | if (docker->view() != this) { |
250 | docker->setView(this); |
251 | } |
252 | m_viewlist = docker->viewList(); |
253 | #if 0 //SchedulesDocker |
254 | SchedulesDockerFactory sdf; |
255 | SchedulesDocker *sd = dynamic_cast<SchedulesDocker*>( createDockWidget( &sdf ) ); |
256 | Q_ASSERT( sd ); |
257 | |
258 | sd->setProject( &getProject() ); |
259 | connect( sd, SIGNAL(selectionChanged(ScheduleManager*)), SLOT(slotSelectionChanged(ScheduleManager*)) ); |
260 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), sd, SLOT(setSelectedSchedule(ScheduleManager*)) ); |
261 | #endif |
262 | } |
263 | |
264 | m_tab = new QStackedWidget( m_sp ); |
265 | |
266 | //////////////////////////////////////////////////////////////////////////////////////////////////// |
267 | |
268 | // Add sub views |
269 | createWelcomeView(); |
270 | |
271 | // The menu items |
272 | // ------ File |
273 | actionCreateTemplate = new KAction( i18n( "&Create Template From Document..." ), this ); |
274 | actionCollection()->addAction("file_createtemplate" , actionCreateTemplate ); |
275 | connect( actionCreateTemplate, SIGNAL(triggered(bool)), SLOT(slotCreateTemplate()) ); |
276 | |
277 | actionCreateNewProject = new KAction( i18n( "&Create New Project..." ), this ); |
278 | actionCollection()->addAction("file_createnewproject" , actionCreateNewProject ); |
279 | connect( actionCreateNewProject, SIGNAL(triggered(bool)), SLOT(slotCreateNewProject()) ); |
280 | |
281 | // ------ Edit |
282 | actionCut = actionCollection()->addAction(KStandardAction::Cut, "edit_cut" , this, SLOT(slotEditCut())); |
283 | actionCopy = actionCollection()->addAction(KStandardAction::Copy, "edit_copy" , this, SLOT(slotEditCopy())); |
284 | actionPaste = actionCollection()->addAction(KStandardAction::Paste, "edit_paste" , this, SLOT(slotEditPaste())); |
285 | |
286 | // ------ View |
287 | actionCollection()->addAction( KStandardAction::Redisplay, "view_refresh" , this, SLOT(slotRefreshView()) ); |
288 | |
289 | actionViewSelector = new KToggleAction(i18n("Show Selector" ), this); |
290 | actionCollection()->addAction("view_show_selector" , actionViewSelector ); |
291 | connect( actionViewSelector, SIGNAL(triggered(bool)), SLOT(slotViewSelector(bool)) ); |
292 | |
293 | // ------ Insert |
294 | |
295 | // ------ Project |
296 | actionEditMainProject = new KAction(koIcon("view-time-schedule-edit" ), i18n("Edit Main Project..." ), this); |
297 | actionCollection()->addAction("project_edit" , actionEditMainProject ); |
298 | connect( actionEditMainProject, SIGNAL(triggered(bool)), SLOT(slotProjectEdit()) ); |
299 | |
300 | actionEditStandardWorktime = new KAction(koIcon("configure" ), i18n("Define Estimate Conversions..." ), this); |
301 | actionCollection()->addAction("project_worktime" , actionEditStandardWorktime ); |
302 | connect( actionEditStandardWorktime, SIGNAL(triggered(bool)), SLOT(slotProjectWorktime()) ); |
303 | |
304 | |
305 | // ------ Tools |
306 | actionDefineWBS = new KAction(koIcon("configure" ), i18n("Define WBS Pattern..." ), this); |
307 | actionCollection()->addAction("tools_define_wbs" , actionDefineWBS ); |
308 | connect( actionDefineWBS, SIGNAL(triggered(bool)), SLOT(slotDefineWBS()) ); |
309 | |
310 | actionInsertFile = new KAction(koIcon("document-import" ), i18n("Insert Project File..." ), this); |
311 | actionCollection()->addAction("insert_file" , actionInsertFile ); |
312 | connect( actionInsertFile, SIGNAL(triggered(bool)), SLOT(slotInsertFile()) ); |
313 | |
314 | // ------ Settings |
315 | actionConfigure = new KAction(koIcon("configure" ), i18n("Configure Plan..." ), this); |
316 | actionCollection()->addAction("configure" , actionConfigure ); |
317 | connect( actionConfigure, SIGNAL(triggered(bool)), SLOT(slotConfigure()) ); |
318 | |
319 | actionCurrencyConfig = new KAction(koIcon("configure" ), i18n("Define Currency..." ), this); |
320 | actionCollection()->addAction( "config_currency" , actionCurrencyConfig ); |
321 | connect( actionCurrencyConfig, SIGNAL(triggered(bool)), SLOT(slotCurrencyConfig()) ); |
322 | |
323 | actionOpenReportFile = new KAction(koIcon("document-open" ), i18n("Open Report Definition File..." ), this); |
324 | actionCollection()->addAction( "reportdesigner_open_file" , actionOpenReportFile ); |
325 | connect( actionOpenReportFile, SIGNAL(triggered(bool)), SLOT(slotOpenReportFile()) ); |
326 | |
327 | // ------ Help |
328 | actionIntroduction = new KAction(koIcon("dialog-information" ), i18n("Introduction to Plan" ), this); |
329 | actionCollection()->addAction("plan_introduction" , actionIntroduction ); |
330 | connect( actionIntroduction, SIGNAL(triggered(bool)), SLOT(slotIntroduction()) ); |
331 | |
332 | // ------ Popup |
333 | actionOpenNode = new KAction(koIcon("document-edit" ), i18n("Edit..." ), this); |
334 | actionCollection()->addAction("node_properties" , actionOpenNode ); |
335 | connect( actionOpenNode, SIGNAL(triggered(bool)), SLOT(slotOpenNode()) ); |
336 | actionTaskProgress = new KAction(koIcon("document-edit" ), i18n("Progress..." ), this); |
337 | actionCollection()->addAction("task_progress" , actionTaskProgress ); |
338 | connect( actionTaskProgress, SIGNAL(triggered(bool)), SLOT(slotTaskProgress()) ); |
339 | actionDeleteTask = new KAction(koIcon("edit-delete" ), i18n("Delete Task" ), this); |
340 | actionCollection()->addAction("delete_task" , actionDeleteTask ); |
341 | connect( actionDeleteTask, SIGNAL(triggered(bool)), SLOT(slotDeleteTask()) ); |
342 | actionTaskDescription = new KAction(koIcon("document-edit" ), i18n("Description..." ), this); |
343 | actionCollection()->addAction("task_description" , actionTaskDescription ); |
344 | connect( actionTaskDescription, SIGNAL(triggered(bool)), SLOT(slotTaskDescription()) ); |
345 | actionIndentTask = new KAction(koIcon("format-indent-more" ), i18n("Indent Task" ), this); |
346 | actionCollection()->addAction("indent_task" , actionIndentTask ); |
347 | connect( actionIndentTask, SIGNAL(triggered(bool)), SLOT(slotIndentTask()) ); |
348 | actionUnindentTask= new KAction(koIcon("format-indent-less" ), i18n("Unindent Task" ), this); |
349 | actionCollection()->addAction("unindent_task" , actionUnindentTask ); |
350 | connect( actionUnindentTask, SIGNAL(triggered(bool)), SLOT(slotUnindentTask()) ); |
351 | actionMoveTaskUp = new KAction(koIcon("arrow-up" ), i18n("Move Task Up" ), this); |
352 | actionCollection()->addAction("move_task_up" , actionMoveTaskUp ); |
353 | connect( actionMoveTaskUp, SIGNAL(triggered(bool)), SLOT(slotMoveTaskUp()) ); |
354 | actionMoveTaskDown = new KAction(koIcon("arrow-down" ), i18n("Move Task Down" ), this); |
355 | actionCollection()->addAction("move_task_down" , actionMoveTaskDown ); |
356 | connect( actionMoveTaskDown, SIGNAL(triggered(bool)), SLOT(slotMoveTaskDown()) ); |
357 | |
358 | actionEditResource = new KAction(koIcon("document-edit" ), i18n("Edit Resource..." ), this); |
359 | actionCollection()->addAction("edit_resource" , actionEditResource ); |
360 | connect( actionEditResource, SIGNAL(triggered(bool)), SLOT(slotEditResource()) ); |
361 | |
362 | actionEditRelation = new KAction(koIcon("document-edit" ), i18n("Edit Dependency..." ), this); |
363 | actionCollection()->addAction("edit_dependency" , actionEditRelation ); |
364 | connect( actionEditRelation, SIGNAL(triggered(bool)), SLOT(slotModifyRelation()) ); |
365 | actionDeleteRelation = new KAction(koIcon("edit-delete" ), i18n("Delete Dependency" ), this); |
366 | actionCollection()->addAction("delete_dependency" , actionDeleteRelation ); |
367 | connect( actionDeleteRelation, SIGNAL(triggered(bool)), SLOT(slotDeleteRelation()) ); |
368 | |
369 | // Viewlist popup |
370 | connect( m_viewlist, SIGNAL(createView()), SLOT(slotCreateView()) ); |
371 | |
372 | m_estlabel = new QLabel( "" , 0 ); |
373 | if ( statusBar() ) { |
374 | addStatusBarItem( m_estlabel, 0, true ); |
375 | } |
376 | |
377 | connect( &getProject(), SIGNAL(scheduleChanged(MainSchedule*)), SLOT(slotScheduleChanged(MainSchedule*)) ); |
378 | |
379 | connect( &getProject(), SIGNAL(scheduleAdded(const MainSchedule*)), SLOT(slotScheduleAdded(const MainSchedule*)) ); |
380 | connect( &getProject(), SIGNAL(scheduleRemoved(const MainSchedule*)), SLOT(slotScheduleRemoved(const MainSchedule*)) ); |
381 | slotPlugScheduleActions(); |
382 | |
383 | connect( doc, SIGNAL(changed()), SLOT(slotUpdate()) ); |
384 | |
385 | connect( m_scheduleActionGroup, SIGNAL(triggered(QAction*)), SLOT(slotViewSchedule(QAction*)) ); |
386 | |
387 | |
388 | connect( getPart(), SIGNAL(workPackageLoaded()), SLOT(slotWorkPackageLoaded()) ); |
389 | |
390 | // hide unused dockers |
391 | QTimer::singleShot( 0, this, SLOT(hideToolDocker()) ); |
392 | // create views after dockers hidden, views take time for large projects |
393 | QTimer::singleShot( 100, this, SLOT(initiateViews()) ); |
394 | |
395 | KService::List offers = KServiceTypeTrader::self()->query(QString::fromLatin1("Plan/ViewPlugin" ), |
396 | QString::fromLatin1("(Type == 'Service') and " |
397 | "([X-Plan-Version] == 28)" )); |
398 | |
399 | KService::List::ConstIterator iter; |
400 | for(iter = offers.constBegin(); iter != offers.constEnd(); ++iter) { |
401 | |
402 | KService::Ptr service = *iter; |
403 | QString error; |
404 | KXMLGUIClient* plugin = |
405 | dynamic_cast<KXMLGUIClient*>(service->createInstance<QObject>(this, QVariantList(), &error)); |
406 | if(plugin) { |
407 | insertChildClient(plugin); |
408 | } else { |
409 | if(!error.isEmpty()) { |
410 | kWarning() << " Error loading plugin was : ErrNoLibrary" << error; |
411 | } |
412 | } |
413 | } |
414 | |
415 | //kDebug(planDbg())<<" end"; |
416 | } |
417 | |
418 | View::~View() |
419 | { |
420 | /* removeStatusBarItem( m_estlabel ); |
421 | delete m_estlabel;*/ |
422 | } |
423 | |
424 | // hackish way to get rid of unused dockers, but as long as no official way exists... |
425 | void View::hideToolDocker() |
426 | { |
427 | if ( mainWindow() ) { |
428 | QStringList lst; lst << "KPlatoViewList" << "Scripting" ; |
429 | QStringList names; |
430 | foreach ( QDockWidget *w, mainWindow()->dockWidgets() ) { |
431 | if ( ! lst.contains( w->objectName() ) ) { |
432 | names << w->windowTitle(); |
433 | w->setFeatures( QDockWidget::DockWidgetClosable ); |
434 | w->hide(); |
435 | } |
436 | } |
437 | foreach(const KActionCollection *c, KActionCollection::allCollections()) { |
438 | KActionMenu *a = qobject_cast<KActionMenu*>(c->action("settings_dockers_menu" )); |
439 | if ( a ) { |
440 | QList<QAction*> actions = a->menu()->actions(); |
441 | foreach ( QAction *act, actions ) { |
442 | if ( names.contains( act->text() ) ) { |
443 | a->removeAction( act ); |
444 | } |
445 | } |
446 | a->addSeparator(); |
447 | break; |
448 | } |
449 | } |
450 | } |
451 | } |
452 | |
453 | void View::initiateViews() |
454 | { |
455 | QApplication::setOverrideCursor( Qt::WaitCursor ); |
456 | createViews(); |
457 | |
458 | connect( m_viewlist, SIGNAL(activated(ViewListItem*,ViewListItem*)), SLOT(slotViewActivated(ViewListItem*,ViewListItem*)) ); |
459 | // after createViews() !! |
460 | connect( m_viewlist, SIGNAL(viewListItemRemoved(ViewListItem*)), SLOT(slotViewListItemRemoved(ViewListItem*)) ); |
461 | // after createViews() !! |
462 | connect( m_viewlist, SIGNAL(viewListItemInserted(ViewListItem*,ViewListItem*,int)), SLOT(slotViewListItemInserted(ViewListItem*,ViewListItem*,int)) ); |
463 | |
464 | QDockWidget *docker = qobject_cast<QDockWidget*>( m_viewlist->parent() ); |
465 | if ( docker ) { |
466 | // after createViews() !! |
467 | connect( m_viewlist, SIGNAL(modified()), docker, SLOT(slotModified())); |
468 | connect( m_viewlist, SIGNAL(modified()), getPart(), SLOT(viewlistModified())); |
469 | connect(getPart(), SIGNAL(viewlistModified(bool)), docker, SLOT(updateWindowTitle(bool))); |
470 | } |
471 | connect( m_tab, SIGNAL(currentChanged(int)), this, SLOT(slotCurrentChanged(int)) ); |
472 | |
473 | loadContext(); |
474 | |
475 | QApplication::restoreOverrideCursor(); |
476 | } |
477 | |
478 | void View::slotCreateTemplate() |
479 | { |
480 | KoTemplateCreateDia::createTemplate("plan_template" , ".plant" , |
481 | Factory::global(), getPart(), this); |
482 | } |
483 | |
484 | void View::slotCreateNewProject() |
485 | { |
486 | kDebug(planDbg()); |
487 | if ( KMessageBox::Continue == KMessageBox::warningContinueCancel( this, |
488 | i18nc( "@info" , |
489 | "<note>This action cannot be undone.</note><nl/><nl/>" |
490 | "Create a new Project from the current project " |
491 | "with new project- and task identities.<nl/>" |
492 | "Resource- and calendar identities are not changed.<nl/>" |
493 | "All scheduling information is removed.<nl/>" |
494 | "<nl/>Do you want to continue?" ) ) ) |
495 | { |
496 | getPart()->createNewProject(); |
497 | slotOpenNode( &getProject() ); |
498 | } |
499 | } |
500 | |
501 | void View::createViews() |
502 | { |
503 | Context *ctx = getPart()->context(); |
504 | if ( ctx && ctx->isLoaded() ) { |
505 | kDebug(planDbg())<<"isLoaded" ; |
506 | KoXmlNode n = ctx->context().namedItem( "categories" ); |
507 | if ( n.isNull() ) { |
508 | kWarning()<<"No categories" ; |
509 | } else { |
510 | n = n.firstChild(); |
511 | for ( ; ! n.isNull(); n = n.nextSibling() ) { |
512 | if ( ! n.isElement() ) { |
513 | continue; |
514 | } |
515 | KoXmlElement e = n.toElement(); |
516 | if (e.tagName() != "category" ) { |
517 | continue; |
518 | } |
519 | kDebug(planDbg())<<"category: " <<e.attribute( "tag" ); |
520 | ViewListItem *cat; |
521 | QString cn = e.attribute( "name" ); |
522 | QString ct = e.attribute( "tag" ); |
523 | if ( cn.isEmpty() ) { |
524 | cn = defaultCategoryInfo( ct ).name; |
525 | } |
526 | cat = m_viewlist->addCategory( ct, cn ); |
527 | KoXmlNode n1 = e.firstChild(); |
528 | for ( ; ! n1.isNull(); n1 = n1.nextSibling() ) { |
529 | if ( ! n1.isElement() ) { |
530 | continue; |
531 | } |
532 | KoXmlElement e1 = n1.toElement(); |
533 | if (e1.tagName() != "view" ) { |
534 | continue; |
535 | } |
536 | ViewBase *v = 0; |
537 | QString type = e1.attribute( "viewtype" ); |
538 | QString tag = e1.attribute( "tag" ); |
539 | QString name = e1.attribute( "name" ); |
540 | QString tip = e1.attribute( "tooltip" ); |
541 | v = createView( cat, type, tag, name, tip ); |
542 | //KoXmlNode settings = e1.namedItem( "settings " ); ???? |
543 | KoXmlNode settings = e1.firstChild(); |
544 | for ( ; ! settings.isNull(); settings = settings.nextSibling() ) { |
545 | if ( settings.nodeName() == "settings" ) { |
546 | break; |
547 | } |
548 | } |
549 | if ( v && settings.isElement() ) { |
550 | kDebug(planDbg())<<" settings" ; |
551 | v->loadContext( settings.toElement() ); |
552 | } |
553 | } |
554 | } |
555 | } |
556 | } else { |
557 | kDebug(planDbg())<<"Default" ; |
558 | ViewListItem *cat; |
559 | QString ct = "Editors" ; |
560 | cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name ); |
561 | |
562 | createCalendarEditor( cat, "CalendarEditor" , QString(), TIP_USE_DEFAULT_TEXT ); |
563 | |
564 | createAccountsEditor( cat, "AccountsEditor" , QString(), TIP_USE_DEFAULT_TEXT ); |
565 | |
566 | createResourceEditor( cat, "ResourceEditor" , QString(), TIP_USE_DEFAULT_TEXT ); |
567 | |
568 | createTaskEditor( cat, "TaskEditor" , QString(), TIP_USE_DEFAULT_TEXT ); |
569 | |
570 | createDependencyEditor( cat, "DependencyEditor" , QString(), TIP_USE_DEFAULT_TEXT ); |
571 | |
572 | createPertEditor( cat, "PertEditor" , QString(), TIP_USE_DEFAULT_TEXT ); |
573 | |
574 | createScheduleHandler( cat, "ScheduleHandlerView" , QString(), TIP_USE_DEFAULT_TEXT ); |
575 | |
576 | ct = "Views" ; |
577 | cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name ); |
578 | |
579 | createGanttView( cat, "GanttView" , QString(), TIP_USE_DEFAULT_TEXT ); |
580 | |
581 | createMilestoneGanttView( cat, "MilestoneGanttView" , QString(), TIP_USE_DEFAULT_TEXT ); |
582 | |
583 | createResourceAppointmentsView( cat, "ResourceAppointmentsView" , QString(), TIP_USE_DEFAULT_TEXT ); |
584 | |
585 | createResourceAppointmentsGanttView( cat, "ResourceAppointmentsGanttView" , QString(), TIP_USE_DEFAULT_TEXT ); |
586 | |
587 | createAccountsView( cat, "AccountsView" , QString(), TIP_USE_DEFAULT_TEXT ); |
588 | |
589 | ct = "Execution" ; |
590 | cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name ); |
591 | |
592 | createProjectStatusView( cat, "ProjectStatusView" , QString(), TIP_USE_DEFAULT_TEXT ); |
593 | |
594 | createPerformanceStatusView( cat, "PerformanceStatusView" , QString(), TIP_USE_DEFAULT_TEXT ); |
595 | |
596 | createTaskStatusView( cat, "TaskStatusView" , QString(), TIP_USE_DEFAULT_TEXT ); |
597 | |
598 | createTaskView( cat, "TaskView" , QString(), TIP_USE_DEFAULT_TEXT ); |
599 | |
600 | createTaskWorkPackageView( cat, "TaskWorkPackageView" , QString(), TIP_USE_DEFAULT_TEXT ); |
601 | |
602 | ct = "Reports" ; |
603 | cat = m_viewlist->addCategory( ct, defaultCategoryInfo( ct ).name ); |
604 | // A little hack to get the user started... |
605 | ReportView *rv = qobject_cast<ReportView*>( createReportView( cat, "ReportView" , i18n( "Task Status Report" ), TIP_USE_DEFAULT_TEXT ) ); |
606 | if ( rv ) { |
607 | QDomDocument doc; |
608 | doc.setContent( standardTaskStatusReport() ); |
609 | rv->loadXML( doc ); |
610 | } |
611 | } |
612 | } |
613 | |
614 | ViewBase *View::createView( ViewListItem *cat, const QString &type, const QString &tag, const QString &name, const QString &tip, int index ) |
615 | { |
616 | ViewBase *v = 0; |
617 | //NOTE: type is the same as classname (so if it is changed...) |
618 | if ( type == "CalendarEditor" ) { |
619 | v = createCalendarEditor( cat, tag, name, tip, index ); |
620 | } else if ( type == "AccountsEditor" ) { |
621 | v = createAccountsEditor( cat, tag, name, tip, index ); |
622 | } else if ( type == "ResourceEditor" ) { |
623 | v = createResourceEditor( cat, tag, name, tip, index ); |
624 | } else if ( type == "TaskEditor" ) { |
625 | v = createTaskEditor( cat, tag, name, tip, index ); |
626 | } else if ( type == "DependencyEditor" ) { |
627 | v = createDependencyEditor( cat, tag, name, tip, index ); |
628 | } else if ( type == "PertEditor" ) { |
629 | v = createPertEditor( cat, tag, name, tip, index ); |
630 | } else if ( type == "ScheduleEditor" ) { |
631 | v = createScheduleEditor( cat, tag, name, tip, index ); |
632 | } else if ( type == "ScheduleHandlerView" ) { |
633 | v = createScheduleHandler( cat, tag, name, tip, index ); |
634 | } else if ( type == "ProjectStatusView" ) { |
635 | v = createProjectStatusView( cat, tag, name, tip, index ); |
636 | } else if ( type == "TaskStatusView" ) { |
637 | v = createTaskStatusView( cat, tag, name, tip, index ); |
638 | } else if ( type == "TaskView" ) { |
639 | v = createTaskView( cat, tag, name, tip, index ); |
640 | } else if ( type == "TaskWorkPackageView" ) { |
641 | v = createTaskWorkPackageView( cat, tag, name, tip, index ); |
642 | } else if ( type == "GanttView" ) { |
643 | v = createGanttView( cat, tag, name, tip, index ); |
644 | } else if ( type == "MilestoneGanttView" ) { |
645 | v = createMilestoneGanttView( cat, tag, name, tip, index ); |
646 | } else if ( type == "ResourceAppointmentsView" ) { |
647 | v = createResourceAppointmentsView( cat, tag, name, tip, index ); |
648 | } else if ( type == "ResourceAppointmentsGanttView" ) { |
649 | v = createResourceAppointmentsGanttView( cat, tag, name, tip, index ); |
650 | } else if ( type == "AccountsView" ) { |
651 | v = createAccountsView( cat, tag, name, tip, index ); |
652 | } else if ( type == "PerformanceStatusView" ) { |
653 | v = createPerformanceStatusView( cat, tag, name, tip, index ); |
654 | } else if ( type == "ReportView" ) { |
655 | v = createReportView( cat, tag, name, tip, index ); |
656 | } else { |
657 | kWarning()<<"Unknown viewtype: " <<type; |
658 | } |
659 | return v; |
660 | } |
661 | |
662 | void View::slotUpdateViewInfo( ViewListItem *itm ) |
663 | { |
664 | if ( itm->type() == ViewListItem::ItemType_SubView ) { |
665 | itm->setViewInfo( defaultViewInfo( itm->viewType() ) ); |
666 | } else if ( itm->type() == ViewListItem::ItemType_Category ) { |
667 | ViewInfo vi = defaultCategoryInfo( itm->tag() ); |
668 | itm->setViewInfo( vi ); |
669 | } |
670 | } |
671 | |
672 | ViewInfo View::defaultViewInfo( const QString &type ) const |
673 | { |
674 | ViewInfo vi; |
675 | if ( type == "CalendarEditor" ) { |
676 | vi.name = i18n( "Work & Vacation" ); |
677 | vi.tip = i18nc( "@info:tooltip" , "Edit working- and vacation days for resources" ); |
678 | } else if ( type == "AccountsEditor" ) { |
679 | vi.name = i18n( "Cost Breakdown Structure" ); |
680 | vi.tip = i18nc( "@info:tooltip" , "Edit cost breakdown structure." ); |
681 | } else if ( type == "ResourceEditor" ) { |
682 | vi.name = i18n( "Resources" ); |
683 | vi.tip = i18nc( "@info:tooltip" , "Edit resource breakdown structure" ); |
684 | } else if ( type == "TaskEditor" ) { |
685 | vi.name = i18n( "Tasks" ); |
686 | vi.tip = i18nc( "@info:tooltip" , "Edit work breakdown structure" ); |
687 | } else if ( type == "DependencyEditor" ) { |
688 | vi.name = i18n( "Dependencies (Graphic)" ); |
689 | vi.tip = i18nc( "@info:tooltip" , "Edit task dependencies" ); |
690 | } else if ( type == "PertEditor" ) { |
691 | vi.name = i18n( "Dependencies (List)" ); |
692 | vi.tip = i18nc( "@info:tooltip" , "Edit task dependencies" ); |
693 | } else if ( type == "ScheduleEditor" ) { |
694 | // This view is not used stand-alone atm |
695 | vi.name = i18n( "Schedules" ); |
696 | } else if ( type == "ScheduleHandlerView" ) { |
697 | vi.name = i18n( "Schedules" ); |
698 | vi.tip = i18nc( "@info:tooltip" , "Calculate and analyze project schedules" ); |
699 | } else if ( type == "ProjectStatusView" ) { |
700 | vi.name = i18n( "Project Performance Chart" ); |
701 | vi.tip = i18nc( "@info:tooltip" , "View project status information" ); |
702 | } else if ( type == "TaskStatusView" ) { |
703 | vi.name = i18n( "Task Status" ); |
704 | vi.tip = i18nc( "@info:tooltip" , "View task progress information" ); |
705 | } else if ( type == "TaskView" ) { |
706 | vi.name = i18n( "Task Execution" ); |
707 | vi.tip = i18nc( "@info:tooltip" , "View task execution information" ); |
708 | } else if ( type == "TaskWorkPackageView" ) { |
709 | vi.name = i18n( "Work Package View" ); |
710 | vi.tip = i18nc( "@info:tooltip" , "View task work package information" ); |
711 | } else if ( type == "GanttView" ) { |
712 | vi.name = i18n( "Gantt" ); |
713 | vi.tip = i18nc( "@info:tooltip" , "View Gantt chart" ); |
714 | } else if ( type == "MilestoneGanttView" ) { |
715 | vi.name = i18n( "Milestone Gantt" ); |
716 | vi.tip = i18nc( "@info:tooltip" , "View milestone Gantt chart" ); |
717 | } else if ( type == "ResourceAppointmentsView" ) { |
718 | vi.name = i18n( "Resource Assignments" ); |
719 | vi.tip = i18nc( "@info:tooltip" , "View resource assignments in a table" ); |
720 | } else if ( type == "ResourceAppointmentsGanttView" ) { |
721 | vi.name = i18n( "Resource Assignments (Gantt)" ); |
722 | vi.tip = i18nc( "@info:tooltip" , "View resource assignments in Gantt chart" ); |
723 | } else if ( type == "AccountsView" ) { |
724 | vi.name = i18n( "Cost Breakdown" ); |
725 | vi.tip = i18nc( "@info:tooltip" , "View planned and actual cost" ); |
726 | } else if ( type == "PerformanceStatusView" ) { |
727 | vi.name = i18n( "Tasks Performance Chart" ); |
728 | vi.tip = i18nc( "@info:tooltip" , "View tasks performance status information" ); |
729 | } else if ( type == "ReportView" ) { |
730 | vi.name = i18n( "Report" ); |
731 | vi.tip = i18nc( "@info:tooltip" , "View report" ); |
732 | } else { |
733 | kWarning()<<"Unknown viewtype: " <<type; |
734 | } |
735 | return vi; |
736 | } |
737 | |
738 | ViewInfo View::defaultCategoryInfo( const QString &type ) const |
739 | { |
740 | ViewInfo vi; |
741 | if ( type == "Editors" ) { |
742 | vi.name = i18n( "Editors" ); |
743 | } else if ( type == "Views" ) { |
744 | vi.name = i18n( "Views" ); |
745 | } else if ( type == "Execution" ) { |
746 | vi.name = i18nc( "Project execution views" , "Execution" ); |
747 | } else if ( type == "Reports" ) { |
748 | vi.name = i18n( "Reports" ); |
749 | } |
750 | return vi; |
751 | } |
752 | |
753 | void View::slotOpenUrlRequest( HtmlView *v, const KUrl &url ) |
754 | { |
755 | if ( url.url().startsWith( QLatin1String( "about:plan" ) ) ) { |
756 | getPart()->aboutPage().generatePage( v->htmlPart(), url ); |
757 | return; |
758 | } |
759 | if ( url.protocol() == "help" ) { |
760 | KToolInvocation::invokeHelp( "" , url.fileName() ); |
761 | return; |
762 | } |
763 | // try to open the url |
764 | new KRun( url, mainWindow() ); |
765 | } |
766 | |
767 | ViewBase *View::createWelcomeView() |
768 | { |
769 | HtmlView *v = new HtmlView(getKoPart(), getPart(), m_tab ); |
770 | v->htmlPart().setJScriptEnabled(false); |
771 | v->htmlPart().setJavaEnabled(false); |
772 | v->htmlPart().setMetaRefreshEnabled(false); |
773 | v->htmlPart().setPluginsEnabled(false); |
774 | |
775 | slotOpenUrlRequest( v, KUrl( "about:plan/main" ) ); |
776 | |
777 | connect( v, SIGNAL(openUrlRequest(HtmlView*,KUrl)), SLOT(slotOpenUrlRequest(HtmlView*,KUrl)) ); |
778 | |
779 | m_tab->addWidget( v ); |
780 | return v; |
781 | } |
782 | |
783 | ViewBase *View::createResourceAppointmentsGanttView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
784 | { |
785 | ResourceAppointmentsGanttView *v = new ResourceAppointmentsGanttView(getKoPart(), getPart(), m_tab ); |
786 | m_tab->addWidget( v ); |
787 | |
788 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
789 | ViewInfo vi = defaultViewInfo( "ResourceAppointmentsGanttView" ); |
790 | if ( name.isEmpty() ) { |
791 | i->setText( 0, vi.name ); |
792 | } |
793 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
794 | i->setToolTip( 0, vi.tip ); |
795 | } else { |
796 | i->setToolTip( 0, tip ); |
797 | } |
798 | |
799 | |
800 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
801 | |
802 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
803 | |
804 | connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
805 | |
806 | v->setProject( &( getProject() ) ); |
807 | v->setScheduleManager( currentScheduleManager() ); |
808 | v->updateReadWrite( m_readWrite ); |
809 | return v; |
810 | } |
811 | |
812 | |
813 | ViewBase *View::createResourceAppointmentsView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
814 | { |
815 | ResourceAppointmentsView *v = new ResourceAppointmentsView(getKoPart(), getPart(), m_tab ); |
816 | m_tab->addWidget( v ); |
817 | |
818 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
819 | ViewInfo vi = defaultViewInfo( "ResourceAppointmentsView" ); |
820 | if ( name.isEmpty() ) { |
821 | i->setText( 0, vi.name ); |
822 | } |
823 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
824 | i->setToolTip( 0, vi.tip ); |
825 | } else { |
826 | i->setToolTip( 0, tip ); |
827 | } |
828 | |
829 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
830 | |
831 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
832 | |
833 | connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
834 | |
835 | v->setProject( &( getProject() ) ); |
836 | v->setScheduleManager( currentScheduleManager() ); |
837 | v->updateReadWrite( m_readWrite ); |
838 | return v; |
839 | } |
840 | |
841 | ViewBase *View::createResourceEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
842 | { |
843 | ResourceEditor *resourceeditor = new ResourceEditor(getKoPart(), getPart(), m_tab ); |
844 | m_tab->addWidget( resourceeditor ); |
845 | resourceeditor->setProject( &(getProject()) ); |
846 | |
847 | ViewListItem *i = m_viewlist->addView( cat, tag, name, resourceeditor, getPart(), "" , index ); |
848 | ViewInfo vi = defaultViewInfo( "ResourceEditor" ); |
849 | if ( name.isEmpty() ) { |
850 | i->setText( 0, vi.name ); |
851 | } |
852 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
853 | i->setToolTip( 0, vi.tip ); |
854 | } else { |
855 | i->setToolTip( 0, tip ); |
856 | } |
857 | |
858 | connect( resourceeditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
859 | |
860 | connect( resourceeditor, SIGNAL(deleteObjectList(QObjectList)), SLOT(slotDeleteResourceObjects(QObjectList)) ); |
861 | |
862 | connect( resourceeditor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
863 | resourceeditor->updateReadWrite( m_readWrite ); |
864 | return resourceeditor; |
865 | } |
866 | |
867 | ViewBase *View::createTaskEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
868 | { |
869 | TaskEditor *taskeditor = new TaskEditor(getKoPart(), getPart(), m_tab ); |
870 | m_tab->addWidget( taskeditor ); |
871 | |
872 | ViewListItem *i = m_viewlist->addView( cat, tag, name, taskeditor, getPart(), "" , index ); |
873 | ViewInfo vi = defaultViewInfo( "TaskEditor" ); |
874 | if ( name.isEmpty() ) { |
875 | i->setText( 0, vi.name ); |
876 | } |
877 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
878 | i->setToolTip( 0, vi.tip ); |
879 | } else { |
880 | i->setToolTip( 0, tip ); |
881 | } |
882 | |
883 | taskeditor->setProject( &(getProject()) ); |
884 | taskeditor->setScheduleManager( currentScheduleManager() ); |
885 | |
886 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), taskeditor, SLOT(setScheduleManager(ScheduleManager*)) ); |
887 | |
888 | connect( taskeditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
889 | |
890 | connect( taskeditor, SIGNAL(addTask()), SLOT(slotAddTask()) ); |
891 | connect( taskeditor, SIGNAL(addMilestone()), SLOT(slotAddMilestone()) ); |
892 | connect( taskeditor, SIGNAL(addSubtask()), SLOT(slotAddSubTask()) ); |
893 | connect( taskeditor, SIGNAL(addSubMilestone()), SLOT(slotAddSubMilestone()) ); |
894 | connect( taskeditor, SIGNAL(deleteTaskList(QList<Node*>)), SLOT(slotDeleteTask(QList<Node*>)) ); |
895 | connect( taskeditor, SIGNAL(moveTaskUp()), SLOT(slotMoveTaskUp()) ); |
896 | connect( taskeditor, SIGNAL(moveTaskDown()), SLOT(slotMoveTaskDown()) ); |
897 | connect( taskeditor, SIGNAL(indentTask()), SLOT(slotIndentTask()) ); |
898 | connect( taskeditor, SIGNAL(unindentTask()), SLOT(slotUnindentTask()) ); |
899 | |
900 | connect(taskeditor, SIGNAL(saveTaskModule(KUrl,Project*)), SLOT(saveTaskModule(KUrl,Project*))); |
901 | connect(taskeditor, SIGNAL(removeTaskModule(KUrl)), SLOT(removeTaskModule(KUrl))); |
902 | |
903 | connect( taskeditor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
904 | taskeditor->updateReadWrite( m_readWrite ); |
905 | |
906 | // last: |
907 | taskeditor->setTaskModules( Factory::global().dirs()->findAllResources( "plan_taskmodules" , QString(), KStandardDirs::NoDuplicates ) ); |
908 | return taskeditor; |
909 | } |
910 | |
911 | ViewBase *View::createAccountsEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
912 | { |
913 | AccountsEditor *ae = new AccountsEditor(getKoPart(), getPart(), m_tab ); |
914 | m_tab->addWidget( ae ); |
915 | |
916 | ViewListItem *i = m_viewlist->addView( cat, tag, name, ae, getPart(), "" , index ); |
917 | ViewInfo vi = defaultViewInfo( "AccountsEditor" ); |
918 | if ( name.isEmpty() ) { |
919 | i->setText( 0, vi.name ); |
920 | } |
921 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
922 | i->setToolTip( 0, vi.tip ); |
923 | } else { |
924 | i->setToolTip( 0, tip ); |
925 | } |
926 | |
927 | ae->draw( getProject() ); |
928 | |
929 | connect( ae, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
930 | ae->updateReadWrite( m_readWrite ); |
931 | return ae; |
932 | } |
933 | |
934 | ViewBase *View::createCalendarEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
935 | { |
936 | CalendarEditor *calendareditor = new CalendarEditor(getKoPart(), getPart(), m_tab ); |
937 | m_tab->addWidget( calendareditor ); |
938 | |
939 | ViewListItem *i = m_viewlist->addView( cat, tag, name, calendareditor, getPart(), "" , index ); |
940 | ViewInfo vi = defaultViewInfo( "CalendarEditor" ); |
941 | if ( name.isEmpty() ) { |
942 | i->setText( 0, vi.name ); |
943 | } |
944 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
945 | i->setToolTip( 0, vi.tip ); |
946 | } else { |
947 | i->setToolTip( 0, tip ); |
948 | } |
949 | |
950 | calendareditor->draw( getProject() ); |
951 | |
952 | connect( calendareditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
953 | |
954 | connect( calendareditor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
955 | calendareditor->updateReadWrite( m_readWrite ); |
956 | return calendareditor; |
957 | } |
958 | |
959 | ViewBase *View::createScheduleHandler( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
960 | { |
961 | ScheduleHandlerView *handler = new ScheduleHandlerView(getKoPart(), getPart(), m_tab ); |
962 | m_tab->addWidget( handler ); |
963 | |
964 | ViewListItem *i = m_viewlist->addView( cat, tag, name, handler, getPart(), "" , index ); |
965 | ViewInfo vi = defaultViewInfo( "ScheduleHandlerView" ); |
966 | if ( name.isEmpty() ) { |
967 | i->setText( 0, vi.name ); |
968 | } |
969 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
970 | i->setToolTip( 0, vi.tip ); |
971 | } else { |
972 | i->setToolTip( 0, tip ); |
973 | } |
974 | |
975 | connect( handler->scheduleEditor(), SIGNAL(addScheduleManager(Project*)), SLOT(slotAddScheduleManager(Project*)) ); |
976 | connect( handler->scheduleEditor(), SIGNAL(deleteScheduleManager(Project*,ScheduleManager*)), SLOT(slotDeleteScheduleManager(Project*,ScheduleManager*)) ); |
977 | connect( handler->scheduleEditor(), SIGNAL(moveScheduleManager(ScheduleManager*,ScheduleManager*,int)), SLOT(slotMoveScheduleManager(ScheduleManager*,ScheduleManager*,int))); |
978 | |
979 | connect( handler->scheduleEditor(), SIGNAL(calculateSchedule(Project*,ScheduleManager*)), SLOT(slotCalculateSchedule(Project*,ScheduleManager*)) ); |
980 | |
981 | connect( handler->scheduleEditor(), SIGNAL(baselineSchedule(Project*,ScheduleManager*)), SLOT(slotBaselineSchedule(Project*,ScheduleManager*)) ); |
982 | |
983 | |
984 | connect( handler, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
985 | |
986 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), handler, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)) ); |
987 | |
988 | connect( handler, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
989 | |
990 | connect(handler, SIGNAL(editNode(Node*)), this, SLOT(slotOpenNode(Node*))); |
991 | connect(handler, SIGNAL(editResource(Resource*)), this, SLOT(slotEditResource(Resource*))); |
992 | |
993 | handler->draw( getProject() ); |
994 | handler->updateReadWrite( m_readWrite ); |
995 | return handler; |
996 | } |
997 | |
998 | ScheduleEditor *View::createScheduleEditor( QWidget *parent ) |
999 | { |
1000 | ScheduleEditor *scheduleeditor = new ScheduleEditor(getKoPart(), getPart(), parent ); |
1001 | |
1002 | connect( scheduleeditor, SIGNAL(addScheduleManager(Project*)), SLOT(slotAddScheduleManager(Project*)) ); |
1003 | connect( scheduleeditor, SIGNAL(deleteScheduleManager(Project*,ScheduleManager*)), SLOT(slotDeleteScheduleManager(Project*,ScheduleManager*)) ); |
1004 | |
1005 | connect( scheduleeditor, SIGNAL(calculateSchedule(Project*,ScheduleManager*)), SLOT(slotCalculateSchedule(Project*,ScheduleManager*)) ); |
1006 | |
1007 | connect( scheduleeditor, SIGNAL(baselineSchedule(Project*,ScheduleManager*)), SLOT(slotBaselineSchedule(Project*,ScheduleManager*)) ); |
1008 | |
1009 | scheduleeditor->updateReadWrite( m_readWrite ); |
1010 | return scheduleeditor; |
1011 | } |
1012 | |
1013 | ViewBase *View::createScheduleEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1014 | { |
1015 | ScheduleEditor *scheduleeditor = new ScheduleEditor(getKoPart(), getPart(), m_tab ); |
1016 | m_tab->addWidget( scheduleeditor ); |
1017 | |
1018 | ViewListItem *i = m_viewlist->addView( cat, tag, name, scheduleeditor, getPart(), "" , index ); |
1019 | ViewInfo vi = defaultViewInfo( "ScheduleEditor" ); |
1020 | if ( name.isEmpty() ) { |
1021 | i->setText( 0, vi.name ); |
1022 | } |
1023 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1024 | i->setToolTip( 0, vi.tip ); |
1025 | } else { |
1026 | i->setToolTip( 0, tip ); |
1027 | } |
1028 | |
1029 | scheduleeditor->setProject( &( getProject() ) ); |
1030 | |
1031 | connect( scheduleeditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1032 | |
1033 | connect( scheduleeditor, SIGNAL(addScheduleManager(Project*)), SLOT(slotAddScheduleManager(Project*)) ); |
1034 | |
1035 | connect( scheduleeditor, SIGNAL(deleteScheduleManager(Project*,ScheduleManager*)), SLOT(slotDeleteScheduleManager(Project*,ScheduleManager*)) ); |
1036 | |
1037 | connect( scheduleeditor, SIGNAL(calculateSchedule(Project*,ScheduleManager*)), SLOT(slotCalculateSchedule(Project*,ScheduleManager*)) ); |
1038 | |
1039 | connect( scheduleeditor, SIGNAL(baselineSchedule(Project*,ScheduleManager*)), SLOT(slotBaselineSchedule(Project*,ScheduleManager*)) ); |
1040 | |
1041 | scheduleeditor->updateReadWrite( m_readWrite ); |
1042 | return scheduleeditor; |
1043 | } |
1044 | |
1045 | |
1046 | ViewBase *View::createDependencyEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1047 | { |
1048 | DependencyEditor *editor = new DependencyEditor(getKoPart(), getPart(), m_tab ); |
1049 | m_tab->addWidget( editor ); |
1050 | |
1051 | ViewListItem *i = m_viewlist->addView( cat, tag, name, editor, getPart(), "" , index ); |
1052 | ViewInfo vi = defaultViewInfo( "DependencyEditor" ); |
1053 | if ( name.isEmpty() ) { |
1054 | i->setText( 0, vi.name ); |
1055 | } |
1056 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1057 | i->setToolTip( 0, vi.tip ); |
1058 | } else { |
1059 | i->setToolTip( 0, tip ); |
1060 | } |
1061 | |
1062 | editor->draw( getProject() ); |
1063 | |
1064 | connect( editor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1065 | |
1066 | connect( editor, SIGNAL(addRelation(Node*,Node*,int)), SLOT(slotAddRelation(Node*,Node*,int)) ); |
1067 | connect( editor, SIGNAL(modifyRelation(Relation*,int)), SLOT(slotModifyRelation(Relation*,int)) ); |
1068 | connect( editor, SIGNAL(modifyRelation(Relation*)), SLOT(slotModifyRelation(Relation*)) ); |
1069 | |
1070 | connect( editor, SIGNAL(editNode(Node*)), SLOT(slotOpenNode(Node*)) ); |
1071 | connect( editor, SIGNAL(addTask()), SLOT(slotAddTask()) ); |
1072 | connect( editor, SIGNAL(addMilestone()), SLOT(slotAddMilestone()) ); |
1073 | connect( editor, SIGNAL(addSubMilestone()), SLOT(slotAddSubMilestone()) ); |
1074 | connect( editor, SIGNAL(addSubtask()), SLOT(slotAddSubTask()) ); |
1075 | connect( editor, SIGNAL(deleteTaskList(QList<Node*>)), SLOT(slotDeleteTask(QList<Node*>)) ); |
1076 | |
1077 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), editor, SLOT(setScheduleManager(ScheduleManager*)) ); |
1078 | |
1079 | connect( editor, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1080 | editor->updateReadWrite( m_readWrite ); |
1081 | editor->setScheduleManager( currentScheduleManager() ); |
1082 | return editor; |
1083 | } |
1084 | |
1085 | ViewBase *View::createPertEditor( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1086 | { |
1087 | PertEditor *perteditor = new PertEditor(getKoPart(), getPart(), m_tab ); |
1088 | m_tab->addWidget( perteditor ); |
1089 | |
1090 | ViewListItem *i = m_viewlist->addView( cat, tag, name, perteditor, getPart(), "" , index ); |
1091 | ViewInfo vi = defaultViewInfo( "PertEditor" ); |
1092 | if ( name.isEmpty() ) { |
1093 | i->setText( 0, vi.name ); |
1094 | } |
1095 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1096 | i->setToolTip( 0, vi.tip ); |
1097 | } else { |
1098 | i->setToolTip( 0, tip ); |
1099 | } |
1100 | |
1101 | perteditor->draw( getProject() ); |
1102 | |
1103 | connect( perteditor, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1104 | m_updatePertEditor = true; |
1105 | perteditor->updateReadWrite( m_readWrite ); |
1106 | return perteditor; |
1107 | } |
1108 | |
1109 | ViewBase *View::createProjectStatusView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1110 | { |
1111 | ProjectStatusView *v = new ProjectStatusView(getKoPart(), getPart(), m_tab ); |
1112 | m_tab->addWidget( v ); |
1113 | |
1114 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
1115 | ViewInfo vi = defaultViewInfo( "ProjectStatusView" ); |
1116 | if ( name.isEmpty() ) { |
1117 | i->setText( 0, vi.name ); |
1118 | } |
1119 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1120 | i->setToolTip( 0, vi.tip ); |
1121 | } else { |
1122 | i->setToolTip( 0, tip ); |
1123 | } |
1124 | |
1125 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1126 | |
1127 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
1128 | |
1129 | v->updateReadWrite( m_readWrite ); |
1130 | v->setProject( &getProject() ); |
1131 | v->setScheduleManager( currentScheduleManager() ); |
1132 | return v; |
1133 | } |
1134 | |
1135 | ViewBase *View::createPerformanceStatusView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1136 | { |
1137 | PerformanceStatusView *v = new PerformanceStatusView(getKoPart(), getPart(), m_tab ); |
1138 | m_tab->addWidget( v ); |
1139 | |
1140 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
1141 | ViewInfo vi = defaultViewInfo( "PerformanceStatusView" ); |
1142 | if ( name.isEmpty() ) { |
1143 | i->setText( 0, vi.name ); |
1144 | } |
1145 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1146 | i->setToolTip( 0, vi.tip ); |
1147 | } else { |
1148 | i->setToolTip( 0, tip ); |
1149 | } |
1150 | |
1151 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1152 | |
1153 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
1154 | |
1155 | connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1156 | |
1157 | v->updateReadWrite( m_readWrite ); |
1158 | v->setProject( &getProject() ); |
1159 | v->setScheduleManager( currentScheduleManager() ); |
1160 | return v; |
1161 | } |
1162 | |
1163 | |
1164 | ViewBase *View::createTaskStatusView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1165 | { |
1166 | TaskStatusView *taskstatusview = new TaskStatusView(getKoPart(), getPart(), m_tab ); |
1167 | m_tab->addWidget( taskstatusview ); |
1168 | |
1169 | ViewListItem *i = m_viewlist->addView( cat, tag, name, taskstatusview, getPart(), "" , index ); |
1170 | ViewInfo vi = defaultViewInfo( "TaskStatusView" ); |
1171 | if ( name.isEmpty() ) { |
1172 | i->setText( 0, vi.name ); |
1173 | } |
1174 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1175 | i->setToolTip( 0, vi.tip ); |
1176 | } else { |
1177 | i->setToolTip( 0, tip ); |
1178 | } |
1179 | |
1180 | connect( taskstatusview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1181 | |
1182 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), taskstatusview, SLOT(setScheduleManager(ScheduleManager*)) ); |
1183 | |
1184 | connect( taskstatusview, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1185 | |
1186 | taskstatusview->updateReadWrite( m_readWrite ); |
1187 | taskstatusview->draw( getProject() ); |
1188 | taskstatusview->setScheduleManager( currentScheduleManager() ); |
1189 | return taskstatusview; |
1190 | } |
1191 | |
1192 | ViewBase *View::createTaskView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1193 | { |
1194 | TaskView *v = new TaskView(getKoPart(), getPart(), m_tab ); |
1195 | m_tab->addWidget( v ); |
1196 | |
1197 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
1198 | ViewInfo vi = defaultViewInfo( "TaskView" ); |
1199 | if ( name.isEmpty() ) { |
1200 | i->setText( 0, vi.name ); |
1201 | } |
1202 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1203 | i->setToolTip( 0, vi.tip ); |
1204 | } else { |
1205 | i->setToolTip( 0, tip ); |
1206 | } |
1207 | |
1208 | v->draw( getProject() ); |
1209 | v->setScheduleManager( currentScheduleManager() ); |
1210 | |
1211 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
1212 | |
1213 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1214 | |
1215 | connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1216 | v->updateReadWrite( m_readWrite ); |
1217 | return v; |
1218 | } |
1219 | |
1220 | ViewBase *View::createTaskWorkPackageView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1221 | { |
1222 | TaskWorkPackageView *v = new TaskWorkPackageView(getKoPart(), getPart(), m_tab ); |
1223 | m_tab->addWidget( v ); |
1224 | |
1225 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
1226 | ViewInfo vi = defaultViewInfo( "TaskWorkPackageView" ); |
1227 | if ( name.isEmpty() ) { |
1228 | i->setText( 0, vi.name ); |
1229 | } |
1230 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1231 | i->setToolTip( 0, vi.tip ); |
1232 | } else { |
1233 | i->setToolTip( 0, tip ); |
1234 | } |
1235 | |
1236 | v->setProject( &getProject() ); |
1237 | v->setScheduleManager( currentScheduleManager() ); |
1238 | |
1239 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
1240 | |
1241 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1242 | |
1243 | connect( v, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1244 | |
1245 | connect( v, SIGNAL(mailWorkpackage(Node*,Resource*)), SLOT(slotMailWorkpackage(Node*,Resource*)) ); |
1246 | connect( v, SIGNAL(mailWorkpackages(QList<Node*>,Resource*)), SLOT(slotMailWorkpackages(QList<Node*>,Resource*)) ); |
1247 | |
1248 | connect(v, SIGNAL(checkForWorkPackages()), getPart(), SLOT(checkForWorkPackages())); |
1249 | v->updateReadWrite( m_readWrite ); |
1250 | return v; |
1251 | } |
1252 | |
1253 | ViewBase *View::createGanttView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1254 | { |
1255 | GanttView *ganttview = new GanttView(getKoPart(), getPart(), m_tab, koDocument()->isReadWrite() ); |
1256 | m_tab->addWidget( ganttview ); |
1257 | |
1258 | ViewListItem *i = m_viewlist->addView( cat, tag, name, ganttview, getPart(), "" , index ); |
1259 | ViewInfo vi = defaultViewInfo( "GanttView" ); |
1260 | if ( name.isEmpty() ) { |
1261 | i->setText( 0, vi.name ); |
1262 | } |
1263 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1264 | i->setToolTip( 0, vi.tip ); |
1265 | } else { |
1266 | i->setToolTip( 0, tip ); |
1267 | } |
1268 | |
1269 | ganttview->setProject( &( getProject() ) ); |
1270 | ganttview->setScheduleManager( currentScheduleManager() ); |
1271 | |
1272 | connect( ganttview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1273 | /* TODO: Review these |
1274 | connect( ganttview, SIGNAL(addRelation(Node*,Node*,int)), SLOT(slotAddRelation(Node*,Node*,int)) ); |
1275 | connect( ganttview, SIGNAL(modifyRelation(Relation*,int)), SLOT(slotModifyRelation(Relation*,int)) ); |
1276 | connect( ganttview, SIGNAL(modifyRelation(Relation*)), SLOT(slotModifyRelation(Relation*)) ); |
1277 | connect( ganttview, SIGNAL(itemDoubleClicked()), SLOT(slotOpenNode()) ); |
1278 | connect( ganttview, SIGNAL(itemRenamed(Node*,QString)), this, SLOT(slotRenameNode(Node*,QString)) );*/ |
1279 | |
1280 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), ganttview, SLOT(setScheduleManager(ScheduleManager*)) ); |
1281 | |
1282 | connect( ganttview, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1283 | ganttview->updateReadWrite( m_readWrite ); |
1284 | return ganttview; |
1285 | } |
1286 | |
1287 | ViewBase *View::createMilestoneGanttView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1288 | { |
1289 | MilestoneGanttView *ganttview = new MilestoneGanttView(getKoPart(), getPart(), m_tab, koDocument()->isReadWrite() ); |
1290 | m_tab->addWidget( ganttview ); |
1291 | |
1292 | ViewListItem *i = m_viewlist->addView( cat, tag, name, ganttview, getPart(), "" , index ); |
1293 | ViewInfo vi = defaultViewInfo( "MilestoneGanttView" ); |
1294 | if ( name.isEmpty() ) { |
1295 | i->setText( 0, vi.name ); |
1296 | } |
1297 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1298 | i->setToolTip( 0, vi.tip ); |
1299 | } else { |
1300 | i->setToolTip( 0, tip ); |
1301 | } |
1302 | |
1303 | ganttview->setProject( &( getProject() ) ); |
1304 | ganttview->setScheduleManager( currentScheduleManager() ); |
1305 | |
1306 | connect( ganttview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1307 | |
1308 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), ganttview, SLOT(setScheduleManager(ScheduleManager*)) ); |
1309 | |
1310 | connect( ganttview, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1311 | ganttview->updateReadWrite( m_readWrite ); |
1312 | return ganttview; |
1313 | } |
1314 | |
1315 | |
1316 | ViewBase *View::createAccountsView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1317 | { |
1318 | AccountsView *accountsview = new AccountsView(getKoPart(), &getProject(), getPart(), m_tab ); |
1319 | m_tab->addWidget( accountsview ); |
1320 | |
1321 | ViewListItem *i = m_viewlist->addView( cat, tag, name, accountsview, getPart(), "" , index ); |
1322 | ViewInfo vi = defaultViewInfo( "AccountsView" ); |
1323 | if ( name.isEmpty() ) { |
1324 | i->setText( 0, vi.name ); |
1325 | } |
1326 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1327 | i->setToolTip( 0, vi.tip ); |
1328 | } else { |
1329 | i->setToolTip( 0, tip ); |
1330 | } |
1331 | |
1332 | accountsview->setScheduleManager( currentScheduleManager() ); |
1333 | |
1334 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), accountsview, SLOT(setScheduleManager(ScheduleManager*)) ); |
1335 | |
1336 | connect( accountsview, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1337 | accountsview->updateReadWrite( m_readWrite ); |
1338 | return accountsview; |
1339 | } |
1340 | |
1341 | ViewBase *View::createResourceAssignmentView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1342 | { |
1343 | ResourceAssignmentView *resourceAssignmentView = new ResourceAssignmentView(getKoPart(), getPart(), m_tab ); |
1344 | m_tab->addWidget( resourceAssignmentView ); |
1345 | m_updateResourceAssignmentView = true; |
1346 | |
1347 | ViewListItem *i = m_viewlist->addView( cat, tag, name, resourceAssignmentView, getPart(), "" , index ); |
1348 | ViewInfo vi = defaultViewInfo( "ResourceAssignmentView" ); |
1349 | if ( name.isEmpty() ) { |
1350 | i->setText( 0, vi.name ); |
1351 | } |
1352 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1353 | i->setToolTip( 0, vi.tip ); |
1354 | } else { |
1355 | i->setToolTip( 0, tip ); |
1356 | } |
1357 | |
1358 | resourceAssignmentView->draw( getProject() ); |
1359 | |
1360 | connect( resourceAssignmentView, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1361 | |
1362 | connect( resourceAssignmentView, SIGNAL(requestPopupMenu(QString,QPoint)), this, SLOT(slotPopupMenu(QString,QPoint)) ); |
1363 | resourceAssignmentView->updateReadWrite( m_readWrite ); |
1364 | return resourceAssignmentView; |
1365 | } |
1366 | |
1367 | ViewBase *View::createReportView( ViewListItem *cat, const QString &tag, const QString &name, const QString &tip, int index ) |
1368 | { |
1369 | ReportView *v = new ReportView(getKoPart(), getPart(), m_tab ); |
1370 | m_tab->addWidget( v ); |
1371 | |
1372 | ViewListItem *i = m_viewlist->addView( cat, tag, name, v, getPart(), "" , index ); |
1373 | ViewInfo vi = defaultViewInfo( "ReportView" ); |
1374 | if ( name.isEmpty() ) { |
1375 | i->setText( 0, vi.name ); |
1376 | } |
1377 | if ( tip == TIP_USE_DEFAULT_TEXT ) { |
1378 | i->setToolTip( 0, vi.tip ); |
1379 | } else { |
1380 | i->setToolTip( 0, tip ); |
1381 | } |
1382 | |
1383 | v->setProject( &getProject() ); |
1384 | |
1385 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(setScheduleManager(ScheduleManager*)) ); |
1386 | connect( this, SIGNAL(currentScheduleManagerChanged(ScheduleManager*)), v, SLOT(slotRefreshView())); |
1387 | v->setScheduleManager( currentScheduleManager() ); |
1388 | |
1389 | connect( v, SIGNAL(guiActivated(ViewBase*,bool)), SLOT(slotGuiActivated(ViewBase*,bool)) ); |
1390 | v->updateReadWrite( m_readWrite ); |
1391 | return v; |
1392 | } |
1393 | |
1394 | Project& View::getProject() const |
1395 | { |
1396 | return getPart() ->getProject(); |
1397 | } |
1398 | |
1399 | KoPrintJob * View::createPrintJob() |
1400 | { |
1401 | KoView *v = qobject_cast<KoView*>( canvas() ); |
1402 | if ( v == 0 ) { |
1403 | return 0; |
1404 | } |
1405 | return v->createPrintJob(); |
1406 | } |
1407 | |
1408 | ViewBase *View::currentView() const |
1409 | { |
1410 | return qobject_cast<ViewBase*>( m_tab->currentWidget() ); |
1411 | } |
1412 | |
1413 | void View::slotEditCut() |
1414 | { |
1415 | ViewBase *v = currentView(); |
1416 | if ( v ) { |
1417 | v->slotEditCut(); |
1418 | } |
1419 | } |
1420 | |
1421 | void View::slotEditCopy() |
1422 | { |
1423 | ViewBase *v = currentView(); |
1424 | if ( v ) { |
1425 | v->slotEditCopy(); |
1426 | } |
1427 | } |
1428 | |
1429 | void View::slotEditPaste() |
1430 | { |
1431 | ViewBase *v = currentView(); |
1432 | if ( v ) { |
1433 | v->slotEditPaste(); |
1434 | } |
1435 | } |
1436 | |
1437 | void View::slotRefreshView() |
1438 | { |
1439 | ViewBase *v = currentView(); |
1440 | if ( v ) { |
1441 | v->slotRefreshView(); |
1442 | } |
1443 | } |
1444 | |
1445 | void View::slotViewSelector( bool show ) |
1446 | { |
1447 | //kDebug(planDbg()); |
1448 | m_viewlist->setVisible( show ); |
1449 | } |
1450 | |
1451 | void View::slotInsertFile() |
1452 | { |
1453 | InsertFileDialog *dlg = new InsertFileDialog( getProject(), currentTask(), this ); |
1454 | connect(dlg, SIGNAL(finished(int)), SLOT(slotInsertFileFinished(int))); |
1455 | dlg->show(); |
1456 | dlg->raise(); |
1457 | dlg->activateWindow(); |
1458 | } |
1459 | |
1460 | void View::slotInsertFileFinished( int result ) |
1461 | { |
1462 | InsertFileDialog *dlg = qobject_cast<InsertFileDialog*>( sender() ); |
1463 | if ( dlg == 0 ) { |
1464 | return; |
1465 | } |
1466 | if ( result == QDialog::Accepted ) { |
1467 | getPart()->insertFile( dlg->url().url(), dlg->parentNode(), dlg->afterNode() ); |
1468 | } |
1469 | dlg->deleteLater(); |
1470 | } |
1471 | |
1472 | void View::slotProjectEdit() |
1473 | { |
1474 | slotOpenNode( &getProject() ); |
1475 | } |
1476 | |
1477 | void View::slotProjectWorktime() |
1478 | { |
1479 | StandardWorktimeDialog *dia = new StandardWorktimeDialog( getProject(), this ); |
1480 | connect(dia, SIGNAL(finished(int)), this, SLOT(slotProjectWorktimeFinished(int))); |
1481 | dia->show(); |
1482 | dia->raise(); |
1483 | dia->activateWindow(); |
1484 | } |
1485 | |
1486 | void View::slotProjectWorktimeFinished( int result ) |
1487 | { |
1488 | StandardWorktimeDialog *dia = qobject_cast<StandardWorktimeDialog*>( sender() ); |
1489 | if ( dia == 0 ) { |
1490 | return; |
1491 | } |
1492 | if ( result == QDialog::Accepted) { |
1493 | KUndo2Command * cmd = dia->buildCommand(); |
1494 | if ( cmd ) { |
1495 | //kDebug(planDbg())<<"Modifying calendar(s)"; |
1496 | getPart() ->addCommand( cmd ); //also executes |
1497 | } |
1498 | } |
1499 | dia->deleteLater(); |
1500 | } |
1501 | |
1502 | void View::slotSelectionChanged( ScheduleManager *sm ) { |
1503 | kDebug(planDbg())<<sm; |
1504 | if ( sm == 0 ) { |
1505 | return; |
1506 | } |
1507 | int idx = m_scheduleActions.values().indexOf( sm->expected() ); |
1508 | if ( idx < 0 ) { |
1509 | kDebug(planDbg())<<sm<<"could not find schedule" <<sm->expected(); |
1510 | return; |
1511 | } |
1512 | QAction *a = m_scheduleActions.keys().at( idx ); |
1513 | Q_ASSERT( a ); |
1514 | a->setChecked( true ); // this doesn't trigger QActionGroup |
1515 | slotViewSchedule( a ); |
1516 | } |
1517 | |
1518 | QList<QAction*> View::sortedActionList() |
1519 | { |
1520 | QMap<QString, QAction*> lst; |
1521 | foreach ( QAction *a, m_scheduleActions.keys() ) { |
1522 | lst.insert( a->objectName(), a ); |
1523 | } |
1524 | return lst.values(); |
1525 | } |
1526 | |
1527 | void View::slotScheduleRemoved( const MainSchedule *sch ) |
1528 | { |
1529 | kDebug(planDbg())<<sch<<sch->name(); |
1530 | QAction *a = 0; |
1531 | QAction *checked = m_scheduleActionGroup->checkedAction(); |
1532 | QMapIterator<QAction*, Schedule*> i( m_scheduleActions ); |
1533 | while (i.hasNext()) { |
1534 | i.next(); |
1535 | if ( i.value() == sch ) { |
1536 | a = i.key(); |
1537 | break; |
1538 | } |
1539 | } |
1540 | if ( a ) { |
1541 | unplugActionList( "view_schedule_list" ); |
1542 | delete a; |
1543 | plugActionList( "view_schedule_list" , sortedActionList() ); |
1544 | if ( checked && checked != a ) { |
1545 | checked->setChecked( true ); |
1546 | } else if ( ! m_scheduleActions.isEmpty() ) { |
1547 | m_scheduleActions.keys().first()->setChecked( true ); |
1548 | } |
1549 | } |
1550 | slotViewSchedule( m_scheduleActionGroup->checkedAction() ); |
1551 | } |
1552 | |
1553 | void View::slotScheduleAdded( const MainSchedule *sch ) |
1554 | { |
1555 | if ( sch->type() != Schedule::Expected ) { |
1556 | return; // Only view expected |
1557 | } |
1558 | MainSchedule *s = const_cast<MainSchedule*>( sch ); |
1559 | // kDebug(planDbg())<<sch->name()<<" deleted="<<sch->isDeleted()<<"scheduled="<<sch->isScheduled(); |
1560 | QAction *checked = m_scheduleActionGroup->checkedAction(); |
1561 | if ( ! sch->isDeleted() && sch->isScheduled() ) { |
1562 | unplugActionList( "view_schedule_list" ); |
1563 | QAction *act = addScheduleAction( s ); |
1564 | plugActionList( "view_schedule_list" , sortedActionList() ); |
1565 | if ( checked ) { |
1566 | checked->setChecked( true ); |
1567 | } else if ( act ) { |
1568 | act->setChecked( true ); |
1569 | } else if ( ! m_scheduleActions.isEmpty() ) { |
1570 | m_scheduleActions.keys().first()->setChecked( true ); |
1571 | } |
1572 | } |
1573 | slotViewSchedule( m_scheduleActionGroup->checkedAction() ); |
1574 | } |
1575 | |
1576 | void View::slotScheduleChanged( MainSchedule *sch ) |
1577 | { |
1578 | // kDebug(planDbg())<<sch->name()<<" deleted="<<sch->isDeleted()<<"scheduled="<<sch->isScheduled(); |
1579 | if ( sch->isDeleted() || ! sch->isScheduled() ) { |
1580 | slotScheduleRemoved( sch ); |
1581 | return; |
1582 | } |
1583 | if ( m_scheduleActions.values().contains( sch ) ) { |
1584 | slotScheduleRemoved( sch ); // hmmm, how to avoid this? |
1585 | } |
1586 | slotScheduleAdded( sch ); |
1587 | } |
1588 | |
1589 | QAction *View::addScheduleAction( Schedule *sch ) |
1590 | { |
1591 | QAction *act = 0; |
1592 | if ( ! sch->isDeleted() && sch->isScheduled() ) { |
1593 | QString n = sch->name(); |
1594 | act = new KToggleAction( n, this); |
1595 | actionCollection()->addAction(n, act ); |
1596 | m_scheduleActions.insert( act, sch ); |
1597 | m_scheduleActionGroup->addAction( act ); |
1598 | //kDebug(planDbg())<<"Add:"<<n; |
1599 | connect( act, SIGNAL(destroyed(QObject*)), SLOT(slotActionDestroyed(QObject*)) ); |
1600 | } |
1601 | return act; |
1602 | } |
1603 | |
1604 | void View::slotViewScheduleManager() |
1605 | { |
1606 | QApplication::setOverrideCursor( Qt::WaitCursor ); |
1607 | setLabel( m_nextScheduleManager ); |
1608 | emit currentScheduleManagerChanged( m_nextScheduleManager ); |
1609 | m_nextScheduleManager = 0; |
1610 | m_trigged = false; |
1611 | QApplication::restoreOverrideCursor(); |
1612 | } |
1613 | |
1614 | void View::slotViewSchedule( QAction *act ) |
1615 | { |
1616 | //kDebug(planDbg())<<act; |
1617 | ScheduleManager *sm = 0; |
1618 | if ( act != 0 ) { |
1619 | Schedule *sch = m_scheduleActions.value( act, 0 ); |
1620 | sm = sch->manager(); |
1621 | } |
1622 | emit currentScheduleManagerChanged( 0 ); |
1623 | setLabel( 0 ); |
1624 | m_nextScheduleManager = sm; |
1625 | // Performance is very dependent on schedule manager change since a lot is recalculated |
1626 | // In case of multiple changes, only issue the last change |
1627 | if ( ! m_trigged ) { |
1628 | m_trigged = true; |
1629 | emit currentScheduleManagerChanged( 0 ); |
1630 | QTimer::singleShot( 0, this, SLOT(slotViewScheduleManager()) ); |
1631 | } |
1632 | } |
1633 | |
1634 | void View::slotActionDestroyed( QObject *o ) |
1635 | { |
1636 | //kDebug(planDbg())<<o->name(); |
1637 | m_scheduleActions.remove( static_cast<QAction*>( o ) ); |
1638 | // slotViewSchedule( m_scheduleActionGroup->checkedAction() ); |
1639 | } |
1640 | |
1641 | void View::slotPlugScheduleActions() |
1642 | { |
1643 | //kDebug(planDbg())<<activeScheduleId(); |
1644 | long id = activeScheduleId(); |
1645 | unplugActionList( "view_schedule_list" ); |
1646 | foreach( QAction *act, m_scheduleActions.keys() ) { |
1647 | m_scheduleActionGroup->removeAction( act ); |
1648 | delete act; |
1649 | } |
1650 | m_scheduleActions.clear(); |
1651 | QAction *ca = 0; |
1652 | foreach( ScheduleManager *sm, getProject().allScheduleManagers() ) { |
1653 | Schedule *sch = sm->expected(); |
1654 | if ( sch == 0 ) { |
1655 | continue; |
1656 | } |
1657 | QAction *act = addScheduleAction( sch ); |
1658 | if ( act && id == sch->id() ) { |
1659 | ca = act; |
1660 | } |
1661 | } |
1662 | plugActionList( "view_schedule_list" , sortedActionList() ); |
1663 | if ( ca == 0 && m_scheduleActionGroup->actions().count() > 0 ) { |
1664 | ca = m_scheduleActionGroup->actions().first(); |
1665 | } |
1666 | if ( ca ) { |
1667 | ca->setChecked( true ); |
1668 | } |
1669 | slotViewSchedule( ca ); |
1670 | } |
1671 | |
1672 | void View::slotProjectCalculated( ScheduleManager *sm ) |
1673 | { |
1674 | // we only get here if current schedule was calculated |
1675 | if ( sm->isScheduled() ) { |
1676 | slotSelectionChanged( sm ); |
1677 | } |
1678 | } |
1679 | |
1680 | void View::slotCalculateSchedule( Project *project, ScheduleManager *sm ) |
1681 | { |
1682 | if ( project == 0 || sm == 0 ) { |
1683 | return; |
1684 | } |
1685 | if ( sm->parentManager() && ! sm->parentManager()->isScheduled() ) { |
1686 | // the parent must be scheduled |
1687 | return; |
1688 | } |
1689 | if ( sm == currentScheduleManager() ) { |
1690 | connect( project, SIGNAL(projectCalculated(ScheduleManager*)), this, SLOT(slotProjectCalculated(ScheduleManager*)) ); |
1691 | } |
1692 | CalculateScheduleCmd *cmd = new CalculateScheduleCmd( *project, sm, kundo2_i18nc("@info:status 1=schedule name" , "Calculate %1" , sm->name() ) ); |
1693 | getPart() ->addCommand( cmd ); |
1694 | slotUpdate(); |
1695 | } |
1696 | |
1697 | void View::slotRemoveCommands() |
1698 | { |
1699 | while ( ! m_undocommands.isEmpty() ) { |
1700 | m_undocommands.last()->undo(); |
1701 | delete m_undocommands.takeLast(); |
1702 | } |
1703 | } |
1704 | |
1705 | void View::slotBaselineSchedule( Project *project, ScheduleManager *sm ) |
1706 | { |
1707 | if ( project == 0 || sm == 0 ) { |
1708 | return; |
1709 | } |
1710 | if ( ! sm->isBaselined() && project->isBaselined() ) { |
1711 | KMessageBox::sorry( this, i18n( "Cannot baseline. The project is already baselined." ) ); |
1712 | return; |
1713 | } |
1714 | KUndo2Command *cmd; |
1715 | if ( sm->isBaselined() ) { |
1716 | int res = KMessageBox::warningContinueCancel( this, i18n( "This schedule is baselined. Do you want to remove the baseline?" ) ); |
1717 | if ( res == KMessageBox::Cancel ) { |
1718 | return; |
1719 | } |
1720 | cmd = new ResetBaselineScheduleCmd( *sm, kundo2_i18n( "Reset baseline %1" , sm->name() ) ); |
1721 | } else { |
1722 | cmd = new BaselineScheduleCmd( *sm, kundo2_i18n( "Baseline %1" , sm->name() ) ); |
1723 | } |
1724 | getPart() ->addCommand( cmd ); |
1725 | } |
1726 | |
1727 | void View::slotAddScheduleManager( Project *project ) |
1728 | { |
1729 | if ( project == 0 ) { |
1730 | return; |
1731 | } |
1732 | ScheduleManager *sm = project->createScheduleManager(); |
1733 | AddScheduleManagerCmd *cmd = new AddScheduleManagerCmd( *project, sm, -1, kundo2_i18n( "Add schedule %1" , sm->name() ) ); |
1734 | getPart() ->addCommand( cmd ); |
1735 | } |
1736 | |
1737 | void View::slotDeleteScheduleManager( Project *project, ScheduleManager *sm ) |
1738 | { |
1739 | if ( project == 0 || sm == 0) { |
1740 | return; |
1741 | } |
1742 | DeleteScheduleManagerCmd *cmd = new DeleteScheduleManagerCmd( *project, sm, kundo2_i18n( "Delete schedule %1" , sm->name() ) ); |
1743 | getPart() ->addCommand( cmd ); |
1744 | } |
1745 | |
1746 | void View::slotMoveScheduleManager( ScheduleManager *sm, ScheduleManager *parent, int index ) |
1747 | { |
1748 | if ( sm == 0 ) { |
1749 | return; |
1750 | } |
1751 | MoveScheduleManagerCmd *cmd = new MoveScheduleManagerCmd( sm, parent, index, kundo2_i18n( "Move schedule %1" , sm->name() ) ); |
1752 | getPart() ->addCommand( cmd ); |
1753 | } |
1754 | |
1755 | void View::slotAddSubTask() |
1756 | { |
1757 | Task * node = getProject().createTask( getPart() ->config().taskDefaults() ); |
1758 | SubTaskAddDialog *dia = new SubTaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this ); |
1759 | connect(dia, SIGNAL(finished(int)), SLOT(slotAddSubTaskFinished(int))); |
1760 | dia->show(); |
1761 | dia->raise(); |
1762 | dia->activateWindow(); |
1763 | } |
1764 | |
1765 | void View::slotAddSubTaskFinished( int result ) |
1766 | { |
1767 | SubTaskAddDialog *dia = qobject_cast<SubTaskAddDialog*>( sender() ); |
1768 | if ( dia == 0 ) { |
1769 | return; |
1770 | } |
1771 | if ( result == QDialog::Accepted) { |
1772 | KUndo2Command *m = dia->buildCommand(); |
1773 | getPart() ->addCommand( m ); // add task to project |
1774 | } |
1775 | dia->deleteLater(); |
1776 | } |
1777 | |
1778 | void View::slotAddTask() |
1779 | { |
1780 | Task * node = getProject().createTask( getPart() ->config().taskDefaults() ); |
1781 | TaskAddDialog *dia = new TaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this ); |
1782 | connect(dia, SIGNAL(finished(int)), SLOT(slotAddTaskFinished(int))); |
1783 | dia->show(); |
1784 | dia->raise(); |
1785 | dia->activateWindow(); |
1786 | } |
1787 | |
1788 | void View::slotAddTaskFinished( int result ) |
1789 | { |
1790 | TaskAddDialog *dia = qobject_cast<TaskAddDialog*>( sender() ); |
1791 | if ( dia == 0 ) { |
1792 | return; |
1793 | } |
1794 | if ( result == QDialog::Accepted) { |
1795 | KUndo2Command *m = dia->buildCommand(); |
1796 | getPart() ->addCommand( m ); // add task to project |
1797 | } |
1798 | dia->deleteLater(); |
1799 | } |
1800 | |
1801 | void View::slotAddMilestone() |
1802 | { |
1803 | Task * node = getProject().createTask(); |
1804 | node->estimate() ->clear(); |
1805 | |
1806 | TaskAddDialog *dia = new TaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this ); |
1807 | connect(dia, SIGNAL(finished(int)), SLOT(slotAddMilestoneFinished(int))); |
1808 | dia->show(); |
1809 | dia->raise(); |
1810 | dia->activateWindow(); |
1811 | } |
1812 | |
1813 | void View::slotAddMilestoneFinished( int result ) |
1814 | { |
1815 | TaskAddDialog *dia = qobject_cast<TaskAddDialog*>( sender() ); |
1816 | if ( dia == 0 ) { |
1817 | return; |
1818 | } |
1819 | if ( result == QDialog::Accepted) { |
1820 | MacroCommand *c = new MacroCommand( kundo2_i18n( "Add milestone" ) ); |
1821 | c->addCommand( dia->buildCommand() ); |
1822 | getPart() ->addCommand( c ); // add task to project |
1823 | } |
1824 | dia->deleteLater(); |
1825 | } |
1826 | |
1827 | void View::slotAddSubMilestone() |
1828 | { |
1829 | Task * node = getProject().createTask(); |
1830 | node->estimate() ->clear(); |
1831 | |
1832 | SubTaskAddDialog *dia = new SubTaskAddDialog( getProject(), *node, currentNode(), getProject().accounts(), this ); |
1833 | connect(dia, SIGNAL(finished(int)), SLOT(slotAddSubMilestoneFinished(int))); |
1834 | dia->show(); |
1835 | dia->raise(); |
1836 | dia->activateWindow(); |
1837 | } |
1838 | |
1839 | void View::slotAddSubMilestoneFinished( int result ) |
1840 | { |
1841 | SubTaskAddDialog *dia = qobject_cast<SubTaskAddDialog*>( sender() ); |
1842 | if ( dia == 0 ) { |
1843 | return; |
1844 | } |
1845 | if ( result == QDialog::Accepted) { |
1846 | MacroCommand *c = new MacroCommand( kundo2_i18n( "Add sub-milestone" ) ); |
1847 | c->addCommand( dia->buildCommand() ); |
1848 | getPart() ->addCommand( c ); // add task to project |
1849 | } |
1850 | dia->deleteLater(); |
1851 | } |
1852 | |
1853 | void View::slotDefineWBS() |
1854 | { |
1855 | //kDebug(planDbg()); |
1856 | Project &p = getProject(); |
1857 | WBSDefinitionDialog *dia = new WBSDefinitionDialog( p, p.wbsDefinition(), this ); |
1858 | connect(dia, SIGNAL(finished(int)), SLOT(slotDefineWBSFinished(int))); |
1859 | dia->show(); |
1860 | dia->raise(); |
1861 | dia->activateWindow(); |
1862 | } |
1863 | |
1864 | void View::slotDefineWBSFinished( int result ) |
1865 | { |
1866 | //kDebug(planDbg()); |
1867 | WBSDefinitionDialog *dia = qobject_cast<WBSDefinitionDialog*>( sender() ); |
1868 | if ( dia == 0 ) { |
1869 | return; |
1870 | } |
1871 | if ( result == QDialog::Accepted ) { |
1872 | KUndo2Command *cmd = dia->buildCommand(); |
1873 | if ( cmd ) { |
1874 | getPart()->addCommand( cmd ); |
1875 | } |
1876 | } |
1877 | dia->deleteLater(); |
1878 | } |
1879 | |
1880 | void View::slotConfigure() |
1881 | { |
1882 | //kDebug(planDbg()); |
1883 | if( KConfigDialog::showDialog("Plan Settings" ) ) { |
1884 | return; |
1885 | } |
1886 | ConfigDialog *dialog = new ConfigDialog( this, "Plan Settings" , KPlatoSettings::self() ); |
1887 | dialog->addPage(new TaskDefaultPanel(), i18n("Task Defaults" ), koIconName("view-task" ) ); |
1888 | dialog->addPage(new ColorsConfigPanel(), i18n("Task Colors" ), koIconName("fill-color" ) ); |
1889 | dialog->addPage(new WorkPackageConfigPanel(), i18n("Work Package" ), koIconName("calligraplanwork" ) ); |
1890 | dialog->show(); |
1891 | |
1892 | } |
1893 | |
1894 | void View::slotIntroduction() |
1895 | { |
1896 | m_tab->setCurrentIndex( 0 ); |
1897 | } |
1898 | |
1899 | |
1900 | Calendar *View::currentCalendar() |
1901 | { |
1902 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
1903 | if ( v == 0 ) { |
1904 | return 0; |
1905 | } |
1906 | return v->currentCalendar(); |
1907 | } |
1908 | |
1909 | Node *View::currentNode() const |
1910 | { |
1911 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
1912 | if ( v == 0 ) { |
1913 | return 0; |
1914 | } |
1915 | Node * task = v->currentNode(); |
1916 | if ( 0 != task ) { |
1917 | return task; |
1918 | } |
1919 | return &( getProject() ); |
1920 | } |
1921 | |
1922 | Task *View::currentTask() const |
1923 | { |
1924 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
1925 | if ( v == 0 ) { |
1926 | return 0; |
1927 | } |
1928 | Node * task = v->currentNode(); |
1929 | if ( task ) { |
1930 | return dynamic_cast<Task*>( task ); |
1931 | } |
1932 | return 0; |
1933 | } |
1934 | |
1935 | Resource *View::currentResource() |
1936 | { |
1937 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
1938 | if ( v == 0 ) { |
1939 | return 0; |
1940 | } |
1941 | return v->currentResource(); |
1942 | } |
1943 | |
1944 | ResourceGroup *View::currentResourceGroup() |
1945 | { |
1946 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
1947 | if ( v == 0 ) { |
1948 | return 0; |
1949 | } |
1950 | return v->currentResourceGroup(); |
1951 | } |
1952 | |
1953 | |
1954 | void View::slotOpenNode() |
1955 | { |
1956 | //kDebug(planDbg()); |
1957 | Node * node = currentNode(); |
1958 | slotOpenNode( node ); |
1959 | } |
1960 | |
1961 | void View::slotOpenNode( Node *node ) |
1962 | { |
1963 | //kDebug(planDbg()); |
1964 | if ( !node ) |
1965 | return ; |
1966 | |
1967 | switch ( node->type() ) { |
1968 | case Node::Type_Project: { |
1969 | Project * project = static_cast<Project *>( node ); |
1970 | MainProjectDialog *dia = new MainProjectDialog( *project, this ); |
1971 | connect(dia, SIGNAL(finished(int)), SLOT(slotProjectEditFinished(int))); |
1972 | dia->show(); |
1973 | dia->raise(); |
1974 | dia->activateWindow(); |
1975 | break; |
1976 | } |
1977 | case Node::Type_Subproject: |
1978 | //TODO |
1979 | break; |
1980 | case Node::Type_Task: { |
1981 | Task *task = static_cast<Task *>( node ); |
1982 | TaskDialog *dia = new TaskDialog( getProject(), *task, getProject().accounts(), this ); |
1983 | connect(dia, SIGNAL(finished(int)), SLOT(slotTaskEditFinished(int))); |
1984 | dia->show(); |
1985 | dia->raise(); |
1986 | dia->activateWindow(); |
1987 | break; |
1988 | } |
1989 | case Node::Type_Milestone: { |
1990 | // Use the normal task dialog for now. |
1991 | // Maybe milestone should have it's own dialog, but we need to be able to |
1992 | // enter a duration in case we accidentally set a tasks duration to zero |
1993 | // and hence, create a milestone |
1994 | Task *task = static_cast<Task *>( node ); |
1995 | TaskDialog *dia = new TaskDialog( getProject(), *task, getProject().accounts(), this ); |
1996 | connect(dia, SIGNAL(finished(int)), SLOT(slotTaskEditFinished(int))); |
1997 | dia->show(); |
1998 | dia->raise(); |
1999 | dia->activateWindow(); |
2000 | break; |
2001 | } |
2002 | case Node::Type_Summarytask: { |
2003 | Task *task = dynamic_cast<Task *>( node ); |
2004 | Q_ASSERT( task ); |
2005 | SummaryTaskDialog *dia = new SummaryTaskDialog( *task, this ); |
2006 | connect(dia, SIGNAL(finished(int)), SLOT(slotSummaryTaskEditFinished(int))); |
2007 | dia->show(); |
2008 | dia->raise(); |
2009 | dia->activateWindow(); |
2010 | break; |
2011 | } |
2012 | default: |
2013 | break; // avoid warnings |
2014 | } |
2015 | } |
2016 | |
2017 | void View::slotProjectEditFinished( int result ) |
2018 | { |
2019 | MainProjectDialog *dia = qobject_cast<MainProjectDialog*>( sender() ); |
2020 | if ( dia == 0 ) { |
2021 | return; |
2022 | } |
2023 | if ( result == QDialog::Accepted) { |
2024 | KUndo2Command * cmd = dia->buildCommand(); |
2025 | if ( cmd ) { |
2026 | getPart() ->addCommand( cmd ); |
2027 | } |
2028 | } |
2029 | dia->deleteLater(); |
2030 | } |
2031 | |
2032 | void View::slotTaskEditFinished( int result ) |
2033 | { |
2034 | TaskDialog *dia = qobject_cast<TaskDialog*>( sender() ); |
2035 | if ( dia == 0 ) { |
2036 | return; |
2037 | } |
2038 | if ( result == QDialog::Accepted) { |
2039 | KUndo2Command * cmd = dia->buildCommand(); |
2040 | if ( cmd ) { |
2041 | getPart() ->addCommand( cmd ); |
2042 | } |
2043 | } |
2044 | dia->deleteLater(); |
2045 | } |
2046 | |
2047 | void View::slotSummaryTaskEditFinished( int result ) |
2048 | { |
2049 | SummaryTaskDialog *dia = qobject_cast<SummaryTaskDialog*>( sender() ); |
2050 | if ( dia == 0 ) { |
2051 | return; |
2052 | } |
2053 | if ( result == QDialog::Accepted) { |
2054 | KUndo2Command * cmd = dia->buildCommand(); |
2055 | if ( cmd ) { |
2056 | getPart() ->addCommand( cmd ); |
2057 | } |
2058 | } |
2059 | dia->deleteLater(); |
2060 | } |
2061 | |
2062 | ScheduleManager *View::currentScheduleManager() const |
2063 | { |
2064 | Schedule *s = m_scheduleActions.value( m_scheduleActionGroup->checkedAction() ); |
2065 | return s == 0 ? 0 : s->manager(); |
2066 | } |
2067 | |
2068 | long View::activeScheduleId() const |
2069 | { |
2070 | Schedule *s = m_scheduleActions.value( m_scheduleActionGroup->checkedAction() ); |
2071 | return s == 0 ? -1 : s->id(); |
2072 | } |
2073 | |
2074 | void View::setActiveSchedule( long id ) |
2075 | { |
2076 | if ( id != -1 ) { |
2077 | QMap<QAction*, Schedule*>::const_iterator it = m_scheduleActions.constBegin(); |
2078 | for (; it != m_scheduleActions.constEnd(); ++it ) { |
2079 | if ( it.value()->id() == id ) { |
2080 | it.key()->setChecked( true ); |
2081 | slotViewSchedule( it.key() ); // signal not emitted from group, so trigger it here |
2082 | break; |
2083 | } |
2084 | } |
2085 | } |
2086 | } |
2087 | |
2088 | void View::slotTaskProgress() |
2089 | { |
2090 | //kDebug(planDbg()); |
2091 | Node * node = currentNode(); |
2092 | if ( !node ) |
2093 | return ; |
2094 | |
2095 | switch ( node->type() ) { |
2096 | case Node::Type_Project: { |
2097 | break; |
2098 | } |
2099 | case Node::Type_Subproject: |
2100 | //TODO |
2101 | break; |
2102 | case Node::Type_Task: { |
2103 | Task *task = dynamic_cast<Task *>( node ); |
2104 | Q_ASSERT( task ); |
2105 | TaskProgressDialog *dia = new TaskProgressDialog( *task, currentScheduleManager(), getProject().standardWorktime(), this ); |
2106 | connect(dia, SIGNAL(finished(int)), SLOT(slotTaskProgressFinished(int))); |
2107 | dia->show(); |
2108 | dia->raise(); |
2109 | dia->activateWindow(); |
2110 | break; |
2111 | } |
2112 | case Node::Type_Milestone: { |
2113 | Task *task = dynamic_cast<Task *>( node ); |
2114 | MilestoneProgressDialog *dia = new MilestoneProgressDialog( *task, this ); |
2115 | connect(dia, SIGNAL(finished(int)), SLOT(slotMilestoneProgressFinished(int))); |
2116 | dia->show(); |
2117 | dia->raise(); |
2118 | dia->activateWindow(); |
2119 | break; |
2120 | } |
2121 | case Node::Type_Summarytask: { |
2122 | // TODO |
2123 | break; |
2124 | } |
2125 | default: |
2126 | break; // avoid warnings |
2127 | } |
2128 | } |
2129 | |
2130 | void View::slotTaskProgressFinished( int result ) |
2131 | { |
2132 | TaskProgressDialog *dia = qobject_cast<TaskProgressDialog*>(sender() ); |
2133 | if ( dia == 0 ) { |
2134 | return; |
2135 | } |
2136 | if ( result == QDialog::Accepted) { |
2137 | KUndo2Command * m = dia->buildCommand(); |
2138 | if ( m ) { |
2139 | getPart() ->addCommand( m ); |
2140 | } |
2141 | } |
2142 | dia->deleteLater(); |
2143 | } |
2144 | |
2145 | void View::slotMilestoneProgressFinished( int result ) |
2146 | { |
2147 | MilestoneProgressDialog *dia = qobject_cast<MilestoneProgressDialog*>(sender() ); |
2148 | if ( dia == 0 ) { |
2149 | return; |
2150 | } |
2151 | if ( result == QDialog::Accepted) { |
2152 | KUndo2Command * m = dia->buildCommand(); |
2153 | if ( m ) { |
2154 | getPart() ->addCommand( m ); |
2155 | } |
2156 | } |
2157 | dia->deleteLater(); |
2158 | } |
2159 | |
2160 | void View::slotTaskDescription() |
2161 | { |
2162 | //kDebug(planDbg()); |
2163 | Node * node = currentNode(); |
2164 | if ( !node ) |
2165 | return ; |
2166 | |
2167 | switch ( node->type() ) { |
2168 | case Node::Type_Project: { |
2169 | break; |
2170 | } |
2171 | case Node::Type_Subproject: |
2172 | //TODO |
2173 | break; |
2174 | case Node::Type_Task: |
2175 | case Node::Type_Milestone: |
2176 | case Node::Type_Summarytask: { |
2177 | Task *task = dynamic_cast<Task *>( node ); |
2178 | Q_ASSERT( task ); |
2179 | TaskDescriptionDialog *dia = new TaskDescriptionDialog( *task, this ); |
2180 | connect(dia, SIGNAL(finished(int)), SLOT(slotTaskDescriptionFinished(int))); |
2181 | dia->show(); |
2182 | dia->raise(); |
2183 | dia->activateWindow(); |
2184 | break; |
2185 | } |
2186 | default: |
2187 | break; // avoid warnings |
2188 | } |
2189 | } |
2190 | |
2191 | void View::slotTaskDescriptionFinished( int result ) |
2192 | { |
2193 | TaskDescriptionDialog *dia = qobject_cast<TaskDescriptionDialog*>(sender() ); |
2194 | if ( dia == 0 ) { |
2195 | return; |
2196 | } |
2197 | if ( result == QDialog::Accepted) { |
2198 | KUndo2Command * m = dia->buildCommand(); |
2199 | if ( m ) { |
2200 | getPart() ->addCommand( m ); |
2201 | } |
2202 | } |
2203 | dia->deleteLater(); |
2204 | } |
2205 | |
2206 | void View::slotDeleteTask( QList<Node*> lst ) |
2207 | { |
2208 | //kDebug(planDbg()); |
2209 | foreach ( Node *n, lst ) { |
2210 | if ( n->isScheduled() ) { |
2211 | int res = KMessageBox::warningContinueCancel( this, i18n( "A task that has been scheduled will be deleted. This will invalidate the schedule." ) ); |
2212 | if ( res == KMessageBox::Cancel ) { |
2213 | return; |
2214 | } |
2215 | break; |
2216 | } |
2217 | } |
2218 | if ( lst.count() == 1 ) { |
2219 | getPart()->addCommand( new NodeDeleteCmd( lst.takeFirst(), kundo2_i18n( "Delete task" ) ) ); |
2220 | return; |
2221 | } |
2222 | int num = 0; |
2223 | MacroCommand *cmd = new MacroCommand( kundo2_i18np( "Delete task" , "Delete tasks" , lst.count() ) ); |
2224 | while ( !lst.isEmpty() ) { |
2225 | Node *node = lst.takeFirst(); |
2226 | if ( node == 0 || node->parentNode() == 0 ) { |
2227 | kDebug(planDbg()) << ( node ?"Task is main project" :"No current task" ); |
2228 | continue; |
2229 | } |
2230 | bool del = true; |
2231 | foreach ( Node *n, lst ) { |
2232 | if ( node->isChildOf( n ) ) { |
2233 | del = false; // node is going to be deleted when we delete n |
2234 | break; |
2235 | } |
2236 | } |
2237 | if ( del ) { |
2238 | //kDebug(planDbg())<<num<<": delete:"<<node->name(); |
2239 | cmd->addCommand( new NodeDeleteCmd( node, kundo2_i18n( "Delete task" ) ) ); |
2240 | num++; |
2241 | } |
2242 | } |
2243 | if ( num > 0 ) { |
2244 | getPart()->addCommand( cmd ); |
2245 | } else { |
2246 | delete cmd; |
2247 | } |
2248 | } |
2249 | |
2250 | void View::slotDeleteTask( Node *node ) |
2251 | { |
2252 | //kDebug(planDbg()); |
2253 | if ( node == 0 || node->parentNode() == 0 ) { |
2254 | kDebug(planDbg()) << ( node ?"Task is main project" :"No current task" ); |
2255 | return ; |
2256 | } |
2257 | if ( node->isScheduled() ) { |
2258 | int res = KMessageBox::warningContinueCancel( this, i18n( "This task has been scheduled. This will invalidate the schedule." ) ); |
2259 | if ( res == KMessageBox::Cancel ) { |
2260 | return; |
2261 | } |
2262 | } |
2263 | NodeDeleteCmd *cmd = new NodeDeleteCmd( node, kundo2_i18n( "Delete task" ) ); |
2264 | getPart() ->addCommand( cmd ); |
2265 | } |
2266 | |
2267 | void View::slotDeleteTask() |
2268 | { |
2269 | //kDebug(planDbg()); |
2270 | return slotDeleteTask( currentNode() ); |
2271 | } |
2272 | |
2273 | void View::slotIndentTask() |
2274 | { |
2275 | //kDebug(planDbg()); |
2276 | Node * node = currentNode(); |
2277 | if ( node == 0 || node->parentNode() == 0 ) { |
2278 | kDebug(planDbg()) << ( node ?"Task is main project" :"No current task" ); |
2279 | return ; |
2280 | } |
2281 | if ( getProject().canIndentTask( node ) ) { |
2282 | NodeIndentCmd * cmd = new NodeIndentCmd( *node, kundo2_i18n( "Indent task" ) ); |
2283 | getPart() ->addCommand( cmd ); |
2284 | } |
2285 | } |
2286 | |
2287 | void View::slotUnindentTask() |
2288 | { |
2289 | //kDebug(planDbg()); |
2290 | Node * node = currentNode(); |
2291 | if ( node == 0 || node->parentNode() == 0 ) { |
2292 | kDebug(planDbg()) << ( node ?"Task is main project" :"No current task" ); |
2293 | return ; |
2294 | } |
2295 | if ( getProject().canUnindentTask( node ) ) { |
2296 | NodeUnindentCmd * cmd = new NodeUnindentCmd( *node, kundo2_i18n( "Unindent task" ) ); |
2297 | getPart() ->addCommand( cmd ); |
2298 | } |
2299 | } |
2300 | |
2301 | void View::slotMoveTaskUp() |
2302 | { |
2303 | //kDebug(planDbg()); |
2304 | |
2305 | Node * task = currentNode(); |
2306 | if ( 0 == task ) { |
2307 | // is always != 0. At least we would get the Project, but you never know who might change that |
2308 | // so better be careful |
2309 | kError() << "No current task" << endl; |
2310 | return ; |
2311 | } |
2312 | |
2313 | if ( Node::Type_Project == task->type() ) { |
2314 | kDebug(planDbg()) <<"The root node cannot be moved up" ; |
2315 | return ; |
2316 | } |
2317 | if ( getProject().canMoveTaskUp( task ) ) { |
2318 | NodeMoveUpCmd * cmd = new NodeMoveUpCmd( *task, kundo2_i18n( "Move task up" ) ); |
2319 | getPart() ->addCommand( cmd ); |
2320 | } |
2321 | } |
2322 | |
2323 | void View::slotMoveTaskDown() |
2324 | { |
2325 | //kDebug(planDbg()); |
2326 | |
2327 | Node * task = currentNode(); |
2328 | if ( 0 == task ) { |
2329 | // is always != 0. At least we would get the Project, but you never know who might change that |
2330 | // so better be careful |
2331 | return ; |
2332 | } |
2333 | |
2334 | if ( Node::Type_Project == task->type() ) { |
2335 | kDebug(planDbg()) <<"The root node cannot be moved down" ; |
2336 | return ; |
2337 | } |
2338 | if ( getProject().canMoveTaskDown( task ) ) { |
2339 | NodeMoveDownCmd * cmd = new NodeMoveDownCmd( *task, kundo2_i18n( "Move task down" ) ); |
2340 | getPart() ->addCommand( cmd ); |
2341 | } |
2342 | } |
2343 | |
2344 | void View::slotAddRelation( Node *par, Node *child ) |
2345 | { |
2346 | //kDebug(planDbg()); |
2347 | Relation * rel = new Relation( par, child ); |
2348 | AddRelationDialog *dia = new AddRelationDialog( getProject(), rel, this ); |
2349 | connect(dia, SIGNAL(finished(int)), SLOT(slotAddRelationFinished(int))); |
2350 | dia->show(); |
2351 | dia->raise(); |
2352 | dia->activateWindow(); |
2353 | } |
2354 | |
2355 | void View::slotAddRelationFinished( int result ) |
2356 | { |
2357 | AddRelationDialog *dia = qobject_cast<AddRelationDialog*>(sender() ); |
2358 | if ( dia == 0 ) { |
2359 | return; |
2360 | } |
2361 | if ( result == QDialog::Accepted) { |
2362 | KUndo2Command * m = dia->buildCommand(); |
2363 | if ( m ) { |
2364 | getPart() ->addCommand( m ); |
2365 | } |
2366 | } |
2367 | dia->deleteLater(); |
2368 | } |
2369 | |
2370 | void View::slotAddRelation( Node *par, Node *child, int linkType ) |
2371 | { |
2372 | //kDebug(planDbg()); |
2373 | if ( linkType == Relation::FinishStart || |
2374 | linkType == Relation::StartStart || |
2375 | linkType == Relation::FinishFinish ) { |
2376 | Relation * rel = new Relation( par, child, static_cast<Relation::Type>( linkType ) ); |
2377 | getPart() ->addCommand( new AddRelationCmd( getProject(), rel, kundo2_i18n( "Add task dependency" ) ) ); |
2378 | } else { |
2379 | slotAddRelation( par, child ); |
2380 | } |
2381 | } |
2382 | |
2383 | void View::slotModifyRelation( Relation *rel ) |
2384 | { |
2385 | //kDebug(planDbg()); |
2386 | ModifyRelationDialog *dia = new ModifyRelationDialog( getProject(), rel, this ); |
2387 | connect(dia, SIGNAL(finished(int)), SLOT(slotModifyRelationFinished(int))); |
2388 | dia->show(); |
2389 | dia->raise(); |
2390 | dia->activateWindow(); |
2391 | } |
2392 | |
2393 | void View::slotModifyRelationFinished( int result ) |
2394 | { |
2395 | ModifyRelationDialog *dia = qobject_cast<ModifyRelationDialog*>( sender() ); |
2396 | if ( dia == 0 ) { |
2397 | return ; |
2398 | } |
2399 | if ( result == QDialog::Accepted) { |
2400 | KUndo2Command *cmd = dia->buildCommand(); |
2401 | if ( cmd ) { |
2402 | getPart() ->addCommand( cmd ); |
2403 | } |
2404 | } |
2405 | dia->deleteLater(); |
2406 | } |
2407 | |
2408 | void View::slotModifyRelation( Relation *rel, int linkType ) |
2409 | { |
2410 | //kDebug(planDbg()); |
2411 | if ( linkType == Relation::FinishStart || |
2412 | linkType == Relation::StartStart || |
2413 | linkType == Relation::FinishFinish ) { |
2414 | getPart() ->addCommand( new ModifyRelationTypeCmd( rel, static_cast<Relation::Type>( linkType ) ) ); |
2415 | } else { |
2416 | slotModifyRelation( rel ); |
2417 | } |
2418 | } |
2419 | |
2420 | void View::slotModifyRelation() |
2421 | { |
2422 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
2423 | if ( v == 0 ) { |
2424 | return; |
2425 | } |
2426 | Relation *rel = v->currentRelation(); |
2427 | if ( rel ) { |
2428 | slotModifyRelation( rel ); |
2429 | } |
2430 | } |
2431 | |
2432 | void View::slotDeleteRelation() |
2433 | { |
2434 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
2435 | if ( v == 0 ) { |
2436 | return; |
2437 | } |
2438 | Relation *rel = v->currentRelation(); |
2439 | if ( rel ) { |
2440 | getPart()->addCommand( new DeleteRelationCmd( getProject(), rel, kundo2_i18n( "Delete task dependency" ) ) ); |
2441 | } |
2442 | } |
2443 | |
2444 | void View::slotEditResource() |
2445 | { |
2446 | //kDebug(planDbg()); |
2447 | slotEditResource( currentResource() ); |
2448 | } |
2449 | |
2450 | void View::slotEditResource( Resource *resource ) |
2451 | { |
2452 | if ( resource == 0 ) { |
2453 | return ; |
2454 | } |
2455 | ResourceDialog *dia = new ResourceDialog( getProject(), resource, this ); |
2456 | connect(dia, SIGNAL(finished(int)), SLOT(slotEditResourceFinished(int))); |
2457 | dia->show(); |
2458 | dia->raise(); |
2459 | dia->activateWindow(); |
2460 | } |
2461 | |
2462 | void View::slotEditResourceFinished( int result ) |
2463 | { |
2464 | //kDebug(planDbg()); |
2465 | ResourceDialog *dia = qobject_cast<ResourceDialog*>( sender() ); |
2466 | if ( dia == 0 ) { |
2467 | return ; |
2468 | } |
2469 | if ( result == QDialog::Accepted) { |
2470 | KUndo2Command * cmd = dia->buildCommand(); |
2471 | if ( cmd ) |
2472 | getPart() ->addCommand( cmd ); |
2473 | } |
2474 | dia->deleteLater(); |
2475 | } |
2476 | |
2477 | void View::slotDeleteResource( Resource *resource ) |
2478 | { |
2479 | getPart()->addCommand( new RemoveResourceCmd( resource->parentGroup(), resource, kundo2_i18n( "Delete resource" ) ) ); |
2480 | } |
2481 | |
2482 | void View::slotDeleteResourceGroup( ResourceGroup *group ) |
2483 | { |
2484 | getPart()->addCommand( new RemoveResourceGroupCmd( group->project(), group, kundo2_i18n( "Delete resourcegroup" ) ) ); |
2485 | } |
2486 | |
2487 | void View::slotDeleteResourceObjects( QObjectList lst ) |
2488 | { |
2489 | //kDebug(planDbg()); |
2490 | foreach ( QObject *o, lst ) { |
2491 | Resource *r = qobject_cast<Resource*>( o ); |
2492 | if ( r && r->isScheduled() ) { |
2493 | int res = KMessageBox::warningContinueCancel( this, i18n( "A resource that has been scheduled will be deleted. This will invalidate the schedule." ) ); |
2494 | if ( res == KMessageBox::Cancel ) { |
2495 | return; |
2496 | } |
2497 | break; |
2498 | } |
2499 | ResourceGroup *g = qobject_cast<ResourceGroup*>( o ); |
2500 | if ( g && g->isScheduled() ) { |
2501 | int res = KMessageBox::warningContinueCancel( this, i18n( "A resource that has been scheduled will be deleted. This will invalidate the schedule." ) ); |
2502 | if ( res == KMessageBox::Cancel ) { |
2503 | return; |
2504 | } |
2505 | break; |
2506 | } |
2507 | } |
2508 | if ( lst.count() == 1 ) { |
2509 | Resource *r = qobject_cast<Resource*>( lst.first() ); |
2510 | if ( r ) { |
2511 | slotDeleteResource( r ); |
2512 | } else { |
2513 | ResourceGroup *g = qobject_cast<ResourceGroup*>( lst.first() ); |
2514 | if ( g ) { |
2515 | slotDeleteResourceGroup( g ); |
2516 | } |
2517 | } |
2518 | return; |
2519 | } |
2520 | // int num = 0; |
2521 | MacroCommand *cmd = 0, *rc = 0, *gc = 0; |
2522 | foreach ( QObject *o, lst ) { |
2523 | Resource *r = qobject_cast<Resource*>( o ); |
2524 | if ( r ) { |
2525 | if ( rc == 0 ) rc = new MacroCommand( KUndo2MagicString() ); |
2526 | rc->addCommand( new RemoveResourceCmd( r->parentGroup(), r ) ); |
2527 | continue; |
2528 | } |
2529 | ResourceGroup *g = qobject_cast<ResourceGroup*>( o ); |
2530 | if ( g ) { |
2531 | if ( gc == 0 ) gc = new MacroCommand( KUndo2MagicString() ); |
2532 | gc->addCommand( new RemoveResourceGroupCmd( g->project(), g ) ); |
2533 | } |
2534 | } |
2535 | if ( rc || gc ) { |
2536 | KUndo2MagicString s; |
2537 | if ( rc && gc ) { |
2538 | s = kundo2_i18n( "Delete resourcegroups and resources" ); |
2539 | } else if ( rc ) { |
2540 | s = kundo2_i18np( "Delete resource" , "Delete resources" , lst.count() ); |
2541 | } else { |
2542 | s = kundo2_i18np( "Delete resourcegroup" , "Delete resourcegroups" , lst.count() ); |
2543 | } |
2544 | cmd = new MacroCommand( s ); |
2545 | } |
2546 | if ( rc ) |
2547 | cmd->addCommand( rc ); |
2548 | if ( gc ) |
2549 | cmd->addCommand( gc ); |
2550 | if ( cmd ) |
2551 | getPart()->addCommand( cmd ); |
2552 | } |
2553 | |
2554 | |
2555 | void View::updateReadWrite( bool readwrite ) |
2556 | { |
2557 | m_readWrite = readwrite; |
2558 | m_viewlist->setReadWrite( readwrite ); |
2559 | } |
2560 | |
2561 | MainDocument *View::getPart() const |
2562 | { |
2563 | return ( MainDocument * ) koDocument(); |
2564 | } |
2565 | |
2566 | KoPart *View::getKoPart() const |
2567 | { |
2568 | return m_partpart; |
2569 | } |
2570 | |
2571 | void View::slotConnectNode() |
2572 | { |
2573 | //kDebug(planDbg()); |
2574 | /* NodeItem *curr = ganttview->currentItem(); |
2575 | if (curr) { |
2576 | kDebug(planDbg())<<"node="<<curr->getNode().name(); |
2577 | }*/ |
2578 | } |
2579 | |
2580 | QMenu * View::( const QString& name ) |
2581 | { |
2582 | //kDebug(planDbg()); |
2583 | if ( factory() ) |
2584 | return ( ( QMenu* ) factory() ->container( name, this ) ); |
2585 | return 0L; |
2586 | } |
2587 | |
2588 | void View::slotUpdate() |
2589 | { |
2590 | //kDebug(planDbg())<<"calculate="<<calculate; |
2591 | |
2592 | // m_updateResourceview = true; |
2593 | m_updateResourceAssignmentView = true; |
2594 | m_updatePertEditor = true; |
2595 | updateView( m_tab->currentWidget() ); |
2596 | } |
2597 | |
2598 | void View::slotGuiActivated( ViewBase *view, bool activate ) |
2599 | { |
2600 | //FIXME: Avoid unplug if possible, it flashes the gui |
2601 | // always unplug, in case they already are plugged |
2602 | foreach( const QString &name, view->actionListNames() ) { |
2603 | unplugActionList( name ); |
2604 | } |
2605 | if ( activate ) { |
2606 | foreach( const QString &name, view->actionListNames() ) { |
2607 | plugActionList( name, view->actionList( name ) ); |
2608 | } |
2609 | foreach ( DockWidget *ds, view->dockers() ) { |
2610 | m_dockers.append( ds ); |
2611 | ds->activate( mainWindow() ); |
2612 | } |
2613 | kDebug(planDbg())<<"Added dockers:" <<view<<m_dockers; |
2614 | } else { |
2615 | kDebug(planDbg())<<"Remove dockers:" <<view<<m_dockers; |
2616 | while ( ! m_dockers.isEmpty() ) { |
2617 | m_dockers.takeLast()->deactivate( mainWindow() ); |
2618 | } |
2619 | } |
2620 | } |
2621 | |
2622 | void View::guiActivateEvent( bool activated ) |
2623 | { |
2624 | if ( activated ) { |
2625 | // plug my own actionlists, they may be gone |
2626 | slotPlugScheduleActions(); |
2627 | } |
2628 | // propagate to sub-view |
2629 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
2630 | if ( v ) { |
2631 | v->setGuiActive( activated ); |
2632 | } |
2633 | } |
2634 | |
2635 | void View::slotViewListItemRemoved( ViewListItem *item ) |
2636 | { |
2637 | getPart()->removeViewListItem( this, item ); |
2638 | } |
2639 | |
2640 | void View::removeViewListItem( const ViewListItem *item ) |
2641 | { |
2642 | if ( item == 0 ) { |
2643 | return; |
2644 | } |
2645 | ViewListItem *itm = m_viewlist->findItem( item->tag() ); |
2646 | if ( itm == 0 ) { |
2647 | return; |
2648 | } |
2649 | m_viewlist->removeViewListItem( itm ); |
2650 | return; |
2651 | } |
2652 | |
2653 | void View::slotViewListItemInserted( ViewListItem *item, ViewListItem *parent, int index ) |
2654 | { |
2655 | getPart()->insertViewListItem( this, item, parent, index ); |
2656 | } |
2657 | |
2658 | void View::addViewListItem( const ViewListItem *item, const ViewListItem *parent, int index ) |
2659 | { |
2660 | if ( item == 0 ) { |
2661 | return; |
2662 | } |
2663 | if ( parent == 0 ) { |
2664 | if ( item->type() != ViewListItem::ItemType_Category ) { |
2665 | return; |
2666 | } |
2667 | m_viewlist->blockSignals( true ); |
2668 | ViewListItem *cat = m_viewlist->addCategory( item->tag(), item->text( 0 ) ); |
2669 | cat->setToolTip( 0, item->toolTip( 0 ) ); |
2670 | m_viewlist->blockSignals( false ); |
2671 | return; |
2672 | } |
2673 | ViewListItem *cat = m_viewlist->findCategory( parent->tag() ); |
2674 | if ( cat == 0 ) { |
2675 | return; |
2676 | } |
2677 | m_viewlist->blockSignals( true ); |
2678 | createView( cat, item->viewType(), item->tag(), item->text( 0 ), item->toolTip( 0 ), index ); |
2679 | m_viewlist->blockSignals( false ); |
2680 | } |
2681 | /* |
2682 | void View::slotCreateReport() |
2683 | { |
2684 | ReportView v(getKoPart(), getPart(), 0 ); |
2685 | ReportDesignDialog *dlg = new ReportDesignDialog( &(getProject()), currentScheduleManager(), QDomElement(), v.createReportModels( &getProject(), currentScheduleManager() ), this ); |
2686 | // The ReportDesignDialog can not know how to create and insert views, |
2687 | // so faciclitate this in the slotCreateReportView() slot. |
2688 | connect( dlg, SIGNAL(createReportView(ReportDesignDialog*)), SLOT(slotCreateReportView(ReportDesignDialog*))); |
2689 | connect(dlg, SIGNAL(finished(int)), SLOT(slotReportDesignFinished(int))); |
2690 | connect(dlg, SIGNAL(modifyReportDefinition(KUndo2Command*)), SLOT(slotModifyReportDefinition(KUndo2Command*))); |
2691 | dlg->show(); |
2692 | dlg->raise(); |
2693 | dlg->activateWindow(); |
2694 | } |
2695 | */ |
2696 | void View::slotCreateReportView( ReportDesignDialog *dlg ) |
2697 | { |
2698 | QPointer<ViewListReportsDialog> vd = new ViewListReportsDialog( this, *m_viewlist, dlg ); |
2699 | connect( vd, SIGNAL(viewCreated(ViewBase*)), dlg, SLOT(slotViewCreated(ViewBase*)) ); |
2700 | vd->exec(); |
2701 | delete vd; |
2702 | } |
2703 | |
2704 | void View::slotOpenReportFile() |
2705 | { |
2706 | KFileDialog *dlg = new KFileDialog( KUrl(), QString(), this ); |
2707 | connect(dlg, SIGNAL(finished(int)), SLOT(slotOpenReportFileFinished(int))); |
2708 | dlg->show(); |
2709 | dlg->raise(); |
2710 | dlg->activateWindow(); |
2711 | } |
2712 | |
2713 | void View::slotOpenReportFileFinished( int result ) |
2714 | { |
2715 | KFileDialog *fdlg = qobject_cast<KFileDialog*>( sender() ); |
2716 | if ( fdlg == 0 || result != QDialog::Accepted ) { |
2717 | return; |
2718 | } |
2719 | QString fn = fdlg->selectedFile(); |
2720 | if ( fn.isEmpty() ) { |
2721 | return; |
2722 | } |
2723 | QFile file( fn ); |
2724 | if ( ! file.open( QIODevice::ReadOnly | QIODevice::Text ) ) { |
2725 | KMessageBox::sorry( this, i18nc( "@info" , "Cannot open file:<br/><filename>%1</filename>" , fn ) ); |
2726 | return; |
2727 | } |
2728 | QDomDocument doc; |
2729 | doc.setContent( &file ); |
2730 | QDomElement e = doc.documentElement(); |
2731 | ReportDesignDialog *dlg = new ReportDesignDialog( e, Report::createBaseReportDataModels( this ), this ); |
2732 | // The ReportDesignDialog can not know how to create and insert views, |
2733 | // so faciclitate this in the slotCreateReportView() slot. |
2734 | connect( dlg, SIGNAL(createReportView(ReportDesignDialog*)), SLOT(slotCreateReportView(ReportDesignDialog*))); |
2735 | connect(dlg, SIGNAL(modifyReportDefinition(KUndo2Command*)), SLOT(slotModifyReportDefinition(KUndo2Command*))); |
2736 | connect(dlg, SIGNAL(finished(int)), SLOT(slotReportDesignFinished(int))); |
2737 | dlg->show(); |
2738 | dlg->raise(); |
2739 | dlg->activateWindow(); |
2740 | } |
2741 | |
2742 | void View::slotReportDesignFinished( int /*result */) |
2743 | { |
2744 | if ( sender() ) { |
2745 | sender()->deleteLater(); |
2746 | } |
2747 | } |
2748 | |
2749 | void View::slotModifyReportDefinition( KUndo2Command *cmd ) |
2750 | { |
2751 | cmd->redo(); |
2752 | delete cmd; // TODO Maybe add command history to views and/or view selector? |
2753 | m_viewlist->setModified(); |
2754 | } |
2755 | |
2756 | void View::slotCreateView() |
2757 | { |
2758 | ViewListDialog *dlg = new ViewListDialog( this, *m_viewlist, this ); |
2759 | connect(dlg, SIGNAL(finished(int)), SLOT(slotCreateViewFinished(int))); |
2760 | dlg->show(); |
2761 | dlg->raise(); |
2762 | dlg->activateWindow(); |
2763 | } |
2764 | |
2765 | void View::slotCreateViewFinished( int ) |
2766 | { |
2767 | if ( sender() ) { |
2768 | sender()->deleteLater(); |
2769 | } |
2770 | } |
2771 | |
2772 | void View::slotViewActivated( ViewListItem *item, ViewListItem *prev ) |
2773 | { |
2774 | QApplication::setOverrideCursor( Qt::WaitCursor ); |
2775 | if ( prev && prev->type() == ViewListItem::ItemType_Category && m_viewlist->previousViewItem() ) { |
2776 | // A view is shown anyway... |
2777 | ViewBase *v = qobject_cast<ViewBase*>( m_viewlist->previousViewItem()->view() ); |
2778 | if ( v ) { |
2779 | v->setGuiActive( false ); |
2780 | } |
2781 | } else if ( prev && prev->type() == ViewListItem::ItemType_SubView ) { |
2782 | ViewBase *v = qobject_cast<ViewBase*>( prev->view() ); |
2783 | if ( v ) { |
2784 | v->setGuiActive( false ); |
2785 | } |
2786 | } |
2787 | if ( item && item->type() == ViewListItem::ItemType_SubView ) { |
2788 | //kDebug(planDbg())<<"Activate:"<<item; |
2789 | m_tab->setCurrentWidget( item->view() ); |
2790 | // Add sub-view specific gui |
2791 | ViewBase *v = dynamic_cast<ViewBase*>( m_tab->currentWidget() ); |
2792 | if ( v ) { |
2793 | v->setGuiActive( true ); |
2794 | } |
2795 | } |
2796 | QApplication::restoreOverrideCursor(); |
2797 | } |
2798 | |
2799 | QWidget *View::canvas() const |
2800 | { |
2801 | return m_tab->currentWidget();//KoView::canvas(); |
2802 | } |
2803 | |
2804 | KoPageLayout View::pageLayout() const |
2805 | { |
2806 | return currentView()->pageLayout(); |
2807 | } |
2808 | |
2809 | QPrintDialog *View::createPrintDialog( KoPrintJob *printJob, QWidget *parent ) |
2810 | { |
2811 | kDebug(planDbg())<<printJob; |
2812 | KoPrintingDialog *job = dynamic_cast<KoPrintingDialog*>( printJob ); |
2813 | if ( ! job ) { |
2814 | return 0; |
2815 | } |
2816 | QPrintDialog *dia = KoView::createPrintDialog( job, parent ); |
2817 | |
2818 | PrintingDialog *j = dynamic_cast<PrintingDialog*>( job ); |
2819 | if ( j ) { |
2820 | new PrintingControlPrivate( j, dia ); |
2821 | } |
2822 | return dia; |
2823 | } |
2824 | |
2825 | void View::slotCurrentChanged( int ) |
2826 | { |
2827 | ViewListItem *item = m_viewlist->findItem( qobject_cast<ViewBase*>( m_tab->currentWidget() ) ); |
2828 | m_viewlist->setCurrentItem( item ); |
2829 | } |
2830 | |
2831 | void View::updateView( QWidget * ) |
2832 | { |
2833 | QApplication::setOverrideCursor( Qt::WaitCursor ); |
2834 | //setScheduleActionsEnabled(); |
2835 | |
2836 | QWidget *widget2; |
2837 | |
2838 | widget2 = m_viewlist->findView( "ResourceAssignmentView" ); |
2839 | if ( widget2 && m_updateResourceAssignmentView ) |
2840 | static_cast<ViewBase*>( widget2 ) ->draw( getProject() ); |
2841 | m_updateResourceAssignmentView = false; |
2842 | |
2843 | QApplication::restoreOverrideCursor(); |
2844 | } |
2845 | |
2846 | void View::slotRenameNode( Node *node, const QString& name ) |
2847 | { |
2848 | //kDebug(planDbg())<<name; |
2849 | if ( node ) { |
2850 | KUndo2MagicString s = kundo2_i18n( "Modify name" ); |
2851 | switch( node->type() ) { |
2852 | case Node::Type_Task: s = kundo2_i18n( "Modify task name" ); break; |
2853 | case Node::Type_Milestone: s = kundo2_i18n( "Modify milestone name" ); break; |
2854 | case Node::Type_Summarytask: s = kundo2_i18n( "Modify summarytask name" ); break; |
2855 | case Node::Type_Project: s = kundo2_i18n( "Modify project name" ); break; |
2856 | } |
2857 | NodeModifyNameCmd * cmd = new NodeModifyNameCmd( *node, name, s ); |
2858 | getPart() ->addCommand( cmd ); |
2859 | } |
2860 | } |
2861 | |
2862 | void View::( const QString& , const QPoint & pos ) |
2863 | { |
2864 | QMenu * = this->popupMenu( menuname ); |
2865 | if ( menu ) { |
2866 | //kDebug(planDbg())<<menu<<":"<<menu->actions().count(); |
2867 | ViewBase *v = qobject_cast<ViewBase*>( m_tab->currentWidget() ); |
2868 | kDebug(planDbg())<<v<<menuname; |
2869 | QList<QAction*> lst; |
2870 | if ( v ) { |
2871 | lst = v->contextActionList(); |
2872 | kDebug(planDbg())<<lst; |
2873 | if ( ! lst.isEmpty() ) { |
2874 | menu->addSeparator(); |
2875 | foreach ( QAction *a, lst ) { |
2876 | menu->addAction( a ); |
2877 | } |
2878 | } |
2879 | } |
2880 | menu->exec( pos ); |
2881 | foreach ( QAction *a, lst ) { |
2882 | menu->removeAction( a ); |
2883 | } |
2884 | } |
2885 | } |
2886 | |
2887 | void View::( const QString& , const QPoint &pos, ViewListItem *item ) |
2888 | { |
2889 | //kDebug(planDbg())<<menuname; |
2890 | m_viewlistItem = item; |
2891 | slotPopupMenu( menuname, pos ); |
2892 | } |
2893 | |
2894 | bool View::loadContext() |
2895 | { |
2896 | Context *ctx = getPart()->context(); |
2897 | if ( ctx == 0 || ! ctx->isLoaded() ) { |
2898 | return false; |
2899 | } |
2900 | KoXmlElement n = ctx->context(); |
2901 | QString cv = n.attribute( "current-view" ); |
2902 | if ( ! cv.isEmpty() ) { |
2903 | m_viewlist->setSelected( m_viewlist->findItem( cv ) ); |
2904 | } else kDebug(planDbg())<<"No current view" ; |
2905 | |
2906 | long id = n.attribute( "current-schedule" , "-1" ).toLong(); |
2907 | if ( id != -1 ) { |
2908 | setActiveSchedule( id ); |
2909 | } else kDebug(planDbg())<<"No current schedule" ; |
2910 | |
2911 | return true; |
2912 | } |
2913 | |
2914 | void View::saveContext( QDomElement &me ) const |
2915 | { |
2916 | //kDebug(planDbg()); |
2917 | long id = activeScheduleId(); |
2918 | if ( id != -1 ) { |
2919 | me.setAttribute( "current-schedule" , (qlonglong)id ); |
2920 | } |
2921 | ViewListItem *item = m_viewlist->findItem( qobject_cast<ViewBase*>( m_tab->currentWidget() ) ); |
2922 | if ( item ) { |
2923 | me.setAttribute("current-view" , item->tag() ); |
2924 | } |
2925 | m_viewlist->save( me ); |
2926 | } |
2927 | |
2928 | bool View::loadWorkPackage( Project &project, const KUrl &url ) |
2929 | { |
2930 | return getPart()->loadWorkPackage( project, url ); |
2931 | } |
2932 | |
2933 | void View::setLabel( ScheduleManager *sm ) |
2934 | { |
2935 | //kDebug(planDbg()); |
2936 | Schedule *s = sm == 0 ? 0 : sm->expected(); |
2937 | if ( s && !s->isDeleted() && s->isScheduled() ) { |
2938 | m_estlabel->setText( sm->name() ); |
2939 | return; |
2940 | } |
2941 | m_estlabel->setText( i18nc( "@info:status" , "Not scheduled" ) ); |
2942 | } |
2943 | |
2944 | void View::slotWorkPackageLoaded() |
2945 | { |
2946 | kDebug(planDbg())<<getPart()->workPackages(); |
2947 | } |
2948 | |
2949 | void View::slotMailWorkpackage( Node *node, Resource *resource ) |
2950 | { |
2951 | kDebug(planDbg()); |
2952 | KTemporaryFile tmpfile; |
2953 | tmpfile.setAutoRemove( false ); |
2954 | tmpfile.setSuffix( ".planwork" ); |
2955 | if ( ! tmpfile.open() ) { |
2956 | kDebug(planDbg())<<"Failed to open file" ; |
2957 | KMessageBox::error(0, i18n("Failed to open temporary file" ) ); |
2958 | return; |
2959 | } |
2960 | KUrl url; |
2961 | url.setPath( tmpfile.fileName() ); |
2962 | if ( ! getPart()->saveWorkPackageUrl( url, node, activeScheduleId(), resource ) ) { |
2963 | kDebug(planDbg())<<"Failed to save to file" ; |
2964 | KMessageBox::error(0, i18nc( "@info" , "Failed to save to temporary file:<br/> <filename>%1</filename>" , url.url() ) ); |
2965 | return; |
2966 | } |
2967 | QStringList attachURLs; |
2968 | attachURLs << url.url(); |
2969 | QString to = resource == 0 ? node->leader() : ( resource->name() + " <" + resource->email() + '>' ); |
2970 | QString cc; |
2971 | QString bcc; |
2972 | QString subject = i18n( "Work Package: %1" , node->name() ); |
2973 | QString body = i18nc( "1=project name, 2=task name" , "%1\n%2" , getProject().name(), node->name() ); |
2974 | QString messageFile; |
2975 | |
2976 | KToolInvocation::invokeMailer( to, cc, bcc, subject, body, messageFile, attachURLs ); |
2977 | } |
2978 | |
2979 | void View::slotMailWorkpackages( const QList<Node*> &nodes, Resource *resource ) |
2980 | { |
2981 | kDebug(planDbg()); |
2982 | if ( resource == 0 ) { |
2983 | kWarning()<<"No resource, we don't handle node->leader() yet" ; |
2984 | return; |
2985 | } |
2986 | QString to = resource->name() + " <" + resource->email() + '>'; |
2987 | QString subject = i18n( "Work Package for project: %1" , getProject().name() ); |
2988 | QString body; |
2989 | QStringList attachURLs; |
2990 | |
2991 | foreach ( Node *n, nodes ) { |
2992 | KTemporaryFile tmpfile; |
2993 | tmpfile.setAutoRemove( false ); |
2994 | tmpfile.setSuffix( ".planwork" ); |
2995 | if ( ! tmpfile.open() ) { |
2996 | kDebug(planDbg())<<"Failed to open file" ; |
2997 | KMessageBox::error(0, i18n("Failed to open temporary file" ) ); |
2998 | return; |
2999 | } |
3000 | KUrl url; |
3001 | url.setPath( tmpfile.fileName() ); |
3002 | if ( ! getPart()->saveWorkPackageUrl( url, n, activeScheduleId(), resource ) ) { |
3003 | kDebug(planDbg())<<"Failed to save to file" ; |
3004 | KMessageBox::error(0, i18nc( "@info" , "Failed to save to temporary file:<br><filename>%1</filename>" , url.url() ) ); |
3005 | return; |
3006 | } |
3007 | attachURLs << url.url(); |
3008 | body += n->name() + '\n'; |
3009 | } |
3010 | |
3011 | QString cc; |
3012 | QString bcc; |
3013 | QString messageFile; |
3014 | |
3015 | KToolInvocation::invokeMailer( to, cc, bcc, subject, body, messageFile, attachURLs ); |
3016 | } |
3017 | |
3018 | void View::slotCurrencyConfig() |
3019 | { |
3020 | LocaleConfigMoneyDialog *dlg = new LocaleConfigMoneyDialog( getProject().locale(), this ); |
3021 | connect(dlg, SIGNAL(finished(int)), SLOT(slotCurrencyConfigFinished(int))); |
3022 | dlg->show(); |
3023 | dlg->raise(); |
3024 | dlg->activateWindow(); |
3025 | } |
3026 | |
3027 | void View::slotCurrencyConfigFinished( int result ) |
3028 | { |
3029 | LocaleConfigMoneyDialog *dlg = qobject_cast<LocaleConfigMoneyDialog*>( sender() ); |
3030 | if ( dlg == 0 ) { |
3031 | return; |
3032 | } |
3033 | if ( result == QDialog::Accepted ) { |
3034 | KUndo2Command *c = dlg->buildCommand( getProject() ); |
3035 | if ( c ) { |
3036 | getPart()->addCommand( c ); |
3037 | } |
3038 | } |
3039 | dlg->deleteLater(); |
3040 | } |
3041 | |
3042 | void View::saveTaskModule( const KUrl &url, Project *project ) |
3043 | { |
3044 | kDebug(planDbg())<<url<<project; |
3045 | QString dir = Factory::global().dirs()->saveLocation( "plan_taskmodules" ); |
3046 | kDebug(planDbg())<<"dir=" <<dir; |
3047 | if ( ! dir.isEmpty() ) { |
3048 | MainDocument part(getKoPart()); |
3049 | part.insertProject( *project, 0, 0 ); |
3050 | part.getProject().setName( project->name() ); |
3051 | part.getProject().setLeader( project->leader() ); |
3052 | part.getProject().setDescription( project->description() ); |
3053 | part.saveNativeFormat( dir + url.fileName() ); |
3054 | kDebug(planDbg())<<dir + url.fileName(); |
3055 | } else { |
3056 | kDebug(planDbg())<<"Could not find a location" ; |
3057 | } |
3058 | } |
3059 | |
3060 | void View::removeTaskModule( const KUrl &url ) |
3061 | { |
3062 | kDebug(planDbg())<<url; |
3063 | } |
3064 | |
3065 | QString View::standardTaskStatusReport() const |
3066 | { |
3067 | QString s = QString::fromLatin1( |
3068 | "<planreportdefinition version=\"1.0\" mime=\"application/x-vnd.kde.plan.report.definition\" editor=\"Plan\" >" |
3069 | "<data-source select-from=\"taskstatus\" ></data-source>" |
3070 | "<report:content xmlns:report=\"http://kexi-project.org/report/2.0\" xmlns:fo=\"urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0\" xmlns:svg=\"urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0\" >" |
3071 | "<report:title>%1</report:title>" |
3072 | "<report:script report:script-interpreter=\"javascript\" ></report:script>" |
3073 | "<report:grid report:grid-divisions=\"4\" report:grid-snap=\"1\" report:page-unit=\"cm\" report:grid-visible=\"1\" />" |
3074 | "<report:page-style report:print-orientation=\"portrait\" fo:margin-bottom=\"1cm\" fo:margin-top=\"1cm\" fo:margin-left=\"1cm\" fo:margin-right=\"1cm\" report:page-size=\"A4\" >predefined</report:page-style>" |
3075 | "<report:body>" |
3076 | "<report:section svg:height=\"1.75cm\" fo:background-color=\"#ffffff\" report:section-type=\"header-page-any\" >" |
3077 | "<report:field report:name=\"field16\" report:horizontal-align=\"left\" report:item-data-source=\"=project.Manager()\" svg:x=\"13cm\" svg:width=\"5.9714cm\" svg:y=\"0.4cm\" report:vertical-align=\"bottom\" svg:height=\"0.6cm\" report:z-index=\"0\" >" |
3078 | "<report:text-style fo:font-weight=\"bold\" fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"10\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3079 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3080 | "</report:field>" |
3081 | "<report:label report:name=\"label16\" report:horizontal-align=\"left\" svg:x=\"13cm\" svg:width=\"5.9714cm\" svg:y=\"0cm\" report:caption=\"%2\" report:vertical-align=\"center\" svg:height=\"0.4cm\" report:z-index=\"1\" >" |
3082 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3083 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3084 | "</report:label>" |
3085 | "<report:field report:name=\"field17\" report:horizontal-align=\"left\" report:item-data-source=\"=project.Name()\" svg:x=\"0cm\" svg:width=\"13cm\" svg:y=\"0.4cm\" report:vertical-align=\"bottom\" svg:height=\"0.6cm\" report:z-index=\"1\" >" |
3086 | "<report:text-style fo:font-weight=\"bold\" fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"10\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"0%\" />" |
3087 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3088 | "</report:field>" |
3089 | "<report:label report:name=\"label18\" report:horizontal-align=\"left\" svg:x=\"0cm\" svg:width=\"13cm\" svg:y=\"0cm\" report:caption=\"%3\" report:vertical-align=\"center\" svg:height=\"0.4cm\" report:z-index=\"0\" >" |
3090 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3091 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3092 | "</report:label>" |
3093 | "<report:line report:name=\"line15\" svg:y1=\"1.2229cm\" svg:x1=\"0cm\" svg:y2=\"1.2229cm\" svg:x2=\"18.9715cm\" report:z-index=\"0\" >" |
3094 | "<report:line-style report:line-style=\"solid\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3095 | "</report:line>" |
3096 | "</report:section>" |
3097 | "<report:section svg:height=\"1.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"header-report\" >" |
3098 | "<report:label report:name=\"label17\" report:horizontal-align=\"left\" svg:x=\"0cm\" svg:width=\"18.97cm\" svg:y=\"0cm\" report:caption=\"%4\" report:vertical-align=\"center\" svg:height=\"1.25cm\" report:z-index=\"0\" >" |
3099 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"10\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3100 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3101 | "</report:label>" |
3102 | "</report:section>" |
3103 | "<report:section svg:height=\"2.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"footer-page-any\" >" |
3104 | "<report:field report:name=\"field10\" report:horizontal-align=\"right\" report:item-data-source=\"=constants.PageNumber()\" svg:x=\"6.75cm\" svg:width=\"0.75cm\" svg:y=\"0.25cm\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >" |
3105 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3106 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3107 | "</report:field>" |
3108 | "<report:field report:name=\"field11\" report:horizontal-align=\"left\" report:item-data-source=\"=constants.PageTotal()\" svg:x=\"8.25cm\" svg:width=\"3cm\" svg:y=\"0.25cm\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >" |
3109 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3110 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3111 | "</report:field>" |
3112 | "<report:label report:name=\"label12\" report:horizontal-align=\"center\" svg:x=\"7.5cm\" svg:width=\"0.75cm\" svg:y=\"0.25cm\" report:caption=\"%5\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >" |
3113 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3114 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3115 | "</report:label>" |
3116 | "<report:label report:name=\"label13\" report:horizontal-align=\"right\" svg:x=\"5.75cm\" svg:width=\"1cm\" svg:y=\"0.25cm\" report:caption=\"%6\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >" |
3117 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:font-style=\"italic\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3118 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3119 | "</report:label>" |
3120 | "<report:line report:name=\"line14\" svg:y1=\"0.2195cm\" svg:x1=\"0cm\" svg:y2=\"0.2195cm\" svg:x2=\"18.9715cm\" report:z-index=\"0\" >" |
3121 | "<report:line-style report:line-style=\"solid\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3122 | "</report:line>" |
3123 | "</report:section>" |
3124 | "<report:detail>" |
3125 | "<report:group report:group-sort=\"ascending\" report:group-column=\"Parent\" >" |
3126 | "<report:section svg:height=\"2.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"group-header\" >" |
3127 | "<report:label report:name=\"label6\" report:horizontal-align=\"left\" svg:x=\"0.5cm\" svg:width=\"3.75cm\" svg:y=\"1.75cm\" report:caption=\"%7\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >" |
3128 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3129 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3130 | "</report:label>" |
3131 | "<report:field report:name=\"field8\" report:horizontal-align=\"left\" report:item-data-source=\"Parent\" svg:x=\"0.5cm\" svg:width=\"8cm\" svg:y=\"1cm\" report:vertical-align=\"center\" svg:height=\"0.689cm\" report:z-index=\"0\" >" |
3132 | "<report:text-style fo:font-weight=\"bold\" fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3133 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3134 | "</report:field>" |
3135 | "<report:label report:name=\"label8\" report:horizontal-align=\"center\" svg:x=\"4.25cm\" svg:width=\"4.25cm\" svg:y=\"1.75cm\" report:caption=\"%8\" report:vertical-align=\"center\" svg:height=\"0.75cm\" report:z-index=\"0\" >" |
3136 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3137 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3138 | "</report:label>" |
3139 | "</report:section>" |
3140 | "</report:group>" |
3141 | "<report:section svg:height=\"0.50cm\" fo:background-color=\"#ffffff\" report:section-type=\"detail\" >" |
3142 | "<report:field report:name=\"field7\" report:horizontal-align=\"left\" report:item-data-source=\"NodeName\" svg:x=\"0.5cm\" svg:width=\"3.75cm\" svg:y=\"0cm\" report:vertical-align=\"center\" svg:height=\"0.5cm\" report:z-index=\"0\" >" |
3143 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3144 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3145 | "</report:field>" |
3146 | "<report:field report:name=\"field9\" report:horizontal-align=\"center\" report:item-data-source=\"NodeCompleted\" svg:x=\"4.25cm\" svg:width=\"4.25cm\" svg:y=\"0cm\" report:vertical-align=\"center\" svg:height=\"0.5cm\" report:z-index=\"0\" >" |
3147 | "<report:text-style fo:letter-spacing=\"0%\" style:letter-kerning=\"true\" fo:font-size=\"8\" fo:foreground-color=\"#000000\" fo:font-family=\"DejaVu Sans\" fo:background-color=\"#ffffff\" fo:background-opacity=\"100%\" />" |
3148 | "<report:line-style report:line-style=\"nopen\" report:line-weight=\"1\" report:line-color=\"#000000\" />" |
3149 | "</report:field>" |
3150 | "</report:section>" |
3151 | "</report:detail>" |
3152 | "</report:body>" |
3153 | "</report:content>" |
3154 | "</planreportdefinition>" ) |
3155 | .arg( |
3156 | i18n( "Report" ), |
3157 | i18nc( "Project manager" , "Manager:" ), |
3158 | i18n( "Project:" ), |
3159 | i18n( "Task Status Report" ), |
3160 | i18nc( "As in: Page 1 of 2" , "of" ), |
3161 | i18n( "Page" ), |
3162 | i18nc( "Task name" , "Name" ), |
3163 | i18nc( "Task completion" , "Completion (%)" ) |
3164 | ); |
3165 | return s; |
3166 | } |
3167 | |
3168 | //--------------------------------- |
3169 | PrintingControlPrivate::PrintingControlPrivate( PrintingDialog *job, QPrintDialog *dia ) |
3170 | : QObject( dia ), |
3171 | m_job( job ), |
3172 | m_dia( dia ) |
3173 | { |
3174 | connect(job, SIGNAL(changed()), SLOT(slotChanged())); |
3175 | } |
3176 | |
3177 | void PrintingControlPrivate::slotChanged() |
3178 | { |
3179 | if ( ! m_job || ! m_dia ) { |
3180 | return; |
3181 | } |
3182 | QSpinBox *to = m_dia->findChild<QSpinBox*>("to" ); |
3183 | QSpinBox *from = m_dia->findChild<QSpinBox*>("from" ); |
3184 | if ( to && from ) { |
3185 | from->setMinimum( m_job->documentFirstPage() ); |
3186 | from->setMaximum( m_job->documentLastPage() ); |
3187 | from->setValue( from->minimum() ); |
3188 | to->setMinimum( from->minimum() ); |
3189 | to->setMaximum( from->maximum() ); |
3190 | to->setValue( to->maximum() ); |
3191 | } |
3192 | } |
3193 | |
3194 | |
3195 | } //KPlato namespace |
3196 | |
3197 | #include "kptprintingcontrolprivate.moc" |
3198 | #include "kptview.moc" |
3199 | |