You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1746 lines
58 KiB
1746 lines
58 KiB
//=============================================================================
|
|
//
|
|
// File : class_widget.cpp
|
|
// Creation date : Mon Sep 11 16:35:32 CET 2000 by Krzysztof Godlewski
|
|
//
|
|
// This file is part of the KVirc irc client distribution
|
|
// Copyright (C) 1999-2005 Szymon Stefanek (pragma at kvirc dot net)
|
|
//
|
|
// This program is FREE software. You can redistribute it and/or
|
|
// modify it under the terms of the GNU General Public License
|
|
// as published by the Free Software Foundation; either version 2
|
|
// of the License, or (at your opinion) any later version.
|
|
//
|
|
// This program is distributed in the HOPE that it will be USEFUL,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
// See the GNU General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU General Public License
|
|
// along with this program. If not, write to the Free Software Foundation,
|
|
// Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "kvi_malloc.h"
|
|
#include "kvi_debug.h"
|
|
|
|
#include "kvi_error.h"
|
|
#include "kvi_locale.h"
|
|
#include "kvi_iconmanager.h"
|
|
#include "kvi_window.h"
|
|
#include "kvi_out.h"
|
|
#include "kvi_mirccntrl.h"
|
|
#include "kvi_app.h"
|
|
#include "kvi_string.h"
|
|
#include <tqcursor.h>
|
|
#include <tqiconset.h>
|
|
#include <tqcolor.h>
|
|
#include <tqlayout.h>
|
|
#include <tqbitmap.h>
|
|
#include <tqmetaobject.h>
|
|
#include "class_widget.h"
|
|
#include "class_pixmap.h"
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
#include <TQKeyEvent>
|
|
#include <TQDesktopWidget>
|
|
#else
|
|
#include <tqwidgetlist.h>
|
|
#endif
|
|
|
|
#include <tqwidget.h>
|
|
#include <tqtooltip.h>
|
|
#include <tqfont.h>
|
|
#include <tqvariant.h>
|
|
|
|
// FIX ME: WFLAGS
|
|
const char * const widgettypes_tbl[] = {
|
|
"TopLevel",
|
|
"Dialog",
|
|
"Popup",
|
|
"Desktop",
|
|
"Customize",
|
|
"Title",
|
|
"StaysOnTop",
|
|
"SysMenu",
|
|
"Minimize",
|
|
"Maximize",
|
|
"NoAutoErase"
|
|
};
|
|
#ifdef COMPILE_USE_QT4
|
|
const TQt::WidgetAttribute widgetattributes_cod[]= {
|
|
TQt::WA_OpaquePaintEvent,
|
|
TQt::WA_NoSystemBackground,
|
|
TQt::WA_PaintOnScreen,
|
|
TQt::WA_NoMousePropagation,
|
|
};
|
|
|
|
const char * const widgetattributes_tbl[] = {
|
|
"opaquePaintEvent",
|
|
"noSystemBackground",
|
|
"paintOnScreen",
|
|
"noMousePropagation",
|
|
};
|
|
#define widgetattributes_num (sizeof(widgetattributes_tbl) / sizeof(widgetattributes_tbl[0]))
|
|
|
|
|
|
const TQt::WindowType widgettypes_cod[] = {
|
|
#else
|
|
const int widgettypes_cod[] = {
|
|
#endif
|
|
TQt::WType_TopLevel,
|
|
TQt::WType_Dialog,
|
|
TQt::WType_Popup,
|
|
TQt::WType_Desktop,
|
|
TQt::WStyle_Customize,
|
|
TQt::WStyle_Title,
|
|
TQt::WStyle_StaysOnTop,
|
|
TQt::WStyle_SysMenu,
|
|
TQt::WStyle_Minimize,
|
|
TQt::WStyle_Maximize,
|
|
TQt::WNoAutoErase
|
|
};
|
|
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
|
|
#define TQT_WIDGET_TABFOCUS TQ_TabFocus
|
|
#define TQT_WIDGET_CLICKFOCUS TQ_ClickFocus
|
|
#define TQT_WIDGET_STRONGFOCUS TQ_StrongFocus
|
|
#define TQT_WIDGET_NOFOCUS TQ_NoFocus
|
|
|
|
#else
|
|
#define TQT_WIDGET_TABFOCUS TQ_TabFocus
|
|
#define TQT_WIDGET_CLICKFOCUS TQ_ClickFocus
|
|
#define TQT_WIDGET_STRONGFOCUS TQ_StrongFocus
|
|
#define TQT_WIDGET_NOFOCUS TQ_NoFocus
|
|
#endif
|
|
|
|
|
|
#define widgettypes_num (sizeof(widgettypes_tbl) / sizeof(widgettypes_tbl[0]))
|
|
|
|
/*
|
|
@doc: widget
|
|
@keyterms:
|
|
widget object class
|
|
@title:
|
|
widget class
|
|
@type:
|
|
class
|
|
@short:
|
|
Base class for all widgets
|
|
@inherits:
|
|
[class]object[/class]
|
|
@description:
|
|
This object class is the rappresentation of a widget.
|
|
All the other widget-type classes inherit from this one.
|
|
@functions:
|
|
!fn: $show()
|
|
Shows this widget and the children.
|
|
See also [classfnc]$hide[/classfnc]() and [classfnc]$isVisible[/classfnc].
|
|
!fn: $hide()
|
|
Hides this widget (and conseguently all the children).
|
|
See also [classfnc]$show[/classfnc]() and [classfnc]$isVisible[/classfnc].
|
|
!fn: $repaint(<bool erase>)
|
|
Repaints the widget directly by calling [classfnc]$paintEvent[/classfnc]() immediately.[br]
|
|
If erase is TRUE, erases the widget before the $paintEvent() call.
|
|
!fn: $x()
|
|
Returns the x coordinate of the upper-left corner
|
|
of this widget relative to the parent widget,
|
|
or to the desktop if this widget is a toplevel one.
|
|
!fn: $y()
|
|
Returns the y coordinate of the uspper-left corner
|
|
of this widget relative to the parent widget,
|
|
or to the desktop if this widget is a toplevel one.
|
|
!fn: $width()
|
|
Returns the width of this widget in pixels.
|
|
!fn: $height()
|
|
Returns the height of this widget in pixels.
|
|
!fn: $geometry()
|
|
Returns the widget geometry in this form:[br]
|
|
x, y, width, height.
|
|
!fn: $setGeometry(<x_or_array>,[<y>,<width>,<height>])
|
|
Sets the geometry of this widget. <x> and <y> are relative
|
|
to the parent widget or to the desktop (if this widget is
|
|
a toplevel one). All the parameters are in pixels.
|
|
!fn: $setMinimumWidth(<value>)
|
|
Sets the minimum width of this widget to <value>.
|
|
The user will not be able to resize the widget to a smaller
|
|
value. This value is also used by the [class:layout]layout class[/class].
|
|
!fn: $setMinimumHeight(<value>)
|
|
Sets the minimum height of this widget to <value>.
|
|
The user will not be able to resize the widget to a smaller
|
|
value. This value is also used by the [class:layout]layout class[/class].
|
|
!fn: $setMaximumWidth(<value>)
|
|
Sets the maximum width of this widget to <value>.
|
|
The user will not be able to resize the widget to a bigger
|
|
value. This value is also used by the [class:layout]layout class[/class].
|
|
!fn: $setMaximumHeight(<value>)
|
|
Sets the maximum height of this widget to <value>.
|
|
The user will not be able to resize the widget to a bigger
|
|
value. This value is also used by the [class:layout]layout class[/class].
|
|
!fn: $move(<x_or_array>[,<y>])
|
|
Moves this widget to the coordinate <x> and <y> relative to its
|
|
parent widget (or the desktop if this widget is a toplevel one).
|
|
This is equivalent to [classfnc]$setGeometry[/classfnc](<x>,<y>,
|
|
[classfnc]$width[/classfnc](),[classfnc]$height[/classfnc]()).
|
|
!fn: $resize(<w_or_array>,[height])
|
|
Changes the widget's width to <width> and height to <height>.
|
|
See also [classfnc]$setGeometry[/classfnc]().
|
|
!fn: $isEnabled()
|
|
Returns '1' if the widget is enabled , '0' otherwise.
|
|
See also [classfnc:widget]$setEnabled[/classfnc]().
|
|
!fn: $setEnabled(<bool>)
|
|
Sets the widget state to enabled or disabled if <bool> is 1 or 0 respectively.
|
|
A disabled widget does not receive keyboard nor mouse input.
|
|
!fn: $setCaption(<text>)
|
|
Sets the caption of this widget to <text>.
|
|
This is meaningful for toplevel widgets only.
|
|
!fn: $setToolTip(<tooltip_text>)
|
|
Set the tooltip of this widget; the text can contain HTML formatting.
|
|
!fn: $window.caption()
|
|
Returns the caption text of this widget.
|
|
!fn: $isTopLevel()
|
|
Returns '1' if this widget is a toplevel (parentless) one,
|
|
'0' otherwise.
|
|
!fn: $isVisible()
|
|
Returns '1' if this widget is currently visible (read: is managed
|
|
by the window manager and displayed by the X server; the widget
|
|
may be hidden behind other widgets). If the widget is not visible
|
|
this function returns '0'.
|
|
See also [classfnc]$show[/classfnc]() and [classfnc]$hide[/classfnc]().
|
|
!fn: $raise()
|
|
Moves this widget to the top of the stack of the widgets relative
|
|
to its parent. See also [classfnc]$lower[/classfnc].
|
|
!fn: $lower()
|
|
Moves this widget to the bottom of the stack of the widgets relative
|
|
to its parent. See also [classfnc]$raise[/classfnc]
|
|
!fn: $hasFocus()
|
|
Returns '1' if this widget has the keyboard focus.
|
|
See also [classfnc]$setFocus[/classfnc].
|
|
!fn: $setFocus()
|
|
Sets this widget to be the one that receives keyboard events.
|
|
See also [classfnc]$hasFocus[/classfnc]
|
|
!fn: $parentWidget()
|
|
Returns the object id of the parent widget, or '0' if this
|
|
widget is a toplevel one.
|
|
!fn: $backgroundColor()
|
|
Returns the background color of this widget in hexadecimal
|
|
html-like format. For example , for a black bacground you will get
|
|
the string "000000" , for a red one , "FF0000", for a white one
|
|
"FFFFFF". See also [classfnc]$setBackgroundColor[/classfnc]()
|
|
!fn: $setBackgroundColor(<rgb(hex string)_array(red:integer,green:integer,blue_integer)_or_red>,[geen:integer],[blue:integer])
|
|
Sets the background color of this widget to <rgb_value>:valid values are:
|
|
- hex string: must be a string with 6 hexadecimal digits (like the ones used to
|
|
specify colors in html pages). The first two digits specify
|
|
the RED component, the third and fourth digit specify the GREEN component
|
|
and the last two specify the BLUE component.
|
|
For example "FFFF00" means full red, full green and no blue that gives
|
|
a yellow color, "808000" designates a brown color (dark yellow),
|
|
"A000A0" is a kind of violet.
|
|
- array(red:integer,green:integer,blue:integer)
|
|
- red:integer,green:integer,blue:integer.
|
|
See also [classfnc]$foregroundColor[/classfnc].
|
|
!fn: $setForegroundColor(<rgb(hex string)_array(red:integer,green:integer,blue_integer)_or_red>,[geen:integer],[blue:integer])
|
|
Sets the foreground color of this widget to <rgb_value>:valid values are:
|
|
- hex string: must be a string with 6 hexadecimal digits (like the ones used to
|
|
specify colors in html pages). The first two digits specify
|
|
the RED component, the third and fourth digit specify the GREEN component
|
|
and the last two specify the BLUE component.
|
|
For example "FFFF00" means full red, full green and no blue that gives
|
|
a yellow color, "808000" designates a brown color (dark yellow),
|
|
"A000A0" is a kind of violet.
|
|
- array(red:integer,green:integer,blue:integer)
|
|
- red:integer,green:integer,blue:integer.
|
|
See also [classfnc]$foregroundColor[/classfnc].
|
|
!fn: $foregroundColor()
|
|
Returns the foreground color of this widget in hexadecimal
|
|
html-like format.
|
|
See also [classfnc]$setForegroundColor[/classfnc].
|
|
!fn: $setMouseTracking(<bool>)
|
|
Enables or disables the mouse tracking if <bool> is '1' or '0' respectively.
|
|
When mouse tracking is enabled you will receive mouse move events
|
|
even if no button is pressed, otherwise you will receive it only
|
|
when a mouse button is being pressed (so after a mousePressEvent).
|
|
!fn: $mousePressEvent(<button>,<x>,<y>)
|
|
This function is called when a mouse button is pressed while
|
|
the cursor is in this widget. <button> is 0 if the pressed button
|
|
is the left one, 1 if the button is the right one and 2 if it is the middle one.
|
|
The <x> and <y> coordinates are relative to this widget upper-left corner
|
|
and are expressed in pixels.
|
|
If you call "[cmd]setreturn[/cmd] 1" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $mouseReleaseEvent(<button>,<x>,<y>)
|
|
This function is called when a mouse button is released while
|
|
the cursor is in this widget. <button> is 0 if the released button
|
|
is the left one, 1 if the button is the right one and 2 if it is the middle one.
|
|
The <x> and <y> coordinates are relative to this widget upper-left corner
|
|
and are expressed in pixels.
|
|
If you call "[cmd]setreturn[/cmd] 1" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $mouseDoubleClickEvent(<button>,<x>,<y>)
|
|
This function is called when a mouse button is double clicked while
|
|
the cursor is in this widget. <button> is 0 if the double clicked button
|
|
is the left one, 1 if the button is the right one and 2 if it is the middle one.
|
|
The <x> and <y> coordinates are relative to this widget upper-left corner
|
|
and are expressed in pixels.
|
|
If you call "[cmd]setreturn[/cmd] 1" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $mouseMoveEvent(<button>,<x>,<y>)
|
|
This function is called when the mouse cursor moves inside this widget.
|
|
<button> is 0 if the pressed button
|
|
is the left one, 1 if the button is the right one and 2 if it is the middle one.
|
|
The special value of -1 indicates that no button is being pressed.
|
|
The <x> and <y> coordinates are relative to this widget upper-left corner
|
|
and are expressed in pixels.
|
|
Normally you will receive this event only if a mouse button is being pressed
|
|
while moving. If you want to receive it also when the mouse buttons are not
|
|
pressed, call [classfnc]$setMouseTracking[/classfnc]().
|
|
If you call "[cmd]return[/cmd]$true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $focusInEvent()
|
|
This function is called when this widget gains keyboard focus.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $focusOutEvent()
|
|
This function is called when this widget looses keyboard focus.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $mouseLeaveEvent()
|
|
This function is called when the mouse leaves this widget.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $mouseEnterEvent()
|
|
This function is called when the mouse enters this widget.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $showEvent()
|
|
This function is called when this widget is being shown.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $hideEvent()
|
|
This function is called when this widget is being hidden.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $closeEvent()
|
|
This function is called when this widget is going to be closed.
|
|
If you call "[cmd]return[/cmd] $true" you will ignore the close event.
|
|
The default implementation does nothing.
|
|
!fn: $resizeEvent()
|
|
This function is called immediately after this widget has been resized.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: $moveEvent()
|
|
This function is called immediately after this widget has been moved.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event. The default implementation does nothing.
|
|
!fn: <tip:string> $maybeTipEvent(<x_tip_pos:integer>,<y_tip_pos:integer>)[QT4 only]
|
|
This event handler is called when a eventualy tip is going to be show.
|
|
You can be reimplement this event and set a dynamic tool tip by using "[cmd]return[/cmd] <tooltip_string>".
|
|
If a tooltip has setted with [classfnc]$setTooltip[/classfnc] the dynamic tooltip will be ignored.
|
|
The default implementation does nothing.
|
|
!fn: $paintEvent()
|
|
This event handler can be reimplemented to repaint all or part of the widget.
|
|
It's needed by the Painter class.
|
|
It's very useful for drawing flicker free animations or low level special graphic effects.
|
|
If you call "[cmd]return[/cmd] $true" you will stop the internal processing
|
|
of this event.
|
|
The default implementation does nothing.
|
|
!fn: $setIcon(<image_id>)
|
|
Sets the icon for this widget. This is meaningful only for toplevel widgets.
|
|
See the [doc:image_id]image identifier[/doc] documentation for the explaination
|
|
of the <image_id> parameter.
|
|
!fn: $setBackgroundImage(<image_id>)
|
|
Sets the background image for this widget.
|
|
See the [doc:image_id]image identifier[/doc] documentation for the explaination
|
|
of the <image_id> parameter.
|
|
For some kind of widgets, setting a background pixmap may have no effect or
|
|
have strange results. Experiment with it.
|
|
To unset the background image call [classfnc]$setBackgroundColor[/classfnc]
|
|
!fn: $setFont(<size>,<family>,<style>)[br]
|
|
Set the font's size, family and stile, valid flag for style are:[br]
|
|
[pre]
|
|
italic [br]
|
|
bold [br]
|
|
underline [br]
|
|
overline [br]
|
|
strikeout [br]
|
|
fixedpitch [br]
|
|
[/pre]
|
|
!fn: $setWFlags(<flag1>, <flag2>, ...)
|
|
This function sets widget flags, given as parameters.
|
|
Valid flags are:
|
|
[pre]
|
|
TopLevel - indicates that this widget is a top-level widget[br]
|
|
Dialog - indicates that this widget is a top-level window that should be decorated as a dialog[br]
|
|
Desktop - indicates that this widget is the desktop[br]
|
|
Popup - indicates that this widget is a popup top-level window[br]
|
|
NoAutoErase - indicates that this widget paints all its pixels. Updating, resizing, scrolling and focus changes should therefore not erase the widget.
|
|
Customize - let's the user to customize the style of the widget.[br]
|
|
[br]
|
|
Valid parameter for a customized widget are:[br]
|
|
Title - gives the window a title bar[br]
|
|
StaysOnTop - window stays on top [br]
|
|
SysMenu - add a windows system menu[br]
|
|
Minimize - add a minimize button for the sysmenu style[br]
|
|
Maximize - add a maximixe button for the sysmenu style[br]
|
|
[/pre]
|
|
!fn: $centerToScreen()
|
|
Centers the window on the screen (useful only for toplevel widgets).[br]
|
|
The best place to call this function is in $showEvent()
|
|
!fn: $setFocusPolicy(<key focus>)
|
|
Sets the way the widget accepts keyboard focus.[br]
|
|
Valid parameters are:
|
|
[pre]
|
|
- TabFocus; (widget accepts keyboard focus by tabbing)[br]
|
|
- ClickFocus; (widget accepts keyboard focus by clicking)[br]
|
|
- StrongFocus; (widget accepts both tabbing/clicking)[br]
|
|
- No Focus; (widget does not accept focus at all; this is the default value)[br]
|
|
[/pre]
|
|
!fn: $keyPressEvent(<key>)
|
|
If widget accepts keyboard focus (see [classfnc]$setFocusPolicy[/classfnc] ) this function handles for keys;
|
|
In its argument the key pressed.[br]
|
|
Special keys are:
|
|
[pre]
|
|
- Return [br]
|
|
- Enter [br]
|
|
- Down (cursor arrow down) [br]
|
|
- Up (cursor arrow up) [br]
|
|
- Left (cursor arrow left) [br]
|
|
- Right (cursor arrow right) [br]
|
|
- Shift [br]
|
|
- Ctrl [br]
|
|
- Alt [br]
|
|
- CapsLock [br]
|
|
- Backspace [br]
|
|
- Del [br]
|
|
- Esc [br]
|
|
- 0 [br]
|
|
- 1 [br]
|
|
- 2 [br]
|
|
- 3 [br]
|
|
- 4 [br]
|
|
- 5 [br]
|
|
- 6 [br]
|
|
- 7 [br]
|
|
- 8 [br]
|
|
- 9 [br]
|
|
- + [br]
|
|
- - [br]
|
|
- * [br]
|
|
- / [br]
|
|
- ( [br]
|
|
- ) [br]
|
|
- = [br]
|
|
- . [br]
|
|
- ^ [br]
|
|
|
|
[/pre]
|
|
!fn: $mapFromGlobal(<x>,<y>)
|
|
Translates the global screen coordinate pos to widget coordinates.
|
|
!fn: $mapToGlobal(<x>,<y>)
|
|
Translates widget coordinates into the global screen coordinate pos.
|
|
!fn: integer $globalCursorX()
|
|
Return the x coordinate of mouse pointer global position.
|
|
!fn: integer $globalCursorY()
|
|
Return the y coordinate of the mo>use pointer global position.
|
|
@examples:
|
|
[example]
|
|
%Widget = $new(widget)
|
|
# This is the main container for other elements.
|
|
|
|
%Widget->$setCaption("This is the widget title")
|
|
|
|
%Widget->$setGeometry(100,200,170,290)
|
|
# 100 and 200 are distance (pixel) from the left and the top of father widget (in this case the KVIrc window)
|
|
# 300 and 400 are the weight and the height of the widget
|
|
|
|
%Widget->%label = $new(label,%Widget)
|
|
%Widget->%label->$setText("This is a text label")
|
|
%Widget->%label->$setGeometry(10,10,150,20)
|
|
|
|
%Widget->%lineedit = $new(lineedit,%Widget)
|
|
%Widget->%lineedit->$setText("This is a lineedit")
|
|
%Widget->%lineedit->$setGeometry(10,40,150,20)
|
|
|
|
%Widget->%multilineedit = $new(multilineedit,%Widget)
|
|
%Widget->%multilineedit->$setText("This is a multilineedit")
|
|
%Widget->%multilineedit->$setGeometry(10,70,150,40)
|
|
|
|
%Widget->%checkbox = $new(checkbox,%Widget)
|
|
%Widget->%checkbox->$setText("This is a checkbox")
|
|
%Widget->%checkbox->$setGeometry(10,120,150,20)
|
|
|
|
%Widget->%combobox = $new(combobox,%Widget)
|
|
%Widget->%combobox->$setGeometry(10,150,150,20)
|
|
%Widget->%combobox->$insertItem("This is a combobox")
|
|
%Widget->%combobox->$insertItem("This is a combobox's item")
|
|
|
|
%Widget->%listbox = $new(listbox,%Widget)
|
|
%Widget->%listbox->$setGeometry(10,180,150,40)
|
|
%Widget->%listbox->$insertItem("This is another item")
|
|
%Widget->%listbox->$insertItem("This is a listbox's item")
|
|
%Widget->%listbox->$insertItem("This is a listbox")
|
|
|
|
%Widget->%radiobutton = $new(radiobutton,%Widget)
|
|
%Widget->%radiobutton->$setGeometry(10,230,150,20)
|
|
%Widget->%radiobutton->$setText("This is a radiobutton")
|
|
|
|
%Widget->%button = $new(button, %Widget)
|
|
%Widget->%button->$setText("Close me")
|
|
%Widget->%button->$setGeometry(10,260,150,20)
|
|
|
|
%Widget->$show()
|
|
# This shows the widget
|
|
|
|
privateimpl(%Widget->%button, mousePressEvent) {
|
|
delete %Widget
|
|
# This closes the widget automatically
|
|
}
|
|
# privateimpl is triggered when user press the button.
|
|
# To do that, widget must be a global variable.
|
|
[/example]
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
//
|
|
// If you never call c->error() , c->warning() (your function never fails)
|
|
// and never call a function that can call c->error() or c->warning()
|
|
// you can avoid ENTER_STACK_FRAME and c->leaveStackFrame()
|
|
// Just return true.
|
|
// c->error() should be called only in really critical situations
|
|
// (we have to define better "critical situation")
|
|
// if possible , leave the things go after just a c->warning()
|
|
//
|
|
|
|
// widget() will be never 0 in THIS class
|
|
// but in derived classes WILL be
|
|
// ... now that I think about it , it
|
|
// may happen that widget() will be zero here too:
|
|
// If the TQt "physical" widget gets destroyed
|
|
// by some external factor (for example when children
|
|
// of a wrapper widget destroyed by KVIrc).
|
|
//
|
|
// as a convention:
|
|
// if widget() can be 0 in a class
|
|
// the user must have a function to check it
|
|
// (sth as object::$hasObject() could do the trick)
|
|
// obviously this will happen only in well defined cases
|
|
// as in a qtwrapper not yet wrapped or failed to wrap (so
|
|
// qtwrapper::$wrap() returned '0' for example)
|
|
// or after the widget has been destroyed...
|
|
// if widget() is 0 , the functions perform no actions
|
|
// return no errors and results that have to be assumed
|
|
// as invalid (this allows the minimum overhead: if widget()
|
|
|
|
//=============================================================================================================
|
|
|
|
|
|
|
|
KVSO_BEGIN_REGISTERCLASS(KviKvsObject_widget,"widget","object")
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"reparent",function_reparent)
|
|
// apparence
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"show",function_show)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"hide",function_hide)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"repaint",function_repaint)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"isTopLevel",function_isTopLevel)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"isVisible",function_isVisible)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"raise",function_raise)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"lower",function_lower)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setEnabled",function_setEnabled)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"isEnabled",function_isEnabled)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setMouseTracking",function_setMouseTracking)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setCaption",function_setCaption)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"caption",function_caption)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"hasFocus",function_hasFocus)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setFocus",function_setFocus)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setToolTip",function_setToolTip)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setWFlags",function_setWFlags)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setIcon",function_setIcon)
|
|
// fonts
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"fontDescent",function_fontDescent)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"fontAscent",function_fontAscent)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"fontMetricsWidth",function_fontMetricsWidth)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"fontMetricsHeight",function_fontMetricsHeight)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setFont",function_setFont)
|
|
// geometry
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"screenResolution",function_screenResolution)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"centerToScreen",function_centerToScreen)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"geometry",function_geometry)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setGeometry",function_setGeometry)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"mapToGlobal",function_mapToGlobal)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"mapFromGlobal",function_mapFromGlobal)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"y",function_y)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"x",function_x)
|
|
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"globalCursorX",function_globalCursorX)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"globalCursorY",function_globalCursorY)
|
|
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"width",function_width)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"height",function_height)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setMinimumWidth",function_setMinimumWidth)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setMinimumHeight",function_setMinimumHeight)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setMaximumWidth",function_setMaximumWidth)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setMaximumHeight",function_setMaximumHeight)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"move",function_move)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"sizeHint",function_sizeHint)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"resize",function_resize)
|
|
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setFocusPolicy",function_setFocusPolicy)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"addWidgetToWrappedLayout",function_addWidgetToWrappedLayout)
|
|
|
|
// colors and image
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setForegroundColor",function_setPaletteForeground)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setBackgroundColor",function_setBackgroundColor)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setBackgroundImage",function_setBackgroundImage)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"backgroundColor",function_backgroundColor)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"foregroundColor",function_foregroundColor)
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setMask",function_setMask)
|
|
|
|
// QT4 only
|
|
#ifdef COMPILE_USE_QT4
|
|
KVSO_REGISTER_HANDLER(KviKvsObject_widget,"setAttribute",function_setAttribute)
|
|
#endif
|
|
|
|
// events
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"mousePressEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"mouseReleaseEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"mouseDoubleClickEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"mouseMoveEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"focusInEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"focusOutEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"mouseLeaveEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"mouseEnterEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"showEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"hideEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"closeEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"resizeEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"moveEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"paintEvent")
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"keyPressEvent")
|
|
#ifdef COMPILE_USE_QT4
|
|
KVSO_REGISTER_STANDARD_NOTHINGRETURN_HANDLER(KviKvsObject_widget,"maybeTipEvent")
|
|
#endif
|
|
|
|
|
|
KVSO_END_REGISTERCLASS(KviKvsObject_widget)
|
|
|
|
|
|
KVSO_BEGIN_CONSTRUCTOR(KviKvsObject_widget,KviKvsObject)
|
|
KVSO_END_CONSTRUCTOR(KviKvsObject_widget)
|
|
|
|
KVSO_BEGIN_DESTRUCTOR(KviKvsObject_widget)
|
|
emit aboutToDie();
|
|
KVSO_END_CONSTRUCTOR(KviKvsObject_widget)
|
|
|
|
bool KviKvsObject_widget::init(KviKvsRunTimeContext * pContext,KviKvsVariantList * pParams)
|
|
{
|
|
setObject(TQT_TQOBJECT(new TQWidget(parentScriptWidget(),getName())),true);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::eventFilter(TQObject *o,TQEvent *e)
|
|
{
|
|
if(o == object())
|
|
{
|
|
bool ret=false;
|
|
int aparam;
|
|
bool brokenhandler=false;
|
|
KviKvsVariant *retv=new KviKvsVariant(ret);
|
|
|
|
switch(e->type())
|
|
{
|
|
#ifdef COMPILE_USE_QT4
|
|
case TQEvent::ToolTip:
|
|
{
|
|
TQHelpEvent *helpEvent = static_cast<TQHelpEvent *>(e);
|
|
TQPoint point=helpEvent->pos();
|
|
TQString szTooltip;
|
|
KviKvsVariant *tipret=new KviKvsVariant(szTooltip);
|
|
KviKvsVariantList params(new KviKvsVariant((kvs_int_t)point.x()),new KviKvsVariant((kvs_int_t)point.y()));
|
|
callFunction(this,"maybeTipEvent",tipret,¶ms);
|
|
tipret->asString(szTooltip);
|
|
TQToolTip::showText(helpEvent->globalPos(),szTooltip);
|
|
break;
|
|
}
|
|
#endif
|
|
case TQEvent::Paint:
|
|
{
|
|
TQRect rect=((TQPaintEvent *)e)->rect();
|
|
KviKvsVariantList params(new KviKvsVariant((kvs_int_t)rect.x()),new KviKvsVariant((kvs_int_t)rect.y()),new KviKvsVariant((kvs_int_t)rect.width()),new KviKvsVariant((kvs_int_t)rect.height()));
|
|
callFunction(this,"paintEvent",retv,¶ms);
|
|
break;
|
|
}
|
|
|
|
case TQEvent::KeyPress:
|
|
{
|
|
TQString tmp="";
|
|
switch(((TQKeyEvent *)e)->key())
|
|
{
|
|
case TQt::Key_Return:
|
|
tmp="Return";
|
|
break;
|
|
case TQt::Key_Down:
|
|
tmp="Down";
|
|
break;
|
|
case TQt::Key_Up:
|
|
tmp="Up";
|
|
break;
|
|
case TQt::Key_Left:
|
|
tmp="Left";
|
|
break;
|
|
case TQt::Key_Right:
|
|
tmp="Right";
|
|
break;
|
|
case TQt::Key_Shift:
|
|
tmp="Shift";
|
|
break;
|
|
case TQt::Key_Control:
|
|
tmp="Ctrl";
|
|
break;
|
|
case TQt::Key_Alt:
|
|
tmp="Alt";
|
|
break;
|
|
case TQt::Key_CapsLock:
|
|
tmp="CapsLock";
|
|
break;
|
|
case TQt::Key_Backspace:
|
|
tmp="Backspace";
|
|
break;
|
|
case TQt::Key_Delete:
|
|
tmp="Del";
|
|
break;
|
|
|
|
case TQt::Key_Enter:
|
|
tmp="Enter";
|
|
break;
|
|
case TQt::Key_Escape:
|
|
tmp="Esc";
|
|
break;
|
|
case TQt::Key_0:
|
|
tmp="0";
|
|
case TQt::Key_1:
|
|
tmp="1";
|
|
break;
|
|
case TQt::Key_2:
|
|
tmp="2";
|
|
break;
|
|
case TQt::Key_3:
|
|
tmp="3";
|
|
break;
|
|
case TQt::Key_4:
|
|
tmp="4";
|
|
break;
|
|
case TQt::Key_5:
|
|
tmp="5";
|
|
break;
|
|
case TQt::Key_6:
|
|
tmp="6";
|
|
break;
|
|
case TQt::Key_7:
|
|
tmp="7";
|
|
break;
|
|
case TQt::Key_8:
|
|
tmp="8";
|
|
break;
|
|
case TQt::Key_9:
|
|
tmp="9";
|
|
break;
|
|
case TQt::Key_Plus:
|
|
tmp="+";
|
|
break;
|
|
case TQt::Key_Minus:
|
|
tmp="-";
|
|
break;
|
|
case TQt::Key_Slash:
|
|
tmp="/";
|
|
break;
|
|
case TQt::Key_Asterisk:
|
|
tmp="*";
|
|
break;
|
|
case TQt::Key_Period:
|
|
tmp=".";
|
|
break;
|
|
case TQt::Key_ParenLeft:
|
|
tmp="(";
|
|
break;
|
|
case TQt::Key_ParenRight:
|
|
tmp=")";
|
|
break;
|
|
case TQt::Key_Equal:
|
|
tmp="=";
|
|
break;
|
|
case TQt::Key_AsciiCircum:
|
|
tmp="^";
|
|
break;
|
|
default:
|
|
if (!((TQKeyEvent *)e)->text().isEmpty()) tmp = ((TQKeyEvent *)e)->text();
|
|
}
|
|
|
|
KviKvsVariantList params(new KviKvsVariant(tmp));
|
|
callFunction(this,"keyPressEvent",0,¶ms);
|
|
}
|
|
break;
|
|
case TQEvent::MouseButtonPress:
|
|
if(((TQMouseEvent *)e)->button() & Qt::LeftButton)aparam = 0;
|
|
else {
|
|
if(((TQMouseEvent *)e)->button() & Qt::RightButton)aparam = 1;
|
|
else aparam = 2;
|
|
}
|
|
if(!callFunction(this,"mousePressEvent",retv,new KviKvsVariantList(new KviKvsVariant((kvs_int_t)aparam),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().x()),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().y())
|
|
))) brokenhandler = true; // ignore results of a broken event handler
|
|
break;
|
|
case TQEvent::MouseButtonRelease:
|
|
if(((TQMouseEvent *)e)->button() & Qt::LeftButton)aparam = 0;
|
|
else {
|
|
if(((TQMouseEvent *)e)->button() & Qt::RightButton)aparam = 1;
|
|
else aparam = 2;
|
|
}
|
|
if(!callFunction(this,"mouseReleaseEvent",retv,new KviKvsVariantList(new KviKvsVariant((kvs_int_t)aparam),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().x()),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().y())
|
|
))) brokenhandler = true; // ignore results of a broken event handler
|
|
break;
|
|
case TQEvent::MouseButtonDblClick:
|
|
if(( (TQMouseEvent *)e)->button() & Qt::LeftButton)aparam = 0;
|
|
else {
|
|
if(((TQMouseEvent *)e)->button() & Qt::RightButton)aparam = 1;
|
|
else aparam = 2;
|
|
}
|
|
if(!callFunction(this,"mouseDoubleClickEvent",retv,new KviKvsVariantList(new KviKvsVariant((kvs_int_t)aparam),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().x()),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().y())
|
|
))) brokenhandler = true; // ignore results of a broken event handler
|
|
|
|
break;
|
|
case TQEvent::MouseMove:
|
|
if( (((TQMouseEvent *)e)->state()) & Qt::LeftButton) aparam = 0;
|
|
else
|
|
{
|
|
if(((TQMouseEvent *)e)->state() & Qt::RightButton)aparam = 1;
|
|
else
|
|
{
|
|
if(((TQMouseEvent *)e)->state() & Qt::MidButton)aparam = 2;
|
|
else aparam = -1;
|
|
}
|
|
}
|
|
if(!callFunction(this,"mouseMoveEvent",retv,new KviKvsVariantList(new KviKvsVariant((kvs_int_t)aparam),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().x()),new KviKvsVariant((kvs_int_t)((TQMouseEvent *)e)->pos().y())
|
|
))) brokenhandler = true; // ignore results of a broken event handler
|
|
break;
|
|
case TQEvent::FocusIn:
|
|
if(!callFunction(this,"focusInEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::FocusOut:
|
|
if(!callFunction(this,"focusOutEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Resize:
|
|
if(!callFunction(this,"resizeEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Move:
|
|
if(!callFunction(this,"moveEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Close:
|
|
if(!callFunction(this,"closeEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Enter:
|
|
if(!callFunction(this,"mouseEnterEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Leave:
|
|
if(!callFunction(this,"mouseLeaveEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Show:
|
|
if(!callFunction(this,"showEvent",retv,0))brokenhandler = true;
|
|
break;
|
|
case TQEvent::Hide:
|
|
if(!callFunction(this,"hideEvent",retv,0))ret =false;
|
|
break;
|
|
default:
|
|
return KviKvsObject::eventFilter(o,e);
|
|
break;
|
|
|
|
}
|
|
if (!brokenhandler) ret=retv->asBoolean();
|
|
delete retv;
|
|
return ret;
|
|
/*
|
|
if(ret.length() == 1)
|
|
{
|
|
if(KviTQString::equalCI("1",ret))return true;
|
|
}
|
|
*/
|
|
}
|
|
|
|
return KviKvsObject::eventFilter(o,e);
|
|
}
|
|
|
|
|
|
bool KviKvsObject_widget::function_show(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(!widget())return true; // should we warn here ?
|
|
widget()->show();
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setEnabled(KviKvsObjectFunctionCall *c)
|
|
{
|
|
bool bEnabled;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget())return true;
|
|
widget()->setEnabled(bEnabled);
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_isEnabled(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(!widget()) return true;
|
|
c->returnValue()->setBoolean(widget()->isEnabled());
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_fontDescent(KviKvsObjectFunctionCall * c)
|
|
{
|
|
if(!widget()) return true;
|
|
TQFontMetrics fm = widget()->fontMetrics();
|
|
int d = fm.descent();
|
|
c->returnValue()->setInteger(d);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_fontAscent(KviKvsObjectFunctionCall * c)
|
|
{
|
|
if(!widget()) return true;
|
|
TQFontMetrics fm = widget()->fontMetrics();
|
|
int d = fm.ascent();
|
|
c->returnValue()->setInteger(d);
|
|
return true;
|
|
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_repaint(KviKvsObjectFunctionCall * c)
|
|
{
|
|
bool bEnabled;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget()) return true;
|
|
widget()->repaint(bEnabled);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_fontMetricsWidth(KviKvsObjectFunctionCall * c)
|
|
{
|
|
TQString m_szStr;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("string",KVS_PT_STRING,0,m_szStr)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget()) return true;
|
|
// int fm = widget()->fontMetrics().width(m_szStr);
|
|
c->returnValue()->setInteger(widget()->fontMetrics().width(m_szStr));
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_fontMetricsHeight(KviKvsObjectFunctionCall * c)
|
|
{
|
|
if(!widget())return true;
|
|
int fm = widget()->fontMetrics().height();
|
|
c->returnValue()->setInteger(fm);
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_screenResolution(KviKvsObjectFunctionCall * c)
|
|
{
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)g_pApp->desktop()->width()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)g_pApp->desktop()->height()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_geometry(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQRect r = widget() ? widget()->geometry() : TQRect(0,0,0,0);
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)r.x()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)r.y()));
|
|
a->set(2,new KviKvsVariant((kvs_int_t)r.width()));
|
|
a->set(3,new KviKvsVariant((kvs_int_t)r.height()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setGeometry(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsVariant * pXOrArray;
|
|
kvs_int_t iX,iY,iW,iH;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("x_or_array",KVS_PT_VARIANT,0,pXOrArray)
|
|
KVSO_PARAMETER("y",KVS_PT_INT,KVS_PF_OPTIONAL,iY)
|
|
KVSO_PARAMETER("w",KVS_PT_INT,KVS_PF_OPTIONAL,iW)
|
|
KVSO_PARAMETER("h",KVS_PT_INT,KVS_PF_OPTIONAL,iH)
|
|
KVSO_PARAMETERS_END(c)
|
|
|
|
// this is a little bit tricky: we accept two syntax versions
|
|
// (this is something like a C++ overload)
|
|
// $setGeometry(x,y,w,h) OR $setGeometry($array(x,y,w,h))
|
|
|
|
// For this purpose we ask the parameter processing engine
|
|
// to return the first parameter as variant and we manually check its data typoe
|
|
// We also set the following three parameters as optional
|
|
// so the user can either pass one or four parameters.
|
|
|
|
// Because of this trick, we must check the parameter consistency
|
|
// manually.
|
|
|
|
if(pXOrArray->isArray())
|
|
{
|
|
// the user has passed a complete geometry array as first parameter
|
|
// make sure it has at least 4 elements
|
|
if(pXOrArray->array()->size() < 4)
|
|
{
|
|
c->error(__tr2qs("The array passed as parameter must contain at least 4 elements"));
|
|
return false;
|
|
}
|
|
// we must also manually extract the data from the array
|
|
KviKvsVariant * pX = pXOrArray->array()->at(0);
|
|
KviKvsVariant * pY = pXOrArray->array()->at(1);
|
|
KviKvsVariant * pW = pXOrArray->array()->at(2);
|
|
KviKvsVariant * pH = pXOrArray->array()->at(3);
|
|
// note that some of the array elements may be empty in fact
|
|
// a null value returned by KviKvsArray::at() means that
|
|
// no parameter was set in that place
|
|
if(!(pX && pY && pW && pH))
|
|
{
|
|
c->error(__tr2qs("One of the geometry array parameters is empty"));
|
|
return false;
|
|
}
|
|
if(!(pX->asInteger(iX) && pY->asInteger(iY) && pW->asInteger(iW) && pH->asInteger(iH)))
|
|
{
|
|
c->error(__tr2qs("One of the geometry array parameters didn't evaluate to an integer"));
|
|
return false;
|
|
}
|
|
// ok: the params are correct
|
|
} else {
|
|
// The user passed something else as first parameter
|
|
// make sure that it is an integer.
|
|
// Also make sure that we really have 4 parameters
|
|
if(c->params()->count() < 4)
|
|
{
|
|
c->error(__tr2qs("$setGeometry() requires either an array as first parameter or four integers"));
|
|
return false;
|
|
}
|
|
if(!pXOrArray->asInteger(iX))
|
|
{
|
|
c->error(__tr2qs("The first parameter didn't evaluate to an array nor an integer"));
|
|
return false;
|
|
}
|
|
// ok: the params are correct
|
|
}
|
|
|
|
if(widget())
|
|
widget()->setGeometry(iX,iY,iW,iH);
|
|
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_mapToGlobal(KviKvsObjectFunctionCall *c)
|
|
|
|
{
|
|
if(!widget())return true;
|
|
kvs_int_t iX,iY;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("x",KVS_PT_INT,0,iX)
|
|
KVSO_PARAMETER("y",KVS_PT_INT,0,iY)
|
|
KVSO_PARAMETERS_END(c)
|
|
TQPoint point=widget()->mapToGlobal(TQPoint(iX,iY));
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)point.x()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)point.y()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_mapFromGlobal(KviKvsObjectFunctionCall *c)
|
|
|
|
{
|
|
if(!widget())return true;
|
|
kvs_int_t iX,iY;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("x",KVS_PT_INT,0,iX)
|
|
KVSO_PARAMETER("y",KVS_PT_INT,0,iY)
|
|
KVSO_PARAMETERS_END(c)
|
|
TQPoint point=widget()->mapFromGlobal(TQPoint(iX,iY));
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)point.x()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)point.y()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_centerToScreen(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget()) widget()->move((g_pApp->desktop()->width() - widget()->width())/2,(g_pApp->desktop()->height() - widget()->height())/2);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setPaletteForeground(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsVariant * pColArray;
|
|
kvs_int_t iColR,iColG,iColB;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("hex_rgb_array_or_red",KVS_PT_VARIANT,0,pColArray)
|
|
KVSO_PARAMETER("green",KVS_PT_INT,KVS_PF_OPTIONAL,iColG)
|
|
KVSO_PARAMETER("blue",KVS_PT_INT,KVS_PF_OPTIONAL,iColB)
|
|
KVSO_PARAMETERS_END(c)
|
|
|
|
if(pColArray->isArray())
|
|
{
|
|
if(pColArray->array()->size() < 3)
|
|
{
|
|
c->error(__tr2qs("The array passed as parameter must contain at least 3 elements"));
|
|
return false;
|
|
}
|
|
KviKvsVariant * pColR = pColArray->array()->at(0);
|
|
KviKvsVariant * pColG = pColArray->array()->at(1);
|
|
KviKvsVariant * pColB = pColArray->array()->at(2);
|
|
|
|
if(!(pColR && pColG && pColB))
|
|
{
|
|
c->error(__tr2qs("One of the colors array parameters is empty"));
|
|
return false;
|
|
}
|
|
if(!(pColR->asInteger(iColR) && pColG->asInteger(iColG) && pColB->asInteger(iColB)))
|
|
{
|
|
c->error(__tr2qs("One of the colors array parameters didn't evaluate to an integer"));
|
|
return false;
|
|
}
|
|
|
|
} else {
|
|
if (c->params()->count()==1)
|
|
{
|
|
bool bOk,bOk1,bOk2;
|
|
TQString value;
|
|
pColArray->asString(value);
|
|
int i=0;
|
|
if (value.length()!=6)
|
|
{
|
|
c->warning(__tr2qs("A string of 6 digits hex is required"));
|
|
return true;
|
|
}
|
|
TQString buffer(value.mid(0,2));
|
|
iColR=buffer.toInt(&bOk,16);
|
|
buffer=value.mid(2,2);
|
|
iColG=buffer.toInt(&bOk1,16);
|
|
buffer=value.mid(4,2);
|
|
iColB=buffer.toInt(&bOk2,16);
|
|
if (!bOk || !bOk1 || !bOk2)
|
|
{
|
|
c->warning(__tr2qs("Not an hex digits"));
|
|
return true;
|
|
}
|
|
if (widget()) widget()->setPaletteForegroundColor(TQColor(iColR,iColG,iColB));
|
|
return true;
|
|
}
|
|
|
|
if(c->params()->count() < 3)
|
|
{
|
|
|
|
c->error(__tr2qs("$setForegroundColor requires either an array as first parameter, one hex string or three integers"));
|
|
return false;
|
|
}
|
|
if(!pColArray->asInteger(iColR))
|
|
{
|
|
c->error(__tr2qs("The first parameter didn't evaluate to an array nor an integer"));
|
|
return false;
|
|
}
|
|
}
|
|
if (widget()) widget()->setPaletteForegroundColor(TQColor(iColR,iColG,iColB));
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setBackgroundColor(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsVariant * pColArray;
|
|
kvs_int_t iColR,iColG,iColB;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("hex_rgb_array_or_red",KVS_PT_VARIANT,0,pColArray)
|
|
KVSO_PARAMETER("green",KVS_PT_INT,KVS_PF_OPTIONAL,iColG)
|
|
KVSO_PARAMETER("blue",KVS_PT_INT,KVS_PF_OPTIONAL,iColB)
|
|
KVSO_PARAMETERS_END(c)
|
|
|
|
if(pColArray->isArray())
|
|
{
|
|
if(pColArray->array()->size() < 3)
|
|
{
|
|
c->error(__tr2qs("The array passed as parameter must contain at least 3 elements"));
|
|
return false;
|
|
}
|
|
KviKvsVariant * pColR = pColArray->array()->at(0);
|
|
KviKvsVariant * pColG = pColArray->array()->at(1);
|
|
KviKvsVariant * pColB = pColArray->array()->at(2);
|
|
|
|
if(!(pColR && pColG && pColB))
|
|
{
|
|
c->error(__tr2qs("One of the colors array parameters is empty"));
|
|
return false;
|
|
}
|
|
if(!(pColR->asInteger(iColR) && pColG->asInteger(iColG) && pColB->asInteger(iColB)))
|
|
{
|
|
c->error(__tr2qs("One of the colors array parameters didn't evaluate to an integer"));
|
|
return false;
|
|
}
|
|
|
|
} else {
|
|
if (c->params()->count()==1)
|
|
{
|
|
bool bOk,bOk1,bOk2;
|
|
TQString value;
|
|
pColArray->asString(value);
|
|
int i=0;
|
|
if (value.length()!=6)
|
|
{
|
|
c->warning(__tr2qs("A string of 6 digits hex is required"));
|
|
return true;
|
|
}
|
|
TQString buffer(value.mid(0,2));
|
|
iColR=buffer.toInt(&bOk,16);
|
|
buffer=value.mid(2,2);
|
|
iColG=buffer.toInt(&bOk1,16);
|
|
buffer=value.mid(4,2);
|
|
iColB=buffer.toInt(&bOk2,16);
|
|
if (!bOk || !bOk1 || !bOk2)
|
|
{
|
|
c->warning(__tr2qs("Not an hex digits"));
|
|
return true;
|
|
}
|
|
if (widget()) widget()->setBackgroundColor(TQColor(iColR,iColG,iColB));
|
|
return true;
|
|
}
|
|
|
|
if(c->params()->count() < 3)
|
|
{
|
|
|
|
c->error(__tr2qs("$setBackgroundColor requires either an array as first parameter, one hex string or three integers"));
|
|
return false;
|
|
}
|
|
if(!pColArray->asInteger(iColR))
|
|
{
|
|
c->error(__tr2qs("The first parameter didn't evaluate to an array nor an integer"));
|
|
return false;
|
|
}
|
|
}
|
|
if (widget()) widget()->setBackgroundColor(TQColor(iColR,iColG,iColB));
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_backgroundColor(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(!widget())return true;
|
|
TQColor col = widget()->backgroundColor();
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)col.red()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)col.green()));
|
|
a->set(2,new KviKvsVariant((kvs_int_t)col.blue()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_foregroundColor(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(!widget())return true;
|
|
TQColor col = widget()->foregroundColor();
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)col.red()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)col.green()));
|
|
a->set(2,new KviKvsVariant((kvs_int_t)col.blue()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_parentWidget(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(!widget())return true;
|
|
if(parentScriptWidget()) c->returnValue()->setHObject(parentObject()->handle());
|
|
else
|
|
c->returnValue()->setHObject((kvs_hobject_t)0);
|
|
return true;
|
|
|
|
}
|
|
bool KviKvsObject_widget::function_setMouseTracking(KviKvsObjectFunctionCall *c)
|
|
{
|
|
bool bEnabled;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("bEnabled",KVS_PT_BOOL,0,bEnabled)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(widget()) widget()->setMouseTracking(bEnabled);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setCaption(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQString szCaption;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("caption",KVS_PT_STRING,0,szCaption)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(widget()) widget()->setCaption(szCaption);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_caption(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget()) c->returnValue()->setString(widget()->caption().utf8().data());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_isTopLevel(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget()) c->returnValue()->setBoolean(widget()->isTopLevel());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_isVisible(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget()) c->returnValue()->setBoolean(widget()->isVisible());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_raise(KviKvsObjectFunctionCall *)
|
|
{
|
|
if(widget()) widget()->raise();
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_lower(KviKvsObjectFunctionCall *)
|
|
{
|
|
if(widget())widget()->lower();
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_hasFocus(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget()) c->returnValue()->setBoolean(widget()->hasFocus());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setFocus(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if (widget())widget()->setFocus();
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_hide(KviKvsObjectFunctionCall *)
|
|
{
|
|
if(widget())widget()->hide();
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setToolTip(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQString szTooltip;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("tooltip",KVS_PT_STRING,0,szTooltip)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(widget())TQToolTip::add( widget(), szTooltip );
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_x(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget()) c->returnValue()->setInteger(widget()->x());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_y(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget())c->returnValue()->setInteger(widget()->y());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_width(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget())c->returnValue()->setInteger(widget()->width());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_height(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget())c->returnValue()->setInteger(widget()->height());
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setMinimumWidth(KviKvsObjectFunctionCall *c)
|
|
{
|
|
kvs_int_t iW;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("w",KVS_PT_INT,0,iW)
|
|
KVSO_PARAMETERS_END(c)
|
|
if (widget()) widget()->setMinimumWidth(iW);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setMinimumHeight(KviKvsObjectFunctionCall *c)
|
|
{
|
|
kvs_int_t iH;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("h",KVS_PT_INT,0,iH)
|
|
KVSO_PARAMETERS_END(c)
|
|
if (widget()) widget()->setMinimumHeight(iH);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setMaximumWidth(KviKvsObjectFunctionCall *c)
|
|
{
|
|
kvs_int_t iW;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("w",KVS_PT_INT,0,iW)
|
|
KVSO_PARAMETERS_END(c)
|
|
if (widget()) widget()->setMaximumWidth(iW);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setMaximumHeight(KviKvsObjectFunctionCall *c)
|
|
{
|
|
kvs_int_t iH;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("h",KVS_PT_INT,0,iH)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(widget()) widget()->setMaximumHeight(iH);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_move(KviKvsObjectFunctionCall *c)
|
|
{
|
|
kvs_int_t iX,iY;
|
|
|
|
KviKvsVariant * pXOrArray;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("x_or_array",KVS_PT_VARIANT,0,pXOrArray)
|
|
KVSO_PARAMETER("y",KVS_PT_INT,KVS_PF_OPTIONAL,iY)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(pXOrArray->isArray())
|
|
{
|
|
if(pXOrArray->array()->size() < 2)
|
|
{
|
|
c->error(__tr2qs("The array passed as parameter must contain at least 2 elements"));
|
|
return false;
|
|
}
|
|
KviKvsVariant * pX = pXOrArray->array()->at(0);
|
|
KviKvsVariant * pY = pXOrArray->array()->at(1);
|
|
if(!(pX && pY))
|
|
{
|
|
c->error(__tr2qs("One of the move array parameters is empty"));
|
|
return false;
|
|
}
|
|
if(!(pX->asInteger(iX) && pY->asInteger(iY)))
|
|
{
|
|
c->error(__tr2qs("One of the move array parameters didn't evaluate to an integer"));
|
|
return false;
|
|
}
|
|
// ok: the params are correct
|
|
} else {
|
|
if(c->params()->count() < 2)
|
|
{
|
|
c->error(__tr2qs("$move() requires either an array as first parameter or two integers"));
|
|
return false;
|
|
}
|
|
if(!pXOrArray->asInteger(iX))
|
|
{
|
|
c->error(__tr2qs("The first parameter didn't evaluate to an array nor an integer"));
|
|
return false;
|
|
}
|
|
// ok: the params are correct
|
|
}
|
|
|
|
if(!widget())return true;
|
|
widget()->move(TQPoint(iX,iY));
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_sizeHint(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(!widget())return true;
|
|
TQSize sizehint = widget()->sizeHint();
|
|
KviKvsArray * a = new KviKvsArray();
|
|
a->set(0,new KviKvsVariant((kvs_int_t)sizehint.width()));
|
|
a->set(1,new KviKvsVariant((kvs_int_t)sizehint.height()));
|
|
c->returnValue()->setArray(a);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_resize(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsVariant * pWOrArray;
|
|
kvs_int_t iW,iH;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("width_or_array",KVS_PT_VARIANT,0,pWOrArray)
|
|
KVSO_PARAMETER("height",KVS_PT_INT,KVS_PF_OPTIONAL,iH)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(pWOrArray->isArray())
|
|
{
|
|
if(pWOrArray->array()->size() < 2)
|
|
{
|
|
c->error(__tr2qs("The array passed as parameter must contain at least 2 elements"));
|
|
return false;
|
|
}
|
|
KviKvsVariant * pW = pWOrArray->array()->at(0);
|
|
KviKvsVariant * pH = pWOrArray->array()->at(1);
|
|
if(!(pW && pH))
|
|
{
|
|
c->error(__tr2qs("One of the resize array parameters is empty"));
|
|
return false;
|
|
}
|
|
if(!(pW->asInteger(iW) && pH->asInteger(iH)))
|
|
{
|
|
c->error(__tr2qs("One of the resize array parameters didn't evaluate to an integer"));
|
|
return false;
|
|
}
|
|
// ok: the params are correct
|
|
} else {
|
|
if(c->params()->count() < 2)
|
|
{
|
|
c->error(__tr2qs("$resize() requires either an array as first parameter or two integers"));
|
|
return false;
|
|
}
|
|
if(!pWOrArray->asInteger(iW))
|
|
{
|
|
c->error(__tr2qs("The first parameter didn't evaluate to an array nor an integer"));
|
|
return false;
|
|
}
|
|
// ok: the params are correct
|
|
}
|
|
|
|
if(!widget())return true;
|
|
widget()->resize(TQSize(iW,iH));
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_setFocusPolicy(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQString szMode;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("focus",KVS_PT_STRING,0,szMode)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget())return true;
|
|
if(KviTQString::equalCI(szMode, "TabFocus"))
|
|
widget()->setFocusPolicy(TQT_WIDGET_TABFOCUS);
|
|
else
|
|
if(KviTQString::equalCI(szMode, "ClickFocus"))
|
|
widget()->setFocusPolicy(TQT_WIDGET_CLICKFOCUS);
|
|
else
|
|
if(KviTQString::equalCI(szMode, "StrongFocus"))
|
|
widget()->setFocusPolicy(TQT_WIDGET_STRONGFOCUS);
|
|
else
|
|
if(KviTQString::equalCI(szMode, "NoFocus"))
|
|
widget()->setFocusPolicy(TQT_WIDGET_NOFOCUS);
|
|
else c->warning(__tr2qs("Invalid parameters"));
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setWFlags(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQStringList wflags;
|
|
//TQt::WindowType sum;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("widget_flags",KVS_PT_STRINGLIST,KVS_PF_OPTIONAL,wflags)
|
|
KVSO_PARAMETERS_END(c)
|
|
if (!widget()) return true;
|
|
#ifdef COMPILE_USE_QT4
|
|
TQt::WindowFlags flag,sum=0;
|
|
#else
|
|
int flag,sum=0;
|
|
#endif
|
|
for ( TQStringList::Iterator it = wflags.begin(); it != wflags.end(); ++it )
|
|
{
|
|
|
|
flag=0;
|
|
for(unsigned int j = 0; j < widgettypes_num; j++)
|
|
{
|
|
if(KviTQString::equalCI((*it), widgettypes_tbl[j]))
|
|
{
|
|
flag=widgettypes_cod[j];
|
|
break;
|
|
}
|
|
}
|
|
if(flag)
|
|
sum = sum | flag;
|
|
else
|
|
c->warning(__tr2qs("Unknown widget flag '%Q'"),&(*it));
|
|
|
|
}
|
|
|
|
#ifdef COMPILE_USE_QT4
|
|
widget()->setWindowFlags(sum);
|
|
#else
|
|
widget()->reparent(widget()->parentWidget(),sum,TQPoint(widget()->x(),widget()->y()));
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setFont(KviKvsObjectFunctionCall *c)
|
|
{
|
|
|
|
TQString szFamily,szStyle;
|
|
kvs_int_t uSize;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("size",KVS_PT_UNSIGNEDINTEGER,0,uSize)
|
|
KVSO_PARAMETER("family",KVS_PT_STRING,0,szFamily)
|
|
KVSO_PARAMETER("style",KVS_PT_STRING,0,szStyle)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget())return true;
|
|
TQFont font=widget()->font();
|
|
font.setFamily(szFamily);
|
|
font.setPointSize(uSize);
|
|
if(KviTQString::equalCI(szStyle,"italic")) font.setItalic(TRUE);
|
|
else if(KviTQString::equalCI(szStyle,"bold")) font.setBold(TRUE);
|
|
else if(KviTQString::equalCI(szStyle,"underline"))font.setUnderline(TRUE);
|
|
else if(KviTQString::equalCI(szStyle,"overline")) font.setOverline(TRUE);
|
|
else if(KviTQString::equalCI(szStyle,"strikeout"))font.setStrikeOut(TRUE);
|
|
else if(KviTQString::equalCI(szStyle,"fixedpitch")) font.setFixedPitch(TRUE);
|
|
else c->warning(__tr2qs("Unknown style '%Q'"),&szStyle);
|
|
widget()->setFont(font);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_addWidgetToWrappedLayout(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsObject *ob;
|
|
kvs_int_t uCol,uRow;
|
|
kvs_hobject_t hObject;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("widget",KVS_PT_HOBJECT,0,hObject)
|
|
KVSO_PARAMETER("col",KVS_PT_UNSIGNEDINTEGER,0,uCol)
|
|
KVSO_PARAMETER("row",KVS_PT_UNSIGNEDINTEGER,0,uRow)
|
|
KVSO_PARAMETERS_END(c)
|
|
ob=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
|
|
if(!widget())return true;
|
|
if (!ob)
|
|
{
|
|
c->warning(__tr2qs("Widget parameter is not an object"));
|
|
return true;
|
|
}
|
|
if (!ob->object())
|
|
{
|
|
c->warning(__tr2qs("Widget parameter is not a valid object"));
|
|
return true;
|
|
}
|
|
TQLayout *lay=widget()->layout();
|
|
if (!lay)
|
|
{
|
|
c->warning(__tr2qs("No Layout associated to the widget "));
|
|
return true;
|
|
}
|
|
if(!ob->object()->isWidgetType())
|
|
{
|
|
c->warning(__tr2qs("Can't add a non-widget object"));
|
|
return true;
|
|
}
|
|
lay->add(((TQWidget *)(ob->object())));
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_reparent(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsObject *ob;
|
|
kvs_hobject_t hObject;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("widget",KVS_PT_HOBJECT,KVS_PF_OPTIONAL,hObject)
|
|
KVSO_PARAMETERS_END(c)
|
|
ob=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
|
|
if(!widget()) return true;
|
|
if(!ob)
|
|
{
|
|
widget()->reparent(0,TQPoint(widget()->x(),widget()->y()));
|
|
return true;
|
|
}
|
|
else
|
|
if(!ob->object()->isWidgetType())
|
|
{
|
|
c->warning(__tr("Parent must be a widget object"));
|
|
return true;
|
|
}
|
|
widget()->reparent(((TQWidget *)(ob->object())),TQPoint(((TQWidget *)(ob->object()))->x(),((TQWidget *)(ob->object()))->y()));
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_setIcon(KviKvsObjectFunctionCall *c)
|
|
{
|
|
|
|
TQString icon;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("icon",KVS_PT_STRING,0,icon)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget())return true;
|
|
TQPixmap * pix = g_pIconManager->getImage(icon);
|
|
if(pix)widget()->setIcon(*pix);
|
|
return true;
|
|
}
|
|
|
|
bool KviKvsObject_widget::function_setBackgroundImage(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQString image;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("image",KVS_PT_STRING,0,image)
|
|
KVSO_PARAMETERS_END(c)
|
|
if(!widget())return true;
|
|
TQPixmap * pix = g_pIconManager->getImage(image);
|
|
if(pix)widget()->setPaletteBackgroundPixmap(*pix);
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_globalCursorX(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget())c->returnValue()->setInteger(TQCursor::pos().x());
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_globalCursorY(KviKvsObjectFunctionCall *c)
|
|
{
|
|
if(widget())c->returnValue()->setInteger(TQCursor::pos().y());
|
|
return true;
|
|
}
|
|
bool KviKvsObject_widget::function_setMask(KviKvsObjectFunctionCall *c)
|
|
{
|
|
KviKvsObject *obj;
|
|
kvs_hobject_t hObject;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("pixmap",KVS_PT_HOBJECT,0,hObject)
|
|
KVSO_PARAMETERS_END(c)
|
|
obj=KviKvsKernel::instance()->objectController()->lookupObject(hObject);
|
|
if(!widget())return true;
|
|
if (!obj)
|
|
{
|
|
c->warning(__tr2qs("Pixmap parameter is not an object"));
|
|
return true;
|
|
}
|
|
if (!obj->inherits("KviKvsObject_pixmap"))
|
|
{
|
|
c->warning(__tr2qs("Pixmap object required"));
|
|
return true;
|
|
}
|
|
TQPixmap * pm=((KviKvsObject_pixmap *)obj)->getPixmap();
|
|
#ifdef COMPILE_USE_QT4
|
|
TQBitmap mask(pm->mask());
|
|
#else
|
|
TQBitmap mask(*pm->mask());
|
|
#endif
|
|
if (mask.isNull()) c->warning(__tr2qs("Null mask"));
|
|
widget()->setMask(mask);
|
|
return true;
|
|
}
|
|
#ifdef COMPILE_USE_QT4
|
|
bool KviKvsObject_widget::function_setAttribute(KviKvsObjectFunctionCall *c)
|
|
{
|
|
TQString attribute;
|
|
bool bFlag;
|
|
KVSO_PARAMETERS_BEGIN(c)
|
|
KVSO_PARAMETER("widget_atribute",KVS_PT_STRING,0,attribute)
|
|
KVSO_PARAMETER("bool_flag",KVS_PT_BOOLEAN,0,bFlag)
|
|
KVSO_PARAMETERS_END(c)
|
|
if (!widget()) return true;
|
|
bool found=false;
|
|
unsigned int j = 0;
|
|
for(; j < widgetattributes_num; j++)
|
|
{
|
|
if(KviTQString::equalCI(attribute, widgetattributes_tbl[j]))
|
|
{
|
|
found=true;
|
|
break;
|
|
}
|
|
}
|
|
if(found)widget()->setAttribute(widgetattributes_cod[j],bFlag);
|
|
else c->warning(__tr2qs("Unknown widget attribute '%Q'"),&attribute);
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
#include "m_class_widget.moc"
|