TDE
/
tdewebdev
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/tdewebdev
0
0
Fork 0
Code Issues Releases Wiki Activity

Fix incorrectly renamed strings

Browse Source
pull/1/head
Slávek Banko 10 years ago
parent e9638a300c
commit 69975e8e2c
2 changed files with 98 additions and 98 deletions
Show Stats Download Patch File Download Diff File

190
lib/compatibility/tdemdi/qextmdi/tdemdimainfrm.h
Unescape View File

@ -86,7 +86,7 @@ public:
* \ref KMdiChildView.
*
* \par General usage
*
*
* Your program mainwidget should inherit KMdiMainFrm. Then usually you'll just need
* addWindow() and removeWindowFromMdi() to control the views.
* \code
@ -108,14 +108,14 @@ public:
*
* KMdiMainFrm will provide the "Window" menu needed in common MDI applications. Just
* insert it in your main menu:
*
*
* \code
* if ( !isFakingSDIApplication() )
* {
* menuBar()->insertItem( i18n( "&Window" ), windowMenu() );
* }
* \endcode
*
*
* To synchronize the positions of the MDI control buttons inserted in your mainmenu:
* \code
* void B_MainModuleWidget::initMenuBar()
@ -129,15 +129,15 @@ public:
* setSysButtonsAtMenuPosition();
* }
* \endcode
*
*
* \par Dynamic mode switching
*
*
* Dynamic switching of the MDI mode can be done via the following functions:
* - switchToChildframeMode()
* - switchToToplevelMode()
* - switchToTabPageMode()
* - switchToIDEAlMode()
*
*
* The MDI mode can be gotten using mdiMode(). If you need to fake the look of an SDI application
* use fakeSDIApplication() to fake it and isFakingSDIApplication() to query whether or not an SDI
* interface is being faked.
@ -177,7 +177,7 @@ public:
* The maximized-Childframe mode means that currently all views are maximized in Childframe mode's application desktop.
*
* \par Managing views
*
*
* This class provides placing algorithms in Childframe mode. The following is a list of the window placement functions
* - tilePragma() - Tile the windows and allow them to overlap
* - tileAnodine() - Tile the windows but don't allow them to overlap
@ -198,7 +198,7 @@ public:
* Note: KMdiChildViews can be added in 2 meanings: Either as a normal child view (usually containing
* user document views) or as a tool-view (usually containing status, info or control widgets).
* The tool-views can be added as floating dockwidgets or as stay-on-top desktop windows in tool style.
*
*
* Also, pay attention to the fact that when you click on the close button of MDI views that their
* close event should be redirected to closeWindow(). Otherwise the mainframe class will
* not get noticed about the deleted view and a dangling pointer will remain in the MDI control. The
@ -210,19 +210,19 @@ public:
* \code
* m_mapOfMdiWidgets.insert( pWnd, mh );
* unsigned int mdiFlags = KMdi::StandardAdd;
*
*
* if ( !show )
* mdiFlags |= KMdi::Hide;
*
*
* if ( !attach )
* mdiFlags |= KMdi::Detach;
*
*
* if ( minimize )
* mdiFlags |= KMdi::Minimize;
*
*
* if ( bToolWindow)
* mdiFlags |= KMdi::ToolWindow;
*
*
* if ( m_pMdiMainFrm->isFakingSDIApplication() )
* {
* if ( attach ) //fake an SDI app
@ -241,7 +241,7 @@ class KMDI_EXPORT KMdiMainFrm : public KParts::DockMainWindow
friend class KMdiChildView;
friend class KMdiTaskBar;
Q_OBJECT
friend class KMdiToolViewAccessor;
// attributes
@ -312,17 +312,17 @@ public:
* Returns whether the application's MDI views are in maximized state or not.
*/
bool isInMaximizedChildFrmMode() { return m_bMaximizedChildFrmMode; }
/**
* Returns the MDI mode. This can be one of the enumerations KMdi::MdiMode.
*/
KMdi::MdiMode mdiMode() { return m_mdiMode; }
/**
* Returns the focused attached MDI view.
*/
KMdiChildView* activeWindow();
/**
* Returns a popup menu filled according to the MDI view state. You can override this
* method to insert additional entries there. The popup menu is usually popuped when the user
@ -331,29 +331,29 @@ public:
* menu called Operations.
*/
virtual TQPopupMenu * taskBarPopup( KMdiChildView *pWnd, bool bIncludeWindowPopup = false );
/**
* Returns a popup menu with only a title "Window". You can fill it with own operations entries
* on the MDI view. This popup menu is inserted as last menu item in taskBarPopup() .
*/
virtual TQPopupMenu * windowPopup( KMdiChildView *pWnd, bool bIncludeTaskbarPopup = true );
/**
* Called in the constructor (forces a resize of all MDI views)
*/
virtual void applyOptions();
/**
* Returns the KMdiChildView belonging to the given caption string.
*/
KMdiChildView * findWindow( const TQString& caption );
enum ExistsAs {DocumentView, ToolView, AnyView};
/**
* Returns whether this MDI child view is under MDI control (using addWindow() ) or not.
* Returns whether this MDI child view is under MDI control (using addWindow() ) or not.
*/
bool windowExists( KMdiChildView *pWnd, ExistsAs as );
/**
* Catches certain TQt events and processes it here.
* Currently, here this catches only the KMdiViewCloseEvent (a KMdi user event) which is sent
@ -367,12 +367,12 @@ public:
* This method calls TQMainWindow::event , additionally.
*/
virtual bool event( TQEvent* e );
/**
* If there's a main menubar given, it will create the 4 maximize mode buttons there (undock, minimize, restore, close).
*/
virtual void setSysButtonsAtMenuPosition();
/**
* Returns the height of the taskbar.
*/
@ -383,12 +383,12 @@ public:
* is visually moved on the desktop by this offset.
*/
virtual void setUndockPositioningOffset( TQPoint offset ) { m_undockPositioningOffset = offset; }
/**
* If you don't want to know about the inner structure of the KMdi system, you can use
* this iterator to handle with the MDI view list in a more abstract way.
* The iterator hides what special data structure is used in KMdi.
*/
*/
// FIXME And what exactly are we supposed to fix? -mattr
KMdiIterator<KMdiChildView*>* createIterator()
{
@ -401,7 +401,7 @@ public:
return new KMdiListIterator<KMdiChildView>( *m_pDocumentViews );
}
}
/**
* Deletes an KMdiIterator created in the KMdi library (needed for the windows dll problem).
*/
@ -409,40 +409,40 @@ public:
{
delete pIt;
}
/**
* Returns a popup menu that contains the MDI controlled view list.
* Additionally, this menu provides some placing actions for these views.
* Usually, you insert this popup menu in your main menubar as "Window" menu.
*/
TQPopupMenu* windowMenu() const { return m_pWindowMenu; };
/**
* Sets a background color for the MDI view area widget.
*/
virtual void setBackgroundColor( const TQColor &c ) { m_pMdi->setBackgroundColor( c ); }
/**
* Sets a background pixmap for the MDI view area widget.
*/
virtual void setBackgroundPixmap( const TQPixmap &pm ) { m_pMdi->setBackgroundPixmap( pm ); }
/**
* Sets a size that is used as the default size for a newly to the MDI system added KMdiChildView .
* By default this size is 600x400. So all non-resized added MDI views appear in that size.
*/
void setDefaultChildFrmSize( const TQSize& sz ) { m_pMdi->m_defaultChildFrmSize = sz; }
/**
* Returns the default size for a newly added KMdiChildView. See setDefaultChildFrmSize() .
*/
TQSize defaultChildFrmSize() { return m_pMdi->m_defaultChildFrmSize; }
/**
* Do nothing when in Toplevel mode
*/
virtual void setMinimumSize( int minw, int minh );
/**
* Returns the Childframe mode height of this. Makes only sense when in Toplevel mode.
*/
@ -459,7 +459,7 @@ public:
* @return the decoration of the window frame of docked (attached) MDI views
*/
static int frameDecorOfAttachedViews() { return m_frameDecoration; }
/**
* An SDI application user interface is faked:
* @li an opened view is always maximized
@ -467,26 +467,26 @@ public:
* @li taskbar and windowmenu are not created/updated
*/
void fakeSDIApplication();
/**
* @returns if we are faking an SDI application (fakeSDIApplication())
*/
bool isFakingSDIApplication() const { return m_bSDIApplication; }
virtual bool eventFilter( TQObject *obj, TQEvent *e );
void findRootDockWidgets( TQPtrList<KDockWidget>* pRootDockWidgetList, TQValueList<TQRect>* pPositionList );
/** We're switching something.*/
void setSwitching( const bool switching ) { m_bSwitching = switching; }
bool switching( void ) const { return m_bSwitching; }
public slots:
/**
/**
* addWindow demands a KMdiChildView. This method wraps every TQWidget in such an object and
* this way you can put every widget under MDI control.
*/
KMdiChildView* createWrapper( TQWidget *view, const TQString& name, const TQString& shortName );
/**
* Adds a KMdiChildView to the MDI system. The main frame takes control of it.
* \param flags the flags for the view such as:
@ -496,7 +496,7 @@ public slots:
* \li whether the view should be added as tool view (stay-on-top and toplevel) or added as document-type view.
*/
virtual void addWindow( KMdiChildView* pView, int flags = KMdi::StandardAdd );
//KDE4: merge the two methods
/**
* Adds a KMdiChildView to the MDI system. The main frame takes control of it.
@ -511,7 +511,7 @@ public slots:
* \since 3.3
*/
void addWindow( KMdiChildView* pView, int flags, int index );
/**
* Adds a KMdiChildView to the MDI system. The main frame takes control of it.
* \param pos move the child view to the specified position
@ -523,7 +523,7 @@ public slots:
* added as document-type view.
*/
virtual void addWindow( KMdiChildView* pView, TQPoint pos, int flags = KMdi::StandardAdd );
/**
* Adds a KMdiChildView to the MDI system. The main frame takes control of it.
* \param rectNormal Sets the geometry for this child view
@ -535,7 +535,7 @@ public slots:
* added as document-type view.
*/
virtual void addWindow( KMdiChildView* pView, TQRect rectNormal, int flags = KMdi::StandardAdd );
/**
* Usually called from addWindow() when adding a tool view window. It reparents the given widget
* as toplevel and stay-on-top on the application's main widget.
@ -543,92 +543,92 @@ public slots:
virtual KMdiToolViewAccessor *addToolWindow( TQWidget* pWnd, KDockWidget::DockPosition pos = KDockWidget::DockNone,
TQWidget* pTargetWnd = 0L, int percent = 50, const TQString& tabToolTip = 0,
const TQString& tabCaption = 0 );
virtual void deleteToolWindow( TQWidget* pWnd );
virtual void deleteToolWindow( KMdiToolViewAccessor *accessor );
/**
* Using this method you have to use the setWidget method of the access object, and it is very recommendet, that you use
* the widgetContainer() method for the parent of your newly created widget
*/
KMdiToolViewAccessor *createToolWindow();
/**
* Removes a KMdiChildView from the MDI system and from the main frame`s control.
* The caller is responsible for deleting the view. If the view is not deleted it will
* be reparented to 0
*/
virtual void removeWindowFromMdi( KMdiChildView *pWnd );
/**
* Removes a KMdiChildView from the MDI system and from the main frame`s control.
* Note: The view will be deleted!
*/
virtual void closeWindow( KMdiChildView *pWnd, bool layoutTaskBar = true );
/**
* Switches the KMdiTaskBar on and off.
*/
virtual void slot_toggleTaskBar();
/**
* Makes a main frame controlled undocked KMdiChildView docked.
* Doesn't work on KMdiChildView which aren't added to the MDI system.
* Use addWindow() for that.
*/
virtual void attachWindow( KMdiChildView *pWnd, bool bShow = true, bool bAutomaticResize = false );
/**
* Makes a docked KMdiChildView undocked.
* The view window still remains under the main frame's MDI control.
*/
virtual void detachWindow( KMdiChildView *pWnd, bool bShow = true );
/**
* Someone wants that the MDI view to be closed. This method sends a KMdiViewCloseEvent to itself
* to break the function call stack. See also event() .
*/
virtual void childWindowCloseRequest( KMdiChildView *pWnd );
/**
* Close all views
*/
virtual void closeAllViews();
/**
* Iconfiy all views
*/
virtual void iconifyAllViews();
/**
* Closes the view of the active (topchild) window
*/
virtual void closeActiveView();
/**
* Undocks all view windows (unix-like)
*/
virtual void switchToToplevelMode();
virtual void finishToplevelMode();
/**
* Docks all view windows (Windows-like)
*/
virtual void switchToChildframeMode();
virtual void finishChildframeMode();
/**
* Docks all view windows (Windows-like)
*/
virtual void switchToTabPageMode();
virtual void finishTabPageMode();
/**
* Docks all view windows. Toolviews use dockcontainers
*/
virtual void switchToIDEAlMode();
virtual void finishIDEAlMode( bool full = true );
/**
* Sets the appearance of the IDEAl mode. See KMultiTabBar styles for the first 3 bits.
* @deprecated use setToolviewStyle(int flags) instead
@ -645,17 +645,17 @@ public slots:
* @return if the view taskbar should be shown if there are MDI views
*/
bool isViewTaskBarOn();
/**
* Shows the view taskbar. This should be connected with your "View" menu.
*/
virtual void showViewTaskBar();
/**
* Hides the view taskbar. This should be connected with your "View" menu.
*/
virtual void hideViewTaskBar();
/**
* Update of the window menu contents.
*/
@ -665,68 +665,68 @@ public slots:
* Cascades the windows without resizing them.
*/
virtual void cascadeWindows() { m_pMdi->cascadeWindows(); }
/**
* Cascades the windows resizing them to the maximum available size.
*/
virtual void cascadeMaximized() { m_pMdi->cascadeMaximized(); }
/**
* Maximizes only in vertical direction.
*/
virtual void expandVertical() { m_pMdi->expandVertical(); }
/**
* Maximizes only in horizontal direction.
*/
virtual void expandHorizontal() { m_pMdi->expandHorizontal(); }
/**
* Tile Pragma
*/
virtual void tilePragma() { m_pMdi->tilePragma(); }
/**
* Tile Anodine
*/
virtual void tileAnodine() { m_pMdi->tileAnodine(); }
/**
* TileQt::Vertically
* Tile Vertically
*/
virtual void tileVertically() { m_pMdi->tileVertically(); }
/**
* Sets the decoration of the window frame of docked (attached) MDI views
* @deprecated Will be removed in KDE 4
*/
virtual void setFrameDecorOfAttachedViews( int frameDecor );
/**
* If in Childframe mode, we can switch between maximized or restored shown MDI views
*/
virtual void setEnableMaximizedChildFrmMode( bool bEnable );
/**
* Activates the next open view
*/
virtual void activateNextWin();
/**
* Activates the previous open view
*/
virtual void activatePrevWin();
/**
* Activates the view first viewed concerning to the access time.
*/
virtual void activateFirstWin();
/**
* Activates the view last viewed concerning to the access time.
*/
virtual void activateLastWin();
/**
* Activates the view with the tab page index (TabPage mode only)
*/
@ -740,17 +740,17 @@ private:
protected:
virtual void resizeEvent( TQResizeEvent * );
/**
* Creates a new MDI taskbar (showing the MDI views as taskbar entries) and shows it.
*/
virtual void createTaskBar();
/**
* Creates the MDI view area and connects some signals and slots with the KMdiMainFrm widget.
*/
virtual void createMdiManager();
/**
* prevents fillWindowMenu() from m_pWindowMenu->clear(). You have to care for it by yourself.
* This is useful if you want to add some actions in your overridden fillWindowMenu() method.
@ -764,10 +764,10 @@ protected:
/** Get tabwidget visibility */
KMdi::TabWidgetVisibility tabWidgetVisibility();
/** Set tabwidget visibility */
void setTabWidgetVisibility( KMdi::TabWidgetVisibility );
/** Returns the tabwidget used in IDEAl and Tabbed modes. Returns 0 in other modes. */
class KTabWidget * tabWidget() const;
@ -778,42 +778,42 @@ protected slots: // Protected slots
* the system buttons in the main menubar when in maximized (Maximize mode).
*/
virtual void activateView( KMdiChildView *pWnd );
/**
* Activates the MDI view (see activateView() ) and popups the taskBar popup menu (see taskBarPopup() ).
*/
virtual void taskbarButtonRightClicked( KMdiChildView *pWnd );
/**
* Turns the system buttons for maximize mode (SDI mode) off, and disconnects them
*/
void switchOffMaximizeModeForMenu( KMdiChildFrm* oldChild );
/**
* Reconnects the system buttons form maximize mode (SDI mode) with the new child frame
*/
void updateSysButtonConnections( KMdiChildFrm* oldChild, KMdiChildFrm* newChild );
/**
* Usually called when the user clicks an MDI view item in the "Window" menu.
*/
void windowMenuItemActivated( int id );
/**
* Usually called when the user clicks an MDI view item in the sub-popup menu "Docking" of the "Window" menu.
*/
void dockMenuItemActivated( int id );
/**
* Popups the "Window" menu. See also windowPopup() .
*/
void popupWindowMenu( TQPoint p );
/**
* The timer for main widget moving has elapsed -> send drag end to all concerned views.
*/
void dragEndTimeOut();
/**
* internally used to handle click on view close button (TabPage mode, only)
*/
@ -824,17 +824,17 @@ signals:
* Signals the last attached KMdiChildView has been closed
*/
void lastChildFrmClosed();
/**
* Signals the last KMdiChildView (that is under MDI control) has been closed
*/
void lastChildViewClosed();
/**
* Signals that the Toplevel mode has been left
*/
void leftTopLevelMode();
/**
* Signals that a child view has been detached (undocked to desktop)
*/
@ -842,10 +842,10 @@ signals:
/** Signals we need to collapse the overlapped containers */
void collapseOverlapContainers();
/** Signals the MDI mode has been changed */
void mdiModeHasBeenChangedTo( KMdi::MdiMode );
void viewActivated( KMdiChildView* );
void viewDeactivated( KMdiChildView* );

6
quanta/components/tableeditor/tableeditor.cpp
Unescape View File

@ -424,7 +424,7 @@ bool TableEditor::setTableArea( int bLine, int bCol, int eLine, int eCol, Parser
if ((uint)nCol >= mergeMatrix[0].size()) // Check if there are enough cols
for (uint i=0; i<mergeMatrix.size(); i++)
mergeMatrix[i].resize(2 * mergeMatrix[i].size());
} else
{
tableNode.node = new Node(0L);
@ -1271,7 +1271,7 @@ void TableEditor::configureCell(int row, int col, Node * node)
return;
// Header (TH) or standard cell?
item->setHeader(node->tag->name.lower() == "th");
//Qt::Horizontal alignment
// Horizontal alignment
TQt::AlignmentFlags flags;
TQString align = node->tag->attributeValue("align", true);
if (align == "right")
@ -1285,7 +1285,7 @@ void TableEditor::configureCell(int row, int col, Node * node)
else
flags = TQt::AlignLeft;
item->setAlignment(flags);
//Qt::Vertical alignment
// Vertical alignment
TQString valign = node->tag->attributeValue("valign", true);
if (valign == "top")
flags = TQt::AlignTop;

Write Preview
Loading…
Cancel
Save