22 wxPython, OGL を用いたコンポーネント図形表示画面 28 import wx.lib.colourdb
30 import RtmLineUtil
as lu
35 from RtmDialog
import *
44 SELECTED_COLOR =
"LIGHT BLUE" 45 UNLOADED_COLOR =
"black" 46 INACTIVE_COLOR =
"blue" 47 ACTIVE_COLOR =
"green" 54 VIRTUAL_COLOR =
"WHITE" 66 strDEL_SELECT =
"Delete Selected Item" 67 strREFRESH =
"Refresh" 68 strOPEN =
"Open System" 69 strSAVE =
"Save System" 70 strSAVE_AS =
"Save System As" 71 strDEL_SYS =
"Current System is Deleted when OPEN.\nDelete It?" 79 strDELITEM =
"Delete Item" 82 strASM_CONNECT =
"Connect" 83 strASM_DELETE =
"Delete" 86 strASKMESSAGE =
"Old Connection Information was found.\nDelete it and reconnect?" 90 strSAVE_AS_TITLE =
"Save file as ..." 92 strOPEN_TITLE =
"Open a file" 96 """ドラッグ&ドロップ:コンポーネントのツリー画面からテキストデータを受け取るクラス""" 98 """クラスの初期化(TextDropTargetの作成)
[引数]
parent -- 親クラス
log -- ログ出力用クラス(wx.LogMessageのラッパー)
[戻り値]
void
102 log -- ログ出力用クラス(wx.LogMessageのラッパー)
[戻り値]
void
107 wx.TextDropTarget.__init__(self)
112 """ドロップ機能のイベントハンドラ 別ウィンドウからのドロップ操作で文字列を受け取る
[引数]
x -- マウスカーソルのx座標
y -- マウスカーソルのy座標
text -- ドロップされた文字列(現時点はコンポーネント名)
[戻り値]
void
113 別ウィンドウからのドロップ操作で文字列を受け取る
[引数]
x -- マウスカーソルのx座標
y -- マウスカーソルのy座標
text -- ドロップされた文字列(現時点はコンポーネント名)
[戻り値]
void
118 text -- ドロップされた文字列(現時点はコンポーネント名)
[戻り値]
void
123 self.log.WriteText(
"(%d, %d)\n%s\n" % (x, y, text))
124 canvas = self.parent.diagram.GetCanvas()
125 dc = wx.ClientDC(self.
parent)
127 self.parent.PrepareDC(dc)
130 if text
not in self.parent.rtc_dict.keys():
133 ref = self.parent.frame.myDict.GetObjRefToFullpath(text)
134 kind = self.parent.frame.myDict.GetKindToFullpath(text)
135 if ref !=
None and kind ==
'rtc':
136 self.parent.rtc_dict[text] =
GRtc(self.
parent, text, x, y)
137 self.parent.rtc_list.append(text)
138 self.parent.rtc_dict[text].refresh()
139 self.parent.remakeLines()
141 print "error: Drag Item does not obj-ref!" 143 self.parent.Redraw(dc)
146 """ドラッグ通知?イベントハンドラ マウスカーソルがターゲット上に来たら呼び出される
[引数]
x -- マウスカーソルのx座標
y -- マウスカーソルのy座標
d -- SHIFT or CONTROL 押下時のフラグ
[戻り値]
wxDragResult -- ドラッグの状態を(システムに?)通知する
147 マウスカーソルがターゲット上に来たら呼び出される
[引数]
x -- マウスカーソルのx座標
y -- マウスカーソルのy座標
d -- SHIFT or CONTROL 押下時のフラグ
[戻り値]
wxDragResult -- ドラッグの状態を(システムに?)通知する
152 d -- SHIFT or CONTROL 押下時のフラグ 155 wxDragResult -- ドラッグの状態を(システムに?)通知する 161 """メモリDC(BufferedDC)を設定、取得する関数
[引数]
canvas -- キャンバス
[戻り値]
dc -- BufferedDC
169 cdc = wx.ClientDC(canvas)
170 canvas.PrepareDC(cdc)
171 bufSize = wx.Size(1000, 1000)
172 dc = wx.BufferedDC(cdc, bufSize)
174 dc.SetBackground(wx.Brush(canvas.GetBackgroundColour()))
179 """コンポーネントの状態で図形の色を変更する関数
[引数]
shape -- 図形(Shape)オブジェクト
colorFlag -- コンポーネントの状態を示す文字列
select, unloaded, inactive, active, error, virtual
[戻り値]
void
182 shape -- 図形(Shape)オブジェクト colorFlag -- コンポーネントの状態を示す文字列
select, unloaded, inactive, active, error, virtual
[戻り値]
void
183 colorFlag -- コンポーネントの状態を示す文字列 select, unloaded, inactive, active, error, virtual
[戻り値]
void
184 select, unloaded, inactive, active, error, virtual 189 if colorFlag ==
'select':
190 shape.SetBrush(wx.Brush(wx.NamedColor(SELECTED_COLOR)))
191 elif colorFlag ==
'unloaded':
192 shape.SetBrush(wx.Brush(wx.NamedColor(UNLOADED_COLOR)))
193 elif colorFlag ==
'inactive':
194 shape.SetBrush(wx.Brush(wx.NamedColor(INACTIVE_COLOR)))
195 elif colorFlag ==
'active':
196 shape.SetBrush(wx.Brush(wx.NamedColor(ACTIVE_COLOR)))
197 elif colorFlag ==
'error':
198 shape.SetBrush(wx.Brush(wx.NamedColor(ERROR_COLOR)))
199 elif colorFlag ==
'virtual':
200 shape.SetBrush(wx.Brush(wx.NamedColor(VIRTUAL_COLOR)))
202 shape.SetBrush(wx.Brush(colorFlag))
208 """CompositeShapeのラッパークラス""" 210 """クラスの初期化(CompositeShapeの作成)
[引数]
parent -- 親クラスを指定
[戻り値]
void
213 parent -- 親クラスを指定
[戻り値]
void
218 ogl.CompositeShape.__init__(self)
223 """2点間の線を描画するラッパークラス""" 225 """クラスの初期化(LineShapeの作成)
[引数]
parent -- 親クラスを指定
canvas -- ShapeCanvasオブジェクトを指定。
[戻り値]
void
228 parent -- 親クラスを指定 canvas -- ShapeCanvasオブジェクトを指定。
[戻り値]
void
229 canvas -- ShapeCanvasオブジェクトを指定。 234 ogl.LineShape.__init__(self)
236 self.SetCanvas(canvas)
237 self.SetPen(wx.Pen(wx.BLUE, 1))
239 self.MakeLineControlPoints(2)
240 diagram = canvas.GetDiagram()
241 diagram.AddShape(self)
244 """開始、終了座標を指定し線を作成する
[引数]
startX -- 線を描画開始するx座標
startY -- 線を描画開始するy座標
endX -- 線を描画終了するx座標
endY -- 線を描画終了するy座標
[戻り値]
void
247 startX -- 線を描画開始するx座標 248 startY -- 線を描画開始するy座標 255 self.SetEnds(startX, startY, endX, endY)
259 """四角形を描画するラッパークラス""" 261 """クラスの初期化(Rectangle作成)
[引数]
parent -- 親クラスを指定
width -- 四角形の幅
height -- 四角形の高さ
[戻り値]
void
264 parent -- 親クラスを指定 width -- 四角形の幅
height -- 四角形の高さ
[戻り値]
void
265 width -- 四角形の幅 height -- 四角形の高さ
[戻り値]
void
271 ogl.RectangleShape.__init__(self,width, height)
279 """インポート図形(polygon)描画用クラス""" 281 """クラスの初期化(PolygonShapeの作成)
[引数]
parent -- 親クラスを指定
points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
284 parent -- 親クラスを指定 points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
285 points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
290 ogl.PolygonShape.__init__(self)
294 self.CalculatePolygonCentre()
297 """インポート図形(polygon)の再描画(座標再指定)
[引数]
points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
300 points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
306 self.UpdateOriginalPoints()
307 self.CalculatePolygonCentre()
311 """アウトポート図形(polygon)描画用クラス""" 313 """クラスの初期化(PolygonShapeの作成)
[引数]
parent -- 親クラスを指定
points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
316 parent -- 親クラスを指定 points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
317 points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
322 ogl.PolygonShape.__init__(self)
326 self.CalculatePolygonCentre()
329 """アウトポート図形(polygon)の再描画(座標再指定)
[引数]
points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
332 points -- タプルで連続した(x,y)座標(wxPoints型)を指定
[戻り値]
void
338 self.UpdateOriginalPoints()
339 self.CalculatePolygonCentre()
344 def __init__(self, parent, pos_x, pos_y, width, height):
345 """クラスの初期化(EllipseShapeの作成)
[引数]
parent -- 親クラスを指定
pos_x -- 描画するx座標
pos_y -- 描画するy座標
width -- 楕円の幅
height -- 楕円の高さ
[戻り値]
void
348 parent -- 親クラスを指定 pos_x -- 描画するx座標
pos_y -- 描画するy座標
width -- 楕円の幅
height -- 楕円の高さ
[戻り値]
void
351 width -- 楕円の幅 height -- 楕円の高さ
[戻り値]
void
357 ogl.EllipseShape.__init__(self, width, height)
365 self.SetPen(wx.Pen(wx.BLACK, 1))
366 self.SetBrush(wx.Brush(
'red'))
372 """クラスの初期化(TextShapeの作成)
[引数]
parent -- 親クラスを指定する
width -- テキスト描画エリアの幅
height -- テキスト描画エリアの高さ
[戻り値]
void
375 parent -- 親クラスを指定する width -- テキスト描画エリアの幅
height -- テキスト描画エリアの高さ
[戻り値]
void
376 width -- テキスト描画エリアの幅 height -- テキスト描画エリアの高さ
[戻り値]
void
377 height -- テキスト描画エリアの高さ 382 ogl.TextShape.__init__(self,width, height)
387 """ツールチップ(バルーンヘルプ)図形を生成するクラス""" 389 """クラスの初期化(ツールチップの作成)
[引数]
parent -- 親クラスを指定する
pt -- ツールチップを表示する座標(x,y)のタプルで指定
dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
392 parent -- 親クラスを指定する pt -- ツールチップを表示する座標(x,y)のタプルで指定
dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
393 pt -- ツールチップを表示する座標(x,y)のタプルで指定 dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
394 dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
406 if parent.tag ==
'in':
407 string1 = parent.inport[
'name']
408 string2 = parent.inport[
'port_type']
410 string1 = parent.outport[
'name']
411 string2 = parent.outport[
'port_type']
412 atr =
'%s\n%s'%(string1, string2)
414 tmp = max(len(string1), len(string2))
416 charW = dc.GetCharWidth()
417 charH = dc.GetCharHeight()
422 self.body.AddText(atr)
424 self.body.FormatText(dc,atr,0)
425 self.body.SetDraggable(
False,
False)
427 self.body.SetX(pt[0]+self.
x_size/2)
428 self.body.SetY(pt[1]-self.
y_size/2)
429 self.body.SetPen(wx.Pen(wx.RED, 1))
430 self.body.SetBrush(wx.Brush(wx.NamedColor(BACK_COLOR)))
433 """ツールチップ図形をキャンバス、DC上から削除
[引数]
dc -- 描画されているデバイス・コンテキストを指定
[戻り値]
void
436 dc -- 描画されているデバイス・コンテキストを指定
[戻り値]
void
441 canvas = self.body.GetCanvas()
443 self.body.RemoveFromCanvas(canvas)
447 """線の移動用の円を生成するクラス""" 449 """クラスの初期化(円を作成)
[引数]
parent -- 親クラスを指定する
tag -- 識別子(連番,線との関係を表すフラグ)を指定
※連番は、線を格納する配列の添え字と連係している
pos_x -- 表示するx座標を指定
pos_y -- 表示するy座標を指定
[戻り値]
void
452 parent -- 親クラスを指定する tag -- 識別子(連番,線との関係を表すフラグ)を指定
※連番は、線を格納する配列の添え字と連係している
pos_x -- 表示するx座標を指定
pos_y -- 表示するy座標を指定
[戻り値]
void
453 tag -- 識別子(連番,線との関係を表すフラグ)を指定 ※連番は、線を格納する配列の添え字と連係している
pos_x -- 表示するx座標を指定
pos_y -- 表示するy座標を指定
[戻り値]
void
454 ※連番は、線を格納する配列の添え字と連係している pos_x -- 表示するx座標を指定
pos_y -- 表示するy座標を指定
[戻り値]
void
455 pos_x -- 表示するx座標を指定 pos_y -- 表示するy座標を指定
[戻り値]
void
456 pos_y -- 表示するy座標を指定
[戻り値]
void
479 """円をキャンバス、DC上から削除
[引数]
dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
482 dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
487 canvas = self.body.GetCanvas()
489 self.body.RemoveFromCanvas(canvas)
495 dc -- 描画するデバイス・コンテキストを指定 d_x -- x座標の相対移動量 (endPoint.x - startPoint.x の値)
d_y -- y座標の相対移動量 (endPoint.y - startPoint.y の値)
[戻り値]
void
496 d_x -- x座標の相対移動量 (endPoint.x - startPoint.x の値) d_y -- y座標の相対移動量 (endPoint.y - startPoint.y の値)
[戻り値]
void
497 d_y -- y座標の相対移動量 (endPoint.y - startPoint.y の値)
[戻り値]
void
502 canvas = self.body.GetCanvas()
506 oval_id = oval_tag[0]
512 if oval_tag[1] ==
'oval_width_pos':
513 self.
pos_x = self.body.GetX() + d_x
514 self.
pos_y = self.body.GetY()
516 self.
pos_x = self.body.GetX()
517 self.
pos_y = self.body.GetY() + d_y
520 line.lines[oval_id].Move(dc, self.
pos_x, self.
pos_y)
521 x1,y1,x2,y2 = line.lines[oval_id].GetEnds()
522 line.changeCoordT(oval_id, (x1, y1), (x2, y2) )
527 for x
in range(1,len(line.oval_dict)+1):
528 tag = line.oval_dict[x].
getTag()
529 if oval_id != tag[0]:
530 line_pos_0 = line.coordT[x]
531 line_pos_1 = line.coordT[x+1]
533 if tag[1] ==
'oval_width_pos':
534 hight = line_pos_0[1] - line_pos_1[1]
535 pos_y = line_pos_1[1] + (hight/2)
536 pos_x = line_pos_0[0]
538 width = line_pos_0[0] - line_pos_1[0]
539 pos_x = line_pos_1[0] + (width/2)
540 pos_y = line_pos_1[1]
542 line.oval_dict[x].body.Move(dc, pos_x, pos_y)
545 """タグの取得
[引数]
なし
[戻り値]
tag -- 識別子(連番,線との関係を表すフラグ)を返却
※連番は、線を格納する配列の添え字と連係している
551 tag -- 識別子(連番,線との関係を表すフラグ)を返却 ※連番は、線を格納する配列の添え字と連係している
552 ※連番は、線を格納する配列の添え字と連係している 563 canvas -- 描画するキャンバスを指定 parent -- 親クラスを指定する
[戻り値]
void
564 parent -- 親クラスを指定する
[戻り値]
void
578 self.
idx =
'L' + `canvas.line_idx`
587 """リフレッシュ処理 線及び移動用の円を非選択状態にする
[引数]
なし
[戻り値]
void
588 線及び移動用の円を非選択状態にする
[引数]
なし
[戻り値]
void
596 canvas = self.body.GetCanvas()
597 dc = wx.ClientDC(canvas)
602 """線および移動用の円をキャンバス、DC上から削除する
[引数]
dc -- 描画されているデバイス・コンテキストを指定
canvas -- 描画されているキャンバスを指定
[戻り値]
void
605 dc -- 描画されているデバイス・コンテキストを指定 canvas -- 描画されているキャンバスを指定
[戻り値]
void
606 canvas -- 描画されているキャンバスを指定
[戻り値]
void
611 for x
in range(len(self.
lines)):
612 self.
lines[x].Unlink()
613 self.
lines[x].Erase(dc)
614 self.
lines[x].DeleteControlPoints()
615 self.
lines[x].RemoveFromCanvas(canvas)
621 """線の削除 関連するInport/Outportの情報(色、unsubscribe)の更新処理を呼び出す
[引数]
dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
622 関連するInport/Outportの情報(色、unsubscribe)の更新処理を呼び出す 625 dc -- 描画するデバイス・コンテキストを指定
[戻り値]
void
631 if len(self.g_inp.line_idx) == 1:
634 if len(self.g_outp.line_idx) == 1:
636 canvas = self.
lines[0].GetCanvas()
638 self.g_outp.disconnect(self.
idx)
640 if self.
g_inp !=
None:
641 self.g_inp.disconnect(self.
idx)
663 for cnt
in range(num-1):
670 for x
in range(len(self.
lines)):
673 evthandler2.SetShape(self.
lines[x])
674 evthandler2.SetPreviousHandler(self.
lines[x].GetEventHandler())
675 self.
lines[x].SetEventHandler(evthandler2)
690 lineUtil = lu.LineUtil(self, self.
g_inp, self.
g_outp, startX, startY, endX, endY)
691 self.
coordT = lineUtil.drawLine()
702 """線の開始点を再設定(開始点の移動)
[引数]
dc -- 描画するデバイス・コンテキストを指定
movex -- 開始点x座標の相対移動量
movey -- 開始点y座標の相対移動量
[戻り値]
void
705 dc -- 描画するデバイス・コンテキストを指定 movex -- 開始点x座標の相対移動量
movey -- 開始点y座標の相対移動量
[戻り値]
void
706 movex -- 開始点x座標の相対移動量 707 movey -- 開始点y座標の相対移動量 712 canvas = self.
lines[0].GetCanvas()
714 for x
in range(len(self.
lines)):
715 self.
lines[x].Erase(dc)
716 self.
lines[x].RemoveFromCanvas(canvas)
725 for x
in range(len(self.
lines)):
726 self.
lines[x].Show(
True)
729 """線の終了点を再設定(終了点の移動)
[引数]
dc -- 描画するデバイス・コンテキストを指定
movex -- 終了点x座標の相対移動量
movey -- 終了点y座標の相対移動量
[戻り値]
void
732 dc -- 描画するデバイス・コンテキストを指定 movex -- 終了点x座標の相対移動量
movey -- 終了点y座標の相対移動量
[戻り値]
void
733 movex -- 終了点x座標の相対移動量 734 movey -- 終了点y座標の相対移動量 739 canvas = self.
lines[0].GetCanvas()
741 for x
in range(len(self.
lines)):
742 self.
lines[x].Erase(dc)
743 self.
lines[x].RemoveFromCanvas(canvas)
752 for x
in range(len(self.
lines)):
753 self.
lines[x].Show(
True)
756 """線の選択処理(色の変更)
[引数]
なし
[戻り値]
void
764 for x
in range(len(self.
lines)):
765 self.
lines[x].SetBrush(wx.Brush(wx.NamedColor(SELECTED_COLOR)))
766 self.
lines[x].SetPen(wx.Pen(SELECTED_COLOR, 1))
767 self.
lines[x].Flash()
770 """線の選択解除処理(色の変更、移動用の円を削除)
[引数]
なし
[戻り値]
void
778 for x
in range(len(self.
lines)):
779 self.
lines[x].SetPen(wx.Pen(INACTIVE_COLOR, 1))
780 self.
lines[x].SetBrush(wx.Brush(wx.NamedColor(INACTIVE_COLOR)))
781 self.
lines[x].Flash()
786 """移動処理のダミールーチン
[引数]
dc -- DCを指定
movex -- 移動時の相対距離
movey -- 移動時の相対距離
[戻り値]
void
789 dc -- DCを指定 movex -- 移動時の相対距離
movey -- 移動時の相対距離
[戻り値]
void
800 線を引く2つのポートをあらかじめ指定し本メソッドを呼び出す。 801 canvas.lineTo, canvas.lineFrom にポートを設定しておく。 804 canvas -- 線を描画するキャンバスを指定 dc -- 線を描画するDCを指定
[戻り値]
void
805 dc -- 線を描画するDCを指定
[戻り値]
void
811 ref = canvas.lineTo.parent.ns_dict.GetObjRefToFullpath(canvas.lineTo.parent.fullpath)
814 if canvas.lineFrom.parent.tag ==
'in':
815 self.g_inp = canvas.lineFrom.parent
816 self.g_outp = canvas.lineTo.parent
818 self.g_inp = canvas.lineTo.parent
819 self.g_outp = canvas.lineFrom.parent
821 self.setPoints(self.g_inp.body.GetX(), self.g_inp.body.GetY(), self.g_outp.body.GetX(), self.g_outp.body.GetY())
822 for x
in range(len(self.lines)):
823 evthandler2 = MyEvtHandlerLine()
824 evthandler2.SetShape(self.lines[x])
825 evthandler2.SetPreviousHandler(self.lines[x].GetEventHandler())
826 self.lines[x].SetEventHandler(evthandler2)
829 canvas.line[self.idx] = self
830 self.g_inp.connect(self.idx)
831 canvas.line_idx = canvas.line_idx + 1
832 for x
in range(len(self.lines)):
833 self.lines[x].Show(
True)
835 self.g_inp.body.Move(dc, self.g_inp.body.GetX(), self.g_inp.body.GetY())
836 self.g_outp.body.Move(dc, self.g_outp.body.GetX(), self.g_outp.body.GetY())
841 """線移動時に移動した線の座標を再設定
[引数]
id -- 座標を再設定する開始インデックス(添え字)
new_p1 -- 新しい座標(x,y)の開始点をタプルで指定
new_p2 -- 新しい座標(x,y)の終了点をタプルで指定
[戻り値]
void
844 id -- 座標を再設定する開始インデックス(添え字) new_p1 -- 新しい座標(x,y)の開始点をタプルで指定
new_p2 -- 新しい座標(x,y)の終了点をタプルで指定
[戻り値]
void
845 new_p1 -- 新しい座標(x,y)の開始点をタプルで指定 new_p2 -- 新しい座標(x,y)の終了点をタプルで指定
[戻り値]
void
846 new_p2 -- 新しい座標(x,y)の終了点をタプルで指定
[戻り値]
void
852 self.
coordT[id+1] = new_p2
855 for cnt
in range(num-1):
862 dc -- 描画するデバイス・コンテキストを指定 pos_new -- 移動後の座標リスト
[戻り値]
void
863 pos_new -- 移動後の座標リスト
[戻り値]
void
870 max_num = len(pos_new)
875 for cnt
in range(max_num-1):
880 """インポート図形を作成するクラス""" 881 def __init__(self, parent, ns_dict, fullpath, inp, pos_x, pos_y):
882 """クラスの初期化(インポート図形の作成)
[引数]
parent -- 親クラスを指定する
ns_data -- コンポーネントのディクショナリー
inp -- インポートのディクショナリー(in_list[n])
pos_x -- インポート図形のx座標
pos_y -- インポート図形のy座標
[戻り値]
void
885 parent -- 親クラスを指定する ns_data -- コンポーネントのディクショナリー
inp -- インポートのディクショナリー(in_list[n])
pos_x -- インポート図形のx座標
pos_y -- インポート図形のy座標
[戻り値]
void
886 ns_data -- コンポーネントのディクショナリー 887 inp -- インポートのディクショナリー(in_list[n]) 894 ogl.Shape.__init__(self)
912 """x,y座標もしくはpositionを取得する
[引数]
name -- 取得したい値のフラグを指定する
フラグ: 915 name -- 取得したい値のフラグを指定する フラグ: 916 フラグ:'x', 'y', 'position' 925 elif name ==
'position' :
931 """インポート図形をキャンバス、DC上から削除する
[引数]
dc -- 描画するデバイス・コンテキストを指定
rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
934 dc -- 描画するデバイス・コンテキストを指定 rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
935 rot -- 線の削除可否を指定する。(回転処理等で使用) 0:線を削除 / 1:線を削除しない
[戻り値]
void
941 canvas = self.body.GetCanvas()
943 self.body.RemoveFromCanvas(canvas)
947 line_list = copy.deepcopy(self.
line_idx)
948 for idx
in line_list:
950 if idx
in canvas.line.keys():
955 """インポート図形を生成する
[引数]
なし
[戻り値]
void
969 self.parent.parent.MyAddShape(
970 self.
body, self.
x+POLYGON_SIZE/2-1, self.
y+POLYGON_SIZE/2-1, wx.Pen(OUTLINE_COLOR, 1), wx.Brush(self.
color, wx.SOLID),
"" , 1)
974 インポートに割り付けられている線も同時に移動させる
[引数]
dc -- 描画するデバイス・コンテキストを指定
movex -- x座標の相対移動量を指定
movey -- y座標の相対移動量を指定
[戻り値]
void
977 dc -- 描画するデバイス・コンテキストを指定 movex -- x座標の相対移動量を指定
movey -- y座標の相対移動量を指定
[戻り値]
void
978 movex -- x座標の相対移動量を指定 movey -- y座標の相対移動量を指定
[戻り値]
void
979 movey -- y座標の相対移動量を指定
[戻り値]
void
984 canvas = self.body.GetCanvas()
988 self.
x = self.body.GetX() + movex
989 self.
y = self.body.GetY() + movey
990 self.body.Move(dc, self.
x, self.
y)
994 canvas.line[line_index].setStartPoint(dc, movex, movey)
997 """インポートに割り付けた線のインデックスを削除する
[引数]
idx -- 線のインデックス
[戻り値]
void
1006 tmp = self.line_idx.index(idx)
1010 """インポートを選択状態にする
[引数]
なし
[戻り値]
void
1018 self.body.SetBrush(wx.Brush(wx.NamedColor(SELECTED_COLOR)))
1022 """インポートを非選択状態にする
[引数]
なし
[戻り値]
void
1030 self.body.SetBrush(wx.Brush(wx.NamedColor(self.
color)))
1037 x -- サイズ変更後のx座標を指定 y -- サイズ変更後のy座標を指定
ratioW -- サイズ変更を行うWidthのサイズ比率
ratioH -- サイズ変更を行うHeightのサイズ比率
[戻り値]
void
1038 y -- サイズ変更後のy座標を指定 ratioW -- サイズ変更を行うWidthのサイズ比率
ratioH -- サイズ変更を行うHeightのサイズ比率
[戻り値]
void
1039 ratioW -- サイズ変更を行うWidthのサイズ比率 1040 ratioH -- サイズ変更を行うHeightのサイズ比率 1045 movex = x - self.body.GetX()
1046 movey = y - self.body.GetY()
1050 if self.parent.xy_swap == 1:
1051 self.
y_size, self.
x_size = self.body.GetBoundingBoxMin()
1052 self.parent.py_size, self.parent.px_size = self.parent.px_size, self.parent.py_size
1054 self.
x_size, self.
y_size = self.body.GetBoundingBoxMin()
1057 self.parent.px_size = self.
x_size 1058 self.parent.py_size = self.
y_size 1059 canvas = self.body.GetCanvas()
1060 dc = wx.ClientDC(canvas)
1061 canvas.PrepareDC(dc)
1062 brush = self.body.GetBrush()
1065 self.body.RemoveFromCanvas(canvas)
1068 self.body.updateInportPolygon(self.
points)
1070 self.parent.parent.MyAddShape(
1071 self.
body, self.
x , self.
y,
1072 wx.Pen(OUTLINE_COLOR, 1), brush,
"" , 1)
1076 canvas.line[line_index].setStartPoint(dc, movex, movey)
1079 """コネクト処理(線のインデックスを格納)
[引数]
line_idx -- インポートに接続する線のインデックス
[戻り値]
成否フラグ -- 0:エラー(オブジェクトリファレンス無し) / 1:成功
1082 line_idx -- インポートに接続する線のインデックス 1085 成否フラグ -- 0:エラー(オブジェクトリファレンス無し) / 1:成功 1087 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
1091 self.line_idx.append(line_idx)
1095 """ディスコネクト処理(線のインデックスを削除)
[引数]
line_idx -- インポートに接続している線のインデックス
[戻り値]
成否フラグ -- 0:エラー / 1:成功
1098 line_idx -- インポートに接続している線のインデックス 1101 成否フラグ -- 0:エラー / 1:成功 1111 現在のpositionを見て図形の向きを決定する 各頂点は(x,y)のタプル形式
[引数]
なし
[戻り値]
void
1155 """アウトポート図形を作成するクラス""" 1156 def __init__(self, parent, ns_dict, fullpath, outp, pos_x, pos_y) :
1157 """クラスの初期化(アウトポート図形の作成)
[引数]
parent -- 親クラスを指定する
ns_data -- コンポーネントのディクショナリー
inp -- インポートのディクショナリー(in_list[n])
pos_x -- インポート図形のx座標
pos_y -- インポート図形のy座標
[戻り値]
void
1160 parent -- 親クラスを指定する ns_data -- コンポーネントのディクショナリー
inp -- インポートのディクショナリー(in_list[n])
pos_x -- インポート図形のx座標
pos_y -- インポート図形のy座標
[戻り値]
void
1161 ns_data -- コンポーネントのディクショナリー 1162 inp -- インポートのディクショナリー(in_list[n]) 1163 pos_x -- インポート図形のx座標 1164 pos_y -- インポート図形のy座標 1169 ogl.Shape.__init__(self)
1189 """リフレッシュ処理 現在の接続状況(Inportのオブジェクトリファレンスが存在するか?)を
チェックし、接続状態を継続もしくはunsubscribeを実行する
[引数]
なし
[戻り値]
void
1190 現在の接続状況(Inportのオブジェクトリファレンスが存在するか?)を チェックし、接続状態を継続もしくはunsubscribeを実行する
[引数]
なし
[戻り値]
void
1191 チェックし、接続状態を継続もしくはunsubscribeを実行する
[引数]
なし
[戻り値]
void
1199 canvas = self.body.GetCanvas()
1200 if canvas.viewMode ==
True:
1203 dc = wx.ClientDC(canvas)
1204 canvas.PrepareDC(dc)
1210 for inp
in self.parent.in_list :
1211 if inp[
'name'] == canvas.line[idx].g_inp.inport[
'name']:
1212 canvas.line[idx].g_inp.inport = inp
1215 ref = canvas.line[idx].g_inp.inport[
'ref']
1216 ref = ref._narrow(RTM.InPort)
1218 except_mess(
'inport object-ref failure:%s\n'%inp[
'name'])
1222 ref = ref._narrow(RTM.OutPort)
1223 rslt = ref.unsubscribe(self.
uuid[idx])
1224 print "refresh:unsubscribe:",rslt
1226 print 'unsubscribe failure: rslt=',rslt
1231 """x,y座標もしくはpositionを取得する
[引数]
name -- 取得したい値のフラグを指定する
フラグ: 1234 name -- 取得したい値のフラグを指定する フラグ: 1235 フラグ:'x', 'y', 'position' 1244 elif name ==
'position' :
1250 """アウトポート図形を削除する
[引数]
dc -- 描画するデバイス・コンテキストを指定
rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
1253 dc -- 描画するデバイス・コンテキストを指定 rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
1254 rot -- 線の削除可否を指定する。(回転処理等で使用) 0:線を削除 / 1:線を削除しない
[戻り値]
void
1260 canvas = self.body.GetCanvas()
1262 self.body.RemoveFromCanvas(canvas)
1266 line_list = copy.deepcopy(self.
line_idx)
1267 for idx
in line_list:
1269 if idx
in canvas.line.keys():
1270 del canvas.line[idx]
1274 """アウトポート図形を作成する
[引数]
なし
[戻り値]
void
1288 self.parent.parent.MyAddShape(
1289 self.
body, self.
x+POLYGON_SIZE/2-1, self.
y+POLYGON_SIZE/2-1, wx.Pen(OUTLINE_COLOR, 1), wx.Brush(self.
color, wx.SOLID),
"",1)
1293 アウトポートに割り付けられている線も同時に移動させる
[引数]
dc -- 描画するデバイス・コンテキストを指定
movex -- x座標の相対移動量を指定
movey -- y座標の相対移動量を指定
[戻り値]
void
1296 dc -- 描画するデバイス・コンテキストを指定 movex -- x座標の相対移動量を指定
movey -- y座標の相対移動量を指定
[戻り値]
void
1297 movex -- x座標の相対移動量を指定 movey -- y座標の相対移動量を指定
[戻り値]
void
1298 movey -- y座標の相対移動量を指定
[戻り値]
void
1303 canvas = self.body.GetCanvas()
1304 canvas.PrepareDC(dc)
1306 self.
x = self.body.GetX() + movex
1307 self.
y = self.body.GetY() + movey
1309 self.body.Move(dc, self.
x, self.
y)
1314 canvas.line[line_index].setEndPoint(dc, self.
body,movex, movey)
1318 """アウトポートに割り付けた線のインデックスを削除する
[引数]
idx -- 線のインデックス
[戻り値]
void
1327 tmp = self.line_idx.index(idx)
1331 """アウトポートを選択状態にする
[引数]
なし
[戻り値]
void
1339 self.body.SetBrush(wx.Brush(wx.NamedColor(SELECTED_COLOR)))
1343 """アウトポートを非選択状態にする
[引数]
なし
[戻り値]
void
1351 self.body.SetBrush(wx.Brush(wx.NamedColor(self.
color)))
1358 x -- サイズ変更後のx座標を指定 y -- サイズ変更後のy座標を指定
ratioW -- 変更を行うWidthのサイズ比率
ratioH -- 変更を行うHeightのサイズ比率
[戻り値]
void
1359 y -- サイズ変更後のy座標を指定 ratioW -- 変更を行うWidthのサイズ比率
ratioH -- 変更を行うHeightのサイズ比率
[戻り値]
void
1360 ratioW -- 変更を行うWidthのサイズ比率 1361 ratioH -- 変更を行うHeightのサイズ比率 1366 movex = x - self.body.GetX()
1367 movey = y - self.body.GetY()
1371 if self.parent.xy_swap == 1:
1372 self.
y_size, self.
x_size = self.body.GetBoundingBoxMin()
1373 self.parent.py_size, self.parent.px_size = self.parent.px_size, self.parent.py_size
1375 self.
x_size, self.
y_size = self.body.GetBoundingBoxMin()
1377 self.parent.px_size = self.
x_size 1378 self.parent.py_size = self.
y_size 1379 canvas = self.body.GetCanvas()
1380 dc = wx.ClientDC(canvas)
1381 canvas.PrepareDC(dc)
1382 brush = self.body.GetBrush()
1385 self.body.RemoveFromCanvas(canvas)
1388 self.body.updateOutportPolygon(self.
points)
1390 self.parent.parent.MyAddShape(
1391 self.
body, self.
x , self.
y,
1392 wx.Pen(OUTLINE_COLOR, 1), brush,
"" , 1)
1396 canvas.line[line_index].setEndPoint(dc, self.
body,movex, movey)
1399 """コネクト処理(subscribeを発行)
[引数]
line_idx -- インポートに接続する線のインデックス
subscription_type -- サブスクリプション・タイプを指定(現在未使用)
[戻り値]
成否フラグ -- 0:エラー(オブジェクトリファレンス無し,subscribe失敗) / 1:成功
1402 line_idx -- インポートに接続する線のインデックス 1403 subscription_type -- サブスクリプション・タイプを指定(現在未使用)
[戻り値]
成否フラグ -- 0:エラー(オブジェクトリファレンス無し,subscribe失敗) / 1:成功
1406 成否フラグ -- 0:エラー(オブジェクトリファレンス無し,subscribe失敗) / 1:成功 1408 canvas = self.body.GetCanvas()
1415 ref = ref._narrow(RTM.OutPort)
1421 inp_ref = canvas.line[line_idx].g_inp.inport[
'ref']
1423 inp_ref = inp_ref._narrow(RTM.InPort)
1429 subscription_list = []
1431 subscription_list = ref._get_subscriptions()
1432 if subscription_list ==
None:
1433 print "get subscriptions failure: return value is None." 1439 connect_num = self.
checkConnect(inp_ref, subscription_list)
1441 if canvas.viewMode ==
False:
1442 if connect_num == -1:
1444 canvas.line[line_idx].subscription_type = subscription_type
1445 canvas.line[line_idx].profile = RTM.SubscriptionProfile(subscription_type,
"",
None,
None,
False,[])
1446 canvas.line[line_idx].profile.out_port = ref
1447 canvas.line[line_idx].profile.in_port = inp_ref
1448 rslt, canvas.line[line_idx].profile = ref.subscribe(canvas.line[line_idx].profile)
1449 self.
uuid[line_idx] = canvas.line[line_idx].profile.id
1452 print "subscribe failure!" 1455 print "connect2 subscribe :",self.
uuid[line_idx]
1459 self.
uuid[line_idx] = subscription_list[connect_num].id
1463 """コネクト処理(線のインデックスを格納、subscribeを発行)
[引数]
line_idx -- インポートに接続する線のインデックス
subscription_type -- サブスクリプション・タイプを指定(現在未使用)
[戻り値]
成否フラグ -- 0:エラー(オブジェクトリファレンス無し,subscribe失敗) / 1:成功
1466 line_idx -- インポートに接続する線のインデックス 1467 subscription_type -- サブスクリプション・タイプを指定(現在未使用)
[戻り値]
成否フラグ -- 0:エラー(オブジェクトリファレンス無し,subscribe失敗) / 1:成功
1470 成否フラグ -- 0:エラー(オブジェクトリファレンス無し,subscribe失敗) / 1:成功 1472 canvas = self.body.GetCanvas()
1479 ref = ref._narrow(RTM.OutPort)
1483 self.parent.refresh()
1489 inp_ref = canvas.line[line_idx].g_inp.inport[
'ref']
1491 inp_ref = inp_ref._narrow(RTM.InPort)
1497 subscription_list = []
1499 subscription_list = ref._get_subscriptions()
1500 if subscription_list ==
None:
1501 print "get subscriptions failure: return value is None." 1507 canvas.line[line_idx].subscription_type = subscription_type
1508 canvas.line[line_idx].profile = RTM.SubscriptionProfile(subscription_type,
"",
None,
None,
False,[])
1511 connect_num = self.
checkConnect(inp_ref, subscription_list)
1517 if canvas.viewMode ==
False:
1518 if connect_num == -1:
1520 canvas.line[line_idx].profile.out_port = ref
1521 canvas.line[line_idx].profile.in_port = inp_ref
1522 (rslt, canvas.line[line_idx].profile) = ref.subscribe(canvas.line[line_idx].profile)
1524 print "subscribe failuer! :rslt=",rslt
1525 self.
uuid[line_idx] = canvas.line[line_idx].profile.id
1526 print "connect subscribe :",self.
uuid[line_idx]
1528 err_mess =
'subscribe failure! :' 1533 self.
uuid[line_idx] = subscription_list[connect_num].id
1536 print "subsrcibe-rslt:",rslt
1539 self.line_idx.append(line_idx)
1544 """ディスコネクト処理(線のインデックスを削除、unsubscribeを発行)
[引数]
line_idx -- アウトポートに接続している線のインデックス
[戻り値]
成否フラグ -- 0:エラー / 1:成功
1547 line_idx -- アウトポートに接続している線のインデックス 1550 成否フラグ -- 0:エラー / 1:成功 1555 canvas = self.body.GetCanvas()
1561 ref = ref._narrow(RTM.OutPort)
1563 inp_obj = canvas.line[line_idx].g_inp.inport[
'ref']
1566 subscription_list = []
1567 subscription_list = ref._get_subscriptions()
1568 if subscription_list ==
None:
1569 print "get subscriptions failure: return value is None." 1572 connect_num = self.
checkConnect(inp_obj, subscription_list)
1578 err_mess =
'outport disconnect failure:' 1581 self.parent.refresh()
1586 if ref !=
None and canvas.viewMode ==
False and connect_num != -1:
1588 print "unsubscribe :",self.
uuid[line_idx]
1589 rslt = ref.unsubscribe(self.
uuid[line_idx])
1591 print 'unsubscribe failure: rslt=',rslt
1593 err_mess =
'unsubscribe failure:' 1605 """再接続処理 オブジェクト上だけに存在する接続情報(subscribe)を検索し線を引く
[引数]
なし
[戻り値]
void
1606 オブジェクト上だけに存在する接続情報(subscribe)を検索し線を引く 1618 canvas = self.body.GetCanvas()
1619 dc = wx.ClientDC(canvas)
1620 canvas.PrepareDC(dc)
1624 ref = ref._narrow(RTM.OutPort)
1626 err_mess =
'outport obj-ref failure:' 1631 subscription_list = []
1632 subscr_list_tmp = []
1634 subscription_list = ref._get_subscriptions()
1635 subscr_list_tmp = copy.deepcopy(subscription_list)
1636 if subscription_list ==
None:
1637 print "get subscriptions failure: return value is None." 1644 line = canvas.line[line_idx]
1645 (ret2,subscr_list_tmp) = self.
checkConnect2(line,subscr_list_tmp)
1647 rtc_list = self.parent.parent.rtc_list
1648 rtc_dict = self.parent.parent.rtc_dict
1653 for subscr
in subscr_list_tmp:
1654 inp_ref = subscr.in_port
1655 for fullname
in rtc_list:
1656 in_list = rtc_dict[fullname].in_list
1657 in_dict = rtc_dict[fullname].in_dict
1660 if inp[
'name']
in in_dict.keys():
1661 ref = in_dict[inp[
'name']].inport[
'ref']
1662 if inp_ref._is_equivalent(ref):
1663 print "_is_equivalent is OK!!!" 1664 ret_name.append( inp[
'name'] )
1665 ret_obj.append( in_dict[inp[
'name']] )
1666 ret_ref.append(inp_ref)
1668 for num
in range(len(ret_name)):
1669 canvas.lineFrom = self.
body 1670 canvas.lineTo = ret_obj[num].body
1672 line.setLine2port(canvas, dc)
1674 self.line_idx.append(line.idx)
1676 connect_num = self.
checkConnect(ret_ref[num], subscription_list)
1678 self.
uuid[line.idx] = subscription_list[connect_num].id
1680 canvas.lineFrom =
None 1681 canvas.lineTo =
None 1686 """古い接続情報があるかチェックする 画面上の線以外の接続がオブジェクト上にあるかチェックする
[引数]
なし
[戻り値]
ret --- True:ある / False:ない
1687 画面上の線以外の接続がオブジェクト上にあるかチェックする
[引数]
なし
[戻り値]
ret --- True:ある / False:ない
1693 ret --- True:ある / False:ない 1696 canvas = self.body.GetCanvas()
1699 ref = ref._narrow(RTM.OutPort)
1701 err_mess =
'outport obj-ref failure:' 1706 subscription_list = []
1708 subscription_list = ref._get_subscriptions()
1709 if subscription_list ==
None:
1710 print "get subscriptions failure: return value is None." 1717 line = canvas.line[line_idx]
1718 (ret2,subscription_list) = self.
checkConnect2(line,subscription_list)
1719 if len(subscription_list) > 0:
1725 指定した接続先(inport)のリファレンスがあるかチェックする
[引数]
inp_obj --- インポートのオブジェクト・リファレンス
ref_list --- インポートのリファレンス・リスト
[戻り値]
ret_num --- subScription_list の添え字/ない場合は-1
1728 inp_obj --- インポートのオブジェクト・リファレンス 1729 ref_list --- インポートのリファレンス・リスト
[戻り値]
ret_num --- subScription_list の添え字/ない場合は-1
1732 ret_num --- subScription_list の添え字/ない場合は-1 1736 for subscr
in subscr_list:
1737 ref_inp = subscr.in_port
1738 if ref_inp._is_equivalent(inp_obj):
1739 print "checkConnect: _is_equivalent is OK!!!" 1742 ret_num = ret_num + 1
1749 チェック対象の接続があった場合は、リスト上から削除して返却する 古い情報があるか調べる為に呼ばれる
[引数]
line --- 線のオブジェクト
ref_list --- 接続先(inport)のオブジェクトリファレンス・リスト
[戻り値]
(ret, ref_list) --- ret 0:ない / 1:ある , ref_list: 残りのリファレンスリスト
1750 古い情報があるか調べる為に呼ばれる
[引数]
line --- 線のオブジェクト
ref_list --- 接続先(inport)のオブジェクトリファレンス・リスト
[戻り値]
(ret, ref_list) --- ret 0:ない / 1:ある , ref_list: 残りのリファレンスリスト
1753 line --- 線のオブジェクト ref_list --- 接続先(inport)のオブジェクトリファレンス・リスト
[戻り値]
(ret, ref_list) --- ret 0:ない / 1:ある , ref_list: 残りのリファレンスリスト
1754 ref_list --- 接続先(inport)のオブジェクトリファレンス・リスト
[戻り値]
(ret, ref_list) --- ret 0:ない / 1:ある , ref_list: 残りのリファレンスリスト
1757 (ret, ref_list) --- ret 0:ない / 1:ある , ref_list: 残りのリファレンスリスト 1760 inp_obj = line.g_inp.inport[
'ref']
1764 for subscr
in subscr_list:
1765 ref_inp = subscr.in_port
1766 if ref_inp._is_equivalent(inp_obj):
1772 del subscr_list[cnt]
1774 return (ret, subscr_list)
1777 """コンポーネント上の接続情報(subscribe)を削除する
[引数]
inp_list --- 接続先(subscriptionProfile)のリスト
[戻り値]
void
1780 inp_list --- 接続先(subscriptionProfile)のリスト
[戻り値]
void
1790 canvas = self.body.GetCanvas()
1792 ref = ref._narrow(RTM.OutPort)
1794 for subscr
in subscr_list:
1795 inp = subscr.in_port
1799 uuid = subscr_list[connect_num].id
1801 if ref !=
None and canvas.viewMode ==
False:
1803 print "unsubscribe2 :",uuid
1804 rslt = ref.unsubscribe(uuid)
1806 print 'unsubscribe2 failure: rslt=',rslt
1808 err_mess =
'unsubscribe failure:' 1813 """再接続処理
[引数]
なし
[戻り値]
void
1825 canvas = self.body.GetCanvas()
1828 ref = ref._narrow(RTM.OutPort)
1830 err_mess =
'outport obj-ref failure:' 1835 subscription_list = []
1836 subscr_list_tmp = []
1838 subscription_list = ref._get_subscriptions()
1839 subscr_list_tmp = copy.deepcopy(subscription_list)
1840 if subscription_list ==
None:
1841 print "get subscriptions failure: return value is None." 1848 line = canvas.line[line_idx]
1849 (ret,subscr_list_tmp) = self.
checkConnect2(line,subscr_list_tmp)
1851 self.
connect2(line_idx,line.subscription_type)
1854 inp_ref = canvas.line[line_idx].g_inp.inport[
'ref']
1855 connect_num = self.
checkConnect(inp_ref, subscription_list)
1856 self.
uuid[line_idx] = subscription_list[connect_num].id
1860 line = canvas.line[line_idx]
1861 (ret,subscr_list_tmp) = self.
checkConnect2(line,subscr_list_tmp)
1863 self.
connect2(line_idx,line.subscription_type)
1864 if len(subscr_list_tmp) > 0:
1870 現在のpositionを見て図形の向きを決定する 各頂点は(x,y)のタプル形式
[引数]
なし
[戻り値]
void
1910 """コンポーネント図形の本体を作成するクラス""" 1912 """クラスの初期化(コンポーネント図形の作成)
[引数]
parent -- 親クラスを指定する
fullpath -- コンポーネントのロングネーム
pos_x -- コンポーネント図形のx座標
pos_y -- コンポーネント図形のy座標
[戻り値]
void
1915 parent -- 親クラスを指定する fullpath -- コンポーネントのロングネーム
pos_x -- コンポーネント図形のx座標
pos_y -- コンポーネント図形のy座標
[戻り値]
void
1916 fullpath -- コンポーネントのロングネーム pos_x -- コンポーネント図形のx座標
pos_y -- コンポーネント図形のy座標
[戻り値]
void
1917 pos_x -- コンポーネント図形のx座標 1918 pos_y -- コンポーネント図形のy座標 1923 ogl.Shape.__init__(self)
1928 self.
name = self.ns_dict.GetCompName(fullpath)
1929 self.
in_list = self.ns_dict.GetInPortToRef(fullpath)
1964 if outp[
'name']
in self.out_dict.keys():
1968 """古い接続情報(画面上に表示されていないsubscribe情報)をチェックする
[引数]
なし
[戻り値]
ret --- True:古い情報あり / False:古い情報なし
1974 ret --- True:古い情報あり / False:古い情報なし 1978 if outp[
'name']
in self.out_dict.keys():
1985 """再接続処理 コンポーネントのアウトポートの再接続処理を呼び出す
[引数]
なし
[戻り値]
void
1986 コンポーネントのアウトポートの再接続処理を呼び出す 1995 if outp[
'name']
in self.out_dict.keys():
1999 """ポート(Shape)のFlash(再描画?)を呼び出す 2000 コンポーネントの絵の下にポートの絵がもぐり込むケースの時に呼び出している。(回避策) 他に良い処理があれば、随時そちらに変更する
[引数]
なし
[戻り値]
void
2001 他に良い処理があれば、随時そちらに変更する
[引数]
なし
[戻り値]
void
2010 if inp[
'name']
in self.in_dict.keys():
2011 self.
in_dict[inp[
'name']].body.Flash()
2013 if outp[
'name']
in self.out_dict.keys():
2014 self.
out_dict[outp[
'name']].body.Flash()
2017 """コンポーネントのステータスをチェックする
[引数]
なし
[戻り値]
void
2027 canvas = self.body.GetCanvas()
2028 tmp = self.ns_dict.GetCompState(self.
fullpath)
2029 if tmp == RTM.RTComponent.RTC_STARTING
or tmp == RTM.RTComponent.RTC_ACTIVE:
2031 elif tmp == RTM.RTComponent.RTC_READY
or tmp == RTM.RTComponent.RTC_STOPPING:
2033 elif tmp >= RTM.RTComponent.RTC_ABORTING :
2037 if canvas.viewMode ==
True and state !=
'unloaded':
2043 """コンポーネントにstart命令を発行
[引数]
なし
[戻り値]
void
2052 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
2053 ref = ref._narrow(RTM.RTCBase)
2056 err_mess =
'rtc_start error:%s\n'%self.
fullpath 2061 self.ns_dict.setCompBodyColor(self.
fullpath,
'active')
2062 self.
state =
'active' 2066 """コンポーネントにstop命令を発行
[引数]
なし
[戻り値]
void
2075 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
2076 ref = ref._narrow(RTM.RTCBase)
2079 err_mess =
'rtc_stop error:%s\n'%self.
fullpath 2084 self.ns_dict.setCompBodyColor(self.
fullpath,
'inactive')
2085 self.
state =
'inactive' 2089 """コンポーネントにreset命令を発行
[引数]
なし
[戻り値]
void
2098 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
2099 ref = ref._narrow(RTM.RTCBase)
2102 err_mess =
'rtc_reset error:%s\n'%self.
fullpath 2110 """コンポーネントにkill命令を発行
[引数]
なし
[戻り値]
void
2119 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
2120 ref = ref._narrow(RTM.RTCBase)
2123 err_mess =
'rtc_kill error:%s\n'%self.
fullpath 2128 self.ns_dict.setCompBodyColor(self.
fullpath,
'unloaded')
2129 self.
state =
'inactive' 2133 """コンポーネントにexit命令を発行
[引数]
なし
[戻り値]
void
2142 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
2143 ref = ref._narrow(RTM.RTCBase)
2146 err_mess =
'rtc_exit error:%s\n'%self.
fullpath 2151 self.ns_dict.setCompBodyColor(self.
fullpath,
'unloaded')
2152 self.
state =
'unloaded' 2156 """ステータスによりコンポーネントの色を設定する
[引数]
state --- コンポーネントの状態を指定する
2159 state --- コンポーネントの状態を指定する 2160 'active','inactive','error',unloaded','virtual' 2165 if state ==
'unloaded':
2166 self.
state =
'unloaded' 2167 self.
color = UNLOADED_COLOR
2168 elif state ==
'active' :
2169 self.
state =
'active' 2170 self.
color = ACTIVE_COLOR
2171 elif state ==
'inactive':
2172 self.
state =
'inactive' 2173 self.
color = INACTIVE_COLOR
2174 elif state ==
'error' :
2175 self.
state =
'error' 2176 self.
color = ERROR_COLOR
2178 canvas = self.parent.diagram.GetCanvas()
2179 dc = wx.ClientDC(canvas)
2180 canvas.PrepareDC(dc)
2181 if canvas.viewMode ==
True and self.
state !=
'unloaded':
2182 self.
state =
'virtual' 2183 self.
color = VIRTUAL_COLOR
2198 if outp[
'name']
in self.out_dict.keys():
2202 """リフレッシュ処理 コンポーネントのstateフラグで現在の状態(active,error,inactive等)を設定
[引数]
なし
[戻り値]
void
2203 コンポーネントのstateフラグで現在の状態(active,error,inactive等)を設定
[引数]
なし
[戻り値]
void
2211 old_state = self.
state 2212 canvas = self.body.GetCanvas()
2213 dc = wx.ClientDC(canvas)
2214 canvas.PrepareDC(dc)
2216 ref = self.ns_dict.GetObjRefToFullpath(self.
fullpath)
2217 ref = ref._narrow(RTM.RTCBase)
2218 tmp_port = ref._get_rtc_state()
2219 tmp_port = tmp_port._narrow(RTM.OutPort)
2220 tmp = tmp_port.get()
2223 print "refresh state:",tmp
2229 self.
state =
'unloaded' 2230 self.
color = UNLOADED_COLOR
2237 if outp[
'name']
in self.out_dict.keys():
2238 self.
out_dict[outp[
'name']].outport = outp
2240 if inp[
'name']
in self.in_dict.keys():
2241 self.
in_dict[inp[
'name']].inport = inp
2244 if tmp == RTM.RTComponent.RTC_STARTING
or tmp == RTM.RTComponent.RTC_ACTIVE:
2245 self.
state =
'active' 2246 self.
color = ACTIVE_COLOR
2247 elif tmp == RTM.RTComponent.RTC_STOPPING
or tmp == RTM.RTComponent.RTC_READY:
2248 self.
state =
'inactive' 2249 self.
color = INACTIVE_COLOR
2250 elif tmp >= RTM.RTComponent.RTC_ABORTING :
2251 self.
state =
'error' 2252 self.
color = ERROR_COLOR
2254 self.
state =
'unloaded' 2255 self.
color = UNLOADED_COLOR
2258 if len(self.out_dict.keys()) != len(self.
out_list):
2273 if old_lastrot ==
'LR':
2289 """コンポーネント図形を削除する インポート図形、アウトポート図形、関連する線も削除する
[引数]
dc -- 描画するデバイス・コンテキストを指定
rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
2290 インポート図形、アウトポート図形、関連する線も削除する
[引数]
dc -- 描画するデバイス・コンテキストを指定
rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
2293 dc -- 描画するデバイス・コンテキストを指定 rot -- 線の削除可否を指定する。(回転処理等で使用)
0:線を削除 / 1:線を削除しない
[戻り値]
void
2294 rot -- 線の削除可否を指定する。(回転処理等で使用) 0:線を削除 / 1:線を削除しない
[戻り値]
void
2301 canvas = self.body.GetCanvas()
2303 self.body.RemoveFromCanvas(canvas)
2308 self.bmp.RemoveFromCanvas(canvas)
2312 self.text.RemoveFromCanvas(canvas)
2316 if inp[
'name']
in self.in_dict.keys():
2319 if outp[
'name']
in self.out_dict.keys():
2327 rot -- 図形の回転処理を行うフラグ 2328 0:回転なし(座標を計算で求める) 1:回転あり(既存の座標を使用)
[戻り値]
void
2338 pos_x = self.
x + (BOX_WIDTH * self.
ratioW)/2
2339 pos_y = self.
y + self.
y_size/2
2345 canvas = self.parent.diagram.GetCanvas()
2346 dc = wx.ClientDC(canvas)
2347 canvas.PrepareDC(dc)
2348 cnt = len(self.
name)
2349 charW = dc.GetCharWidth()
2350 charH = dc.GetCharHeight()
2351 tmpW = charW * (cnt*1.2)
2357 self.text.AddText(self.
name)
2368 bitmap = wx.NullBitmap
2369 self.bmp.SetSize(10,10,
False)
2371 self.bmp.SetBitmap(bitmap)
2372 self.bmp.parent = self
2373 self.parent.MyAddBmp( self.
bmp, pos_x, pos_y, wx.BLACK_PEN )
2377 self.parent.MyAddShape(self.
baseBox, pos_x, pos_y, wx.BLACK_PEN, wx.Brush(self.
color, wx.SOLID),
"" ,0)
2380 self.body.AddChild(self.
baseBox)
2381 self.body.AddChild(self.
bmp)
2382 self.body.AddChild(self.
text)
2390 self.body.Recompute()
2391 self.body.CalculateSize()
2393 self.parent.MyAddShape(
2394 self.
body, pos_x, pos_y, wx.BLACK_PEN, wx.Brush(self.
color, wx.SOLID),
"" ,0)
2396 self.baseBox.lastx = self.body.GetX()
2397 self.baseBox.lasty = self.body.GetY()
2409 port_y = port_y + (POLYGON_SIZE*self.
ratioH)*2
2412 port_x = self.
x + (BOX_WIDTH*self.
ratioW) - (POLYGON_SIZE*self.
ratioW)/3
2413 port_y = self.
y + (POLYGON_SIZE*self.
ratioH)/2
2419 port_y = port_y + (POLYGON_SIZE*self.
ratioH)*2
2425 """コンポーネント図形の移動処理 インポート、アウトポート図形および関連する線も移動
[引数]
dc -- 描画するデバイス・コンテキストを指定
movex -- x座標の相対移動量を指定
movey -- y座標の相対移動量を指定
[戻り値]
void
2426 インポート、アウトポート図形および関連する線も移動 2429 dc -- 描画するデバイス・コンテキストを指定 movex -- x座標の相対移動量を指定
movey -- y座標の相対移動量を指定
[戻り値]
void
2430 movex -- x座標の相対移動量を指定 movey -- y座標の相対移動量を指定
[戻り値]
void
2431 movey -- y座標の相対移動量を指定
[戻り値]
void
2436 canvas = self.body.GetCanvas()
2438 self.
x = self.body.GetX() + movex
2439 self.
y = self.body.GetY() + movey
2441 self.body.Move(dc, self.
x, self.
y)
2444 if inp[
'name']
in self.in_dict.keys():
2447 if outp[
'name']
in self.out_dict.keys():
2452 """コンポーネント図形の選択処理(色の変更)
[引数]
なし
[戻り値]
void
2460 self.baseBox.SetBrush(wx.Brush(wx.NamedColor(SELECTED_COLOR)))
2466 """コンポーネント図形の非選択処理(色の変更)
[引数]
dc -- 描画していたデバイス・コンテキストを指定
[戻り値]
void
2469 dc -- 描画していたデバイス・コンテキストを指定
[戻り値]
void
2480 """コンポーネント図形(インポート/アウトポート)のサイズ変更処理 コンポーネント図形本体のサイズ変更はデフォルト(システム側)で行われる
[引数]
x -- 描画するx座標を指定
y -- 描画するy座標を指定
ratioW -- サイズ変更するWidthの比率を指定
ratioH -- サイズ変更するHeightの比率を指定
[戻り値]
void
2481 コンポーネント図形本体のサイズ変更はデフォルト(システム側)で行われる
[引数]
x -- 描画するx座標を指定
y -- 描画するy座標を指定
ratioW -- サイズ変更するWidthの比率を指定
ratioH -- サイズ変更するHeightの比率を指定
[戻り値]
void
2484 x -- 描画するx座標を指定 y -- 描画するy座標を指定
ratioW -- サイズ変更するWidthの比率を指定
ratioH -- サイズ変更するHeightの比率を指定
[戻り値]
void
2485 y -- 描画するy座標を指定 ratioW -- サイズ変更するWidthの比率を指定
ratioH -- サイズ変更するHeightの比率を指定
[戻り値]
void
2486 ratioW -- サイズ変更するWidthの比率を指定 ratioH -- サイズ変更するHeightの比率を指定
[戻り値]
void
2487 ratioH -- サイズ変更するHeightの比率を指定
[戻り値]
void
2496 self.
x_size, self.
y_size = self.baseBox.GetBoundingBoxMin()
2498 canvas = self.body.GetCanvas()
2499 dc = wx.ClientDC(canvas)
2500 canvas.PrepareDC(dc)
2513 self.body.Select(
False, dc)
2514 tmp = canvas.selected.index(self.
baseBox)
2515 del canvas.selected[tmp]
2518 self.baseBox.Select(
True, dc)
2519 canvas.selected.append(self.
baseBox)
2528 port_x = self.
x - self.
x_size/2 + x_size -1
2529 port_y = self.
y - self.
y_size/2 + y_size -1
2531 if in_pos ==
'Right':
2532 port_x = self.
x + self.
x_size/2 + x_size/6
2533 elif in_pos ==
'Left':
2534 port_x = self.
x - self.
x_size/2 - x_size/6
2535 elif in_pos ==
'Top':
2536 port_y = self.
y - self.
y_size/2 - y_size/6
2537 elif in_pos ==
'Bottom':
2538 port_y = self.
y + self.
y_size/2 + y_size/6
2541 if inp[
'name']
in self.in_dict.keys():
2544 if in_pos ==
'Right' or in_pos ==
'Left':
2545 port_y = port_y + y_size*2
2547 port_x = port_x + x_size*2
2554 port_x = self.
x - self.
x_size/2 + x_size -1
2555 port_y = self.
y - self.
y_size/2 + y_size -1
2557 if out_pos ==
'Right':
2558 port_x = self.
x + self.
x_size/2 + x_size/6
2559 elif out_pos ==
'Left':
2560 port_x = self.
x - self.
x_size/2 - x_size/6
2561 elif out_pos ==
'Top':
2562 port_y = self.
y - self.
y_size/2 - y_size/6
2563 elif out_pos ==
'Bottom':
2564 port_y = self.
y + self.
y_size/2 + y_size/6
2567 if outp[
'name']
in self.out_dict.keys():
2570 if out_pos ==
'Right' or out_pos ==
'Left':
2571 port_y = port_y + y_size*2
2573 port_x = port_x + x_size*self.
ratioW*2
2581 self.text.SetY(self.
text_y)
2585 tmpw, tmph = self.bmp.GetBoundingBoxMin()
2586 pos_y = self.
y - self.
y_size/2 + tmph/2
2588 pos_y = pos_y + self.
py_size/2
2590 self.bmp.SetY(pos_y)
2597 """左右反転(回転)処理
[引数]
なし
[戻り値]
void
2610 self.
x = self.baseBox.GetX()
2611 self.
y = self.baseBox.GetY()
2613 center_x = self.baseBox.GetX()
2614 center_y = self.baseBox.GetY()
2617 self.
x_size, self.
y_size = self.baseBox.GetBoundingBoxMin()
2620 self.
y_size, self.
x_size = self.baseBox.GetBoundingBoxMin()
2623 canvas = self.body.GetCanvas()
2624 dc = wx.ClientDC(canvas)
2625 canvas.PrepareDC(dc)
2636 port_x = self.
x - self.
x_size/2 - p_size/6
2637 port_y = self.
y - self.
y_size/2 + p_size-1
2639 if inp[
'name']
in self.in_dict.keys():
2640 self.
in_dict[inp[
'name']].position =
'Left' 2642 port_y = port_y + p_size*2
2644 port_x = self.
x + self.
x_size/2 + p_size/6
2645 port_y = self.
y - self.
y_size/2 + p_size-1
2647 if outp[
'name']
in self.out_dict.keys():
2648 self.
out_dict[outp[
'name']].position =
'Right' 2650 port_y = port_y + p_size*2
2653 port_x = self.
x + self.
x_size/2 + p_size/6
2654 port_y = self.
y - self.
y_size/2 + p_size-1
2656 if inp[
'name']
in self.in_dict.keys():
2657 self.
in_dict[inp[
'name']].position =
'Right' 2659 port_y = port_y + p_size*2
2661 port_x = self.
x - self.
x_size/2 - p_size/6
2662 port_y = self.
y - self.
y_size/2 + p_size-1
2664 if outp[
'name']
in self.out_dict.keys():
2665 self.
out_dict[outp[
'name']].position =
'Left' 2667 port_y = port_y + p_size*2
2672 self.text.SetY(self.
text_y)
2680 """上下回転処理
[引数]
なし
[戻り値]
void
2689 self.
x = center_x = self.baseBox.GetX()
2690 self.
y = center_y = self.baseBox.GetY()
2693 self.
y_size, self.
x_size = self.baseBox.GetBoundingBoxMin()
2696 self.
x_size, self.
y_size = self.baseBox.GetBoundingBoxMin()
2699 canvas = self.body.GetCanvas()
2700 dc = wx.ClientDC(canvas)
2701 canvas.PrepareDC(dc)
2720 port_x = self.
x - self.
x_size/2 + p_size-1
2721 port_y = self.
y - self.
y_size/2 - p_size/6
2723 if inp[
'name']
in self.in_dict.keys():
2724 self.
in_dict[inp[
'name']].position =
'Top' 2726 port_x = port_x + p_size*2
2728 port_x = self.
x - self.
x_size/2 + p_size-1
2729 port_y = self.
y + self.
y_size/2 + p_size/6
2731 if outp[
'name']
in self.out_dict.keys():
2732 self.
out_dict[outp[
'name']].position =
'Bottom' 2734 port_x = port_x + p_size*2
2737 port_x = self.
x - self.
x_size/2 + p_size-1
2738 port_y = self.
y + self.
y_size/2 + p_size/6
2740 if inp[
'name']
in self.in_dict.keys():
2741 self.
in_dict[inp[
'name']].position =
'Bottom' 2743 port_x = port_x + p_size*2
2745 port_x = self.
x - self.
x_size/2 + p_size-1
2746 port_y = self.
y - self.
y_size/2 - p_size/6
2748 if outp[
'name']
in self.out_dict.keys():
2749 self.
out_dict[outp[
'name']].position =
'Top' 2751 port_x = port_x + p_size*2
2756 self.text.SetY(self.
text_y)
2760 tmpw, tmph = self.bmp.GetBoundingBoxMin()
2763 self.bmp.SetY(pos_y)
2771 """ビットマップ用のダミーイベントクラス""" 2776 log -- ログ出力クラスのオブジェクト frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2777 frame -- ステータスバーのオブジェクト ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2778 ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2783 ogl.ShapeEvtHandler.__init__(self)
2788 """ドラッグ終了時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2789 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2794 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント
[戻り値]
void
2795 attachment -- アタッチメント
[戻り値]
void
2803 """マウス左クリック時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2804 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2809 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント
[戻り値]
void
2810 attachment -- アタッチメント
[戻り値]
void
2818 """サイズ変更終了時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
pt -- コントロールポイント
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2819 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
pt -- コントロールポイント
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2822 pt -- コントロールポイント x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2825 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント
[戻り値]
void
2826 attachment -- アタッチメント
[戻り値]
void
2834 """ドラッグ開始時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2835 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント
[戻り値]
void
2840 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント
[戻り値]
void
2841 attachment -- アタッチメント
[戻り値]
void
2849 class MyEvtHandlerOval(ogl.ShapeEvtHandler):
2850 """線移動用の円のイベントクラス""" 2852 """クラスの初期化(ShapeEvtHandlerの作成)
[引数]
log -- ログ出力クラスのオブジェクト
frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2855 log -- ログ出力クラスのオブジェクト frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2856 frame -- ステータスバーのオブジェクト ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2857 ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2862 ogl.ShapeEvtHandler.__init__(self)
2867 """ドラッグ終了時に呼ばれるイベントハンドラ ドラッグフラグをoffにする
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2868 ドラッグフラグをoffにする
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2873 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
2874 attachment -- アタッチメント(未使用)
[戻り値]
void
2882 """ドラッグ開始時に呼ばれるイベントハンドラ ドラッグフラグをonにする
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2883 ドラッグフラグをonにする
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2888 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
2889 attachment -- アタッチメント(未使用)
[戻り値]
void
2897 """ドラッグ開始時に呼ばれるイベントハンドラ 移動用の円をドラッグで移動(円のdmoveメソッド内で関連する線も移動させる)
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2898 移動用の円をドラッグで移動(円のdmoveメソッド内で関連する線も移動させる)
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2903 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
2904 attachment -- アタッチメント(未使用)
[戻り値]
void
2910 shape = self.GetShape()
2915 canvas = shape.GetCanvas()
2917 canvas.PrepareDC(dc)
2919 movex = x - shape.lastx
2920 movey = y - shape.lasty
2922 shape.parent.dmove(dc,movex,movey)
2924 shape.lastx = shape.GetX()
2925 shape.lasty = shape.GetY()
2931 """ダミーイベントハンドラ ""
def __init__(self, log, frame):
"""クラスの初期化
[引数]
log -- ログ出力クラスのオブジェクト
frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
"""
ogl.ShapeEvtHandler.__init__(self)
self.log = log
ogl.ShapeEvtHandler.__init__(self)
self.log = log
self.statbarFrame = frame
def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
"""ドラッグ終了時に呼ばれるイベントハンドラ
処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
pass
def OnDragLeft(self, draw, x, y, keys=0, attachment=0):
"""ドラッグ時に呼ばれるイベントハンドラ
処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
pass
def OnBeginDragLeft(self, x, y, keys, attachment):
"""ドラッグ開始時に呼ばれるイベントハンドラ
処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
pass
def OnLeftClick(self, x, y, keys = 0, attachment = 0):
"""マウス左クリックに呼ばれるイベントハンドラ
処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
pass
#----------------------------------------------------------------------
class MyEvtHandlerLine(ogl.ShapeEvtHandler):
"""線のイベントクラス"""
def __init__(self ):
"""クラスの初期化
[引数]
なし
[戻り値]
void
"""
ogl.ShapeEvtHandler.__init__(self)
def OnLeftClick(self, x, y, keys = 0, attachment = 0):
"""マウス左クリック時に呼ばれるイベントハンドラ
線の選択/解除を行う
選択処理では、移動用の円も作成する
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
# print shape.__class__, shape.GetClassName()
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
# 線が選択済み
if shape in canvas.selected:
# 選択状態の解除
for obj in shape.parent.lines:
obj.Select(False, dc)
shape.parent.unselected(dc)
for obj in canvas.selected:
if shape == obj:
obj.parent.unselected(dc)
idx = canvas.selected.index(obj)
del canvas.selected[idx]
# 線が未選択
else:
# 選択状態に移行
redraw = False
shapeList = canvas.GetDiagram().GetShapeList()
if canvas.selected and keys != 1:
for s in canvas.selected:
s.Select(False, dc)
s.parent.unselected(dc)
canvas.selected = []
canvas.Redraw(dc)
shape.parent.selected()
for obj in shape.parent.lines:
canvas.selected.append(obj)
# create oval on line
line = shape.parent
if (line.coordT == None) or (len(line.coordT) == 2):
return
# 線移動用の円を生成
num = len(line.coordT)
line.oval_dict = {}
for oval_id in range(1,num-2):
line_pos_0 = line.coordT[oval_id]
line_pos_1 = line.coordT[oval_id+1]
if line_pos_0[0] == line_pos_1[0] and line_pos_0[1] != line_pos_1[1]: # width line
hight = line_pos_0[1] - line_pos_1[1]
pos_y = line_pos_1[1] + (hight/2)
pos_x = line_pos_0[0]
tag = (oval_id, "oval_width_pos")
elif line_pos_0[0] != line_pos_1[0] and line_pos_0[1] == line_pos_1[1] : # length line
width = line_pos_0[0] - line_pos_1[0]
pos_x = line_pos_1[0] + (width/2)
pos_y = line_pos_1[1]
tag = (oval_id, "oval_length_pos")
line.oval_dict[oval_id] = GRectOval(line, tag, pos_x, pos_y)
line.parent.parent.parent.MyAddOval(line.oval_dict[oval_id].body, pos_x, pos_y)
canvas.Redraw(dc)
#----------------------------------------------------------------------
class MyEvtHandler(ogl.ShapeEvtHandler):
"""コンポーネント図形(四角形)本体のイベントクラス"""
def __init__(self, log, frame):
"""クラスの初期化
[引数]
log -- ログ出力クラスのオブジェクト
frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
"""
ogl.ShapeEvtHandler.__init__(self)
self.log = log
self.statbarFrame = frame
self.dragOn = 0
def UpdateStatusBar(self, shape):
"""ステータスバーへ表示する情報の更新
[引数]
shape -- 図形のオブジェクトを指定
[戻り値]
void
"""
x,y = shape.GetX(), shape.GetY()
width, height = shape.GetBoundingBoxMax()
self.statbarFrame.SetStatusText("Pos: (%d,%d) Size: (%d, %d)" %
(x, y, width, height))
def OnLeftClick(self, x, y, keys = 0, attachment = 0):
"""マウス左クリック時に呼ばれるイベントハンドラ
本体の選択/解除を行う
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
# print shape.__class__, shape.GetClassName()
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
# クリック時、プロファイル表示
ref = self.statbarFrame.myDict.GetObjRefToFullpath(shape.parent.fullpath)
try:
ref = ref._narrow(RTM.RTCBase)
self.statbarFrame.profilepanel.RefreshProfile(ref._get_profile())
except:
except_mess("obj-ref error:")
# イベントで呼び出された図形が選択済みの場合
if shape in canvas.selected:
#if shape.parent.tag == 'body' or shape.parent.tag == 'line':
# 選択解除
canvas.lineFrom = None
shape.Select(False, dc)
shape.parent.unselected(dc)
for obj in canvas.selected:
if shape == obj:
idx = canvas.selected.index(obj)
del canvas.selected[idx]
canvas.Redraw(dc)
# イベントで呼び出された図形が未選択の場合
else:
# 選択状態へ移行
canvas.lineFrom = None
redraw = False
shapeList = canvas.GetDiagram().GetShapeList()
shape.Select(True, dc)
shape.parent.selected()
if canvas.selected and keys != 1:
for s in canvas.selected:
s.Select(False, dc)
s.parent.unselected(dc)
canvas.selected = []
canvas.Redraw(dc)
canvas.selected.append(shape)
self.UpdateStatusBar(shape)
def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
"""ドラッグ終了時に呼ばれるイベントハンドラ
選択状態の全図形を移動
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
if self.dragOn == 1:
shape = self.GetShape()
# self.base_OnEndDragLeft(x, y, keys, attachment)
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
movex = x - shape.lastx
movey = y - shape.lasty
# 選択状態の全図形を移動
for obj in canvas.selected:
# body/inport/outport
obj.parent.dmove(dc,movex,movey)
obj.lastx = obj.GetX()
obj.lasty = obj.GetY()
if obj.parent.tag != 'line':
obj.Select(True, dc)
canvas.Redraw(dc)
self.dragOn = 0
self.UpdateStatusBar(shape)
def OnSizingEndDragLeft(self, pt, x, y, keys, attch):
"""サイズ変更終了時に呼ばれるイベントハンドラ
[引数]
pt -- コントロールポイント
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
# デフォルトのサイズ変更イベントハンドラ呼び出し
self.base_OnSizingEndDragLeft(pt, x, y, keys, attch)
shape = self.GetShape()
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
# サイズ変更時のWidth,Heightの比率算出
width, height = shape.GetBoundingBoxMax()
ratioW = width / shape.parent.lastBBoxWidth
ratioH = height / shape.parent.lastBBoxHeight
tmpx,tmpy = shape.GetX(), shape.GetY()
# サイズ変更
shape.parent.updatePolygonSize(tmpx,tmpy,ratioW,ratioH)
self.UpdateStatusBar(shape)
canvas.Redraw(dc)
shape.parent.lastBBoxWidth, shape.parent.lastBBoxHeight = shape.GetBoundingBoxMax()
def OnDragLeft(self, draw, x, y, keys, attachment):
"""ドラッグ時に呼ばれるイベントハンドラ
選択状態の全図形を移動
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
canvas = shape.GetCanvas()
if self.dragOn == 1:
if shape not in canvas.selected:
pass
else:
width, height = shape.GetBoundingBoxMax()
self.statbarFrame.SetStatusText("Pos: (%d,%d) Size: (%d, %d)" %
(x, y, width, height))
# self.base_OnDragLeft(1, x, y, keys, attachment)
# メモリDC(BufferedDC)の生成:メモリ上に絵を描いて、Redrawdeで表に表示
dc = getBufferedDC(canvas)
canvas.PrepareDC(dc)
# 選択済みの図形を移動
movex = x - shape.lastx
movey = y - shape.lasty
for obj in canvas.selected:
obj.DeleteControlPoints()
# inport/outport
obj.parent.dmove(dc,movex,movey)
obj.lastx = obj.GetX()
obj.lasty = obj.GetY()
canvas.Redraw(dc)
def OnBeginDragLeft(self, x, y, keys, attachment):
"""ドラッグ開始時に呼ばれるイベントハンドラ
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
if shape not in canvas.selected:
shape.DeleteControlPoints()
if canvas.selected and keys != 1:
for s in canvas.selected:
s.Select(False, dc)
s.parent.unselected(dc)
canvas.selected = []
canvas.Redraw(dc)
shape.Select(True, dc)
shape.parent.selected()
canvas.selected.append(shape)
else:
for s in canvas.selected:
if s.parent.tag == 'line':
s.Select(False, dc)
s.parent.unselected(dc)
idx = canvas.selected.index(s)
del canvas.selected[idx]
canvas.Redraw(dc)
self.log.write("OnBeginDragLeft: %s, %s, %s\n" % (x, y, keys))
# self.base_OnBeginDragLeft(x, y, keys, attachment)
self.dragOn = 1
#----------------------------------------------------------------------
class MyPortEvtHandler(ogl.ShapeEvtHandler):
"""ポートのイベントクラス"""
def __init__(self, log, frame):
"""クラスの初期化
[引数]
log -- ログ出力クラスのオブジェクト
frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
"""
ogl.ShapeEvtHandler.__init__(self)
self.log = log
self.statbarFrame = frame
self.dragOn = 0
def UpdateStatusBar(self, shape):
"""ステータスバーへ表示する情報の更新
[引数]
shape -- 図形のオブジェクトを指定
[戻り値]
void
"""
x,y = shape.GetX(), shape.GetY()
width, height = shape.GetBoundingBoxMax()
self.statbarFrame.SetStatusText("Pos: (%d,%d) Size: (%d, %d)" %
(x, y, width, height))
def OnLeftClick(self, x, y, keys = 0, attachment = 0):
"""マウス左クリック時に呼ばれるイベントハンドラ
線を引く為の、開始点or終了点を設定
終了点を設定後は、2点間で線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
# print shape.__class__, shape.GetClassName()
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
ref = shape.parent.ns_dict.GetObjRefToFullpath(shape.parent.fullpath)
try:
ref = ref._narrow(RTM.RTCBase)
tmp = shape.parent.ns_dict.GetCompState(shape.parent.fullpath)
if tmp >= RTM.RTComponent.RTC_ABORTING or tmp == 0:
ref = None
except :
except_mess("except error:")
ref = None
if not ref:
return
if canvas.lineFrom == None:
canvas.lineFrom = shape
elif canvas.lineFrom != shape:
if canvas.lineFrom.parent.tag == 'in':
checktag = 'out'
else:
checktag = 'in'
if shape.parent.tag != checktag:
return
if shape.parent.fullpath == canvas.lineFrom.parent.fullpath:
return
canvas.lineTo = shape
line = GRtcLine(canvas,shape.parent)
line.setLine2port(canvas, dc)
line.g_outp.connect(line.idx, line.g_outp.subscription_type)
canvas.lineFrom = None
canvas.lineTo = None
canvas.Redraw(dc)
self.UpdateStatusBar(shape)
def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
"""ドラッグ終了時に呼ばれるイベントハンドラ
ポート上にマウスカーソルがあれば線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
ref = shape.parent.ns_dict.GetObjRefToFullpath(shape.parent.fullpath)
try:
ref = ref._narrow(RTM.RTCBase)
tmp = shape.parent.ns_dict.GetCompState(shape.parent.fullpath)
if tmp >= RTM.RTComponent.RTC_ABORTING or tmp == 0:
ref = None
except :
except_mess("except error:")
ref = None
if not ref:
return
if self.dragOn == 1:
# shape.parent.parent.blink.Stop()
self.dragOn = 0
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
canvas.moveLine.removeWidget(dc)
canvas.Redraw(dc)
tmpShape = canvas.FindShape(x,y)
if tmpShape == 0 or not hasattr(tmpShape[0], "parent") or not hasattr(tmpShape[0].parent, "ns_dict"):
return
ref = tmpShape[0].parent.ns_dict.GetObjRefToFullpath(tmpShape[0].parent.fullpath)
try:
ref = ref._narrow(RTM.RTCBase)
tmp = tmpShape[0].parent.ns_dict.GetCompState(tmpShape[0].parent.fullpath)
if tmp >= RTM.RTComponent.RTC_ABORTING or tmp == 0:
ref = None
if shape.parent.fullpath == tmpShape[0].parent.fullpath:
ref = None
except :
except_mess("except error:")
ref = None
if not ref:
return
if canvas.lineFrom.parent.tag == 'in':
checktag = 'out'
else:
checktag = 'in'
if tmpShape[0].parent.tag == checktag:
canvas.lineTo = tmpShape[0]
line = GRtcLine(canvas,shape.parent)
line.setLine2port(canvas, dc)
line.g_outp.connect(line.idx, line.g_outp.subscription_type)
canvas.lineFrom = None
canvas.lineTo = None
canvas.Redraw(dc)
else:
pass
def OnDragLeft(self, draw, x, y, keys, attachment):
"""ドラッグ時に呼ばれるイベントハンドラ
マウスカーソルと始点間で線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
shape = self.GetShape()
if self.dragOn == 1:
canvas = shape.GetCanvas()
dc = getBufferedDC(canvas)
canvas.PrepareDC(dc)
# create line
canvas.moveLine.setPoints(shape.GetX(), shape.GetY(), x, y)
canvas.moveLine.lines[0].SetPen(wx.Pen(SELECTED_COLOR, 1))
canvas.moveLine.lines[0].Show(True)
canvas.Redraw(dc)
else:
pass
def OnBeginDragLeft(self, x, y, keys, attachment):
"""ドラッグ開始時に呼ばれるイベントハンドラ
ドラッグによる線引き処理の開始(オブジェクトリファレンスが存在する場合)
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
"""
self.log.write("OnBeginDragLeft: %s, %s, %s\n" % (x, y, keys))
self.dragOn = 1
shape = self.GetShape()
ref = shape.parent.ns_dict.GetObjRefToFullpath(shape.parent.fullpath)
try:
ref = ref._narrow(RTM.RTCBase)
tmp = shape.parent.ns_dict.GetCompState(shape.parent.fullpath)
if tmp >= RTM.RTComponent.RTC_ABORTING or tmp == 0:
ref = None
except :
ref = None
except_mess("except error:")
if ref:
canvas = shape.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
canvas.lineFrom = shape
# make line
canvas.moveLine = GRtcLine(canvas, shape.parent)
canvas.moveLine.setPoints(shape.GetX(), shape.GetY(), x, y)
canvas.moveLine.lines[0].SetPen(wx.Pen(SELECTED_COLOR, 1))
canvas.moveLine.lines[0].Show(True)
# shape.parent.parent.blink.setBlinkState(shape.parent.parent, 'inactive', 'active')
# shape.parent.parent.blink.Start(500)
else:
self.dragOn = 0
#----------------------------------------------------------------------
class RtdSystemDraw(ogl.ShapeCanvas):
"""図形描画用のキャンバス生成クラス"""
def __init__(self, parent, log, frame):
"""クラスの初期化
[引数]
log -- ログ出力クラスのオブジェクト
frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
parent -- 親ウィンドウを指定
[戻り値]
void
"""
ogl.ShapeCanvas.__init__(self, parent)
maxWidth = 1000
maxHeight = 1000
# self.SetScrollbars(20, 20, maxWidth/20, maxHeight/20)
self.x_size = maxWidth
self.y_size = maxHeight
self.log = log
self.frame = frame
self.SetBackgroundColour(wx.WHITE)
self.diagram = ogl.Diagram()
self.save_gdi = []
self.SetDiagram(self.diagram)
self.diagram.SetCanvas(self)
self.tooltip = None
self.rtc_dict = {}
self.rtc_list = []
canvas = self.diagram.GetCanvas()
canvas.lineFrom = None
canvas.lineTo = None
canvas.line_idx = 0
canvas.line = {}
canvas.moveLine = None
canvas.selected = []
canvas.viewMode = False
rRectBrush = wx.Brush("MEDIUM TURQUOISE", wx.SOLID)
dsBrush = wx.Brush("WHITE", wx.SOLID)
# ドラッグ&ドロップ:ドロップターゲットの設定
dt = MyTextDropTarget(self, log)
self.SetDropTarget(dt)
# イベントの割付
self.Bind(wx.EVT_WINDOW_DESTROY, self.OnDestroy)
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
self.Bind(wx.EVT_LEFT_DOWN, self.OnLeftDown)
self.Bind(wx.EVT_MIDDLE_DOWN, self.OnMiddleDown)
self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
def changeCompColor(self, fullname, state) :
"""コンポーネント単体の色を変更(rtc_state()参照)
[引数]
fullname -- コンポーネントのフルパス名
[戻り値]
void
"""
if fullname in self.rtc_list:
# self.rtc_dict[fullname].refresh()
self.rtc_dict[fullname].changeBodyColor(state)
self.rtc_dict[fullname].state = state
def search_g_inp(self, inp_ref) :
"""インポートの検索
[引数]
inp_ref -- インポートのオブジェクトリファレンス
[戻り値]
g_inp -- インポートのディクショナリー
"""
print "len rtc_list:",len(self.rtc_list)
for rtc_name in self.rtc_list :
g_rtc = self.rtc_dict[rtc_name]
ref = g_rtc.ns_dict.GetObjRefToFullpath(g_rtc.fullpath)
if ref :
print "len in_list:",len(g_rtc.in_list)
for inp in g_rtc.in_list :
print "inp_ref:",inp_ref, " == ", g_rtc.in_dict[inp['name']].inport['ref']
if inp_ref._is_equivalent(g_rtc.in_dict[inp['name']].inport['ref']) :
print "_is_equivalent is OK!!!"
return g_rtc.in_dict[inp['name']]
def openFileDialog(self):
wildcard = "*.xml |*.xml| *.* |*.*"
dialog = wx.FileDialog( self, strOPEN_TITLE, defaultDir=os.getcwd(),
defaultFile="", wildcard=wildcard, style=wx.OPEN)
if dialog.ShowModal() != wx.ID_OK:
return None
openFileName = dialog.GetPath()
dialog.Destroy()
return openFileName
def loadXML(self):
if len(self.rtc_dict) > 0:
ret = self.askDialog(strDEL_SYS)
if ret != wx.ID_OK:
return
openFileName = self.openFileDialog()
print "open file is :",openFileName
if openFileName == None:
return
# delete
self.deleteAllShape()
rtxml = RtmParser.RtmParser()
dict = rtxml.readXML(openFileName)
canvas = self.diagram.GetCanvas()
canvas.viewMode = True
self.createGRtc_from_dict(dict)
def saveFileDialog(self):
wildcard = "*.xml |*.xml| *.* |*.*"
dialog = wx.FileDialog( self, strSAVE_AS_TITLE, defaultDir=os.getcwd(),
defaultFile="", wildcard=wildcard, style=wx.SAVE)
if dialog.ShowModal() != wx.ID_OK:
return None
saveFileName = dialog.GetPath()
dialog.Destroy()
return saveFileName
def makeDumpData(self):
canvas = self.diagram.GetCanvas()
dict = {}
dict['rtc'] = {}
dict['line'] = []
for fullname in self.rtc_list:
comp = self.rtc_dict[fullname]
name = fullname
x_size, y_size = comp.baseBox.GetBoundingBoxMin()
if comp.lastRot == 'TB':
y_size, x_size = x_size, y_size
x = comp.baseBox.GetX() - x_size/2
y = comp.baseBox.GetY() - y_size/2
# print "Comp name:",name," x=",x," y=",y
dict['rtc'][name] = {}
dict['rtc'][name]['x'] = x
dict['rtc'][name]['y'] = y
if comp.lastRot == 'LR':
if comp.revTogle == 1:
dict['rtc'][name]['rot'] = 'Right'
else:
dict['rtc'][name]['rot'] = 'Left'
else:
if comp.rotTogle == 1:
dict['rtc'][name]['rot'] = 'Top'
else:
dict['rtc'][name]['rot'] = 'Bottom'
# comp.rotTogle # 1 or 0 # 1 :inport's is top side of body
# comp.revTogle # 1 or 0 # 1 :inport's is right side of body
# comp.lastRot # LR(Left/Right) or TB(Top/Bottom)
for line_idx in canvas.line:
out_obj = canvas.line[line_idx].g_outp
in_obj = canvas.line[line_idx].g_inp
tmp = {}
# tmp['type'] =
tmp['pos'] = canvas.line[line_idx].coordT
tmp['in-comp'] = in_obj.fullpath
tmp['in-name'] = in_obj.inport['name']
tmp['out-comp'] = out_obj.fullpath
tmp['out-name'] = out_obj.outport['name']
dict['line'].append(tmp)
return dict
def saveXML(self, saveFileName):
dict = {}
dict = self.makeDumpData()
rtxml = RtmParser.RtmParser()
rtxml.writeXML(saveFileName, dict)
def saveAsXML(self):
saveFileName = self.saveFileDialog()
if saveFileName == None:
return
self.saveXML(saveFileName)
def refresh(self):
"""リフレッシュ処理
コンポーネント及び、表示図形のリフレッシュを行う
[引数]
なし
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
for obj in canvas.selected:
obj.Select(False, dc)
obj.parent.unselected(dc)
canvas.selected = []
for rtc_name in self.rtc_list:
self.rtc_dict[rtc_name].refresh()
for rtc_name in self.rtc_list:
self.rtc_dict[rtc_name].refresh_outp()
def reConnect(self):
"""再接続処理
画面上のコンポーネントの再接続処理を呼び出す
[引数]
なし
[戻り値]
void
"""
# assembly dummy process
# return
# assembly dummy process
for rtc_name in self.rtc_list:
self.rtc_dict[rtc_name].reConnectLine()
def remakeLines(self):
# assembly dummy process
# return
# assembly dummy process
for rtc_name in self.rtc_list:
self.rtc_dict[rtc_name].remakeLines()
def createGRtc_from_dict(self,dict):
"""ディクショナリーからコンポーネント図形を生成
[引数]
dict -- アセンブリのディクショナリー
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(canvas)
canvas.PrepareDC(dc)
rtc_list = dict['rtc'].keys()
self.rtc_dict = {}
new_list = []
pos_x = 0
pos_y = 0
for rtc_name in rtc_list:
# obj-ref error check
try:
ref = self.frame.myDict.GetObjRefToFullpath(rtc_name)
if ref == None:
print 'Component Create error!: %s'%rtc_name
continue
ref = ref._narrow(RTM.RTCBase)
tmp = self.frame.myDict.GetCompState(rtc_name)
# if tmp >= RTM.RTComponent.RTC_ABORTING or tmp == 0:
# ref = None
except:
err_mess = 'Component Create error:%s\n'%rtc_name
except_mess(err_mess)
continue
new_list.append(rtc_name)
pos_x = dict['rtc'][rtc_name]['x']
pos_y = dict['rtc'][rtc_name]['y']
comp = GRtc(self, rtc_name, pos_x, pos_y)
comp.changeBodyColor('virtual')
self.rtc_dict[rtc_name] = comp
if dict['rtc'][rtc_name]['rot'] == 'Left':
comp.reversesBody()
elif dict['rtc'][rtc_name]['rot'] == 'Top':
comp.rotatesBody()
elif dict['rtc'][rtc_name]['rot'] == 'Bottom':
comp.rotatesBody()
comp.rotatesBody()
comp.refresh()
if len(new_list) == 0:
canvas.viewMode = False
return
self.rtc_list = new_list
for line_num in range(len(dict['line'])):
line_dict = dict['line'][line_num]
out_comp_name = line_dict['out-comp']
out_name = line_dict['out-name']
in_comp_name = line_dict['in-comp']
in_name = line_dict['in-name']
#error check
if not self.rtc_dict.has_key(out_comp_name):
print 'Assembly Check: Port Connection Error!:',out_comp_name
continue
if not self.rtc_dict[out_comp_name].out_dict.has_key(out_name):
print 'Assembly Check: Port Connection Error!: ',out_comp_name,":",out_name
continue
if not self.rtc_dict.has_key(in_comp_name):
print 'Assembly Check: Port Connection Error!:',in_comp_name
continue
if not self.rtc_dict[in_comp_name].in_dict.has_key(in_name):
print 'Assembly Check: Port Connection Error!: ',in_comp_name,":",in_name
continue
outp_obj = self.rtc_dict[out_comp_name].out_dict[out_name]
inp_obj = self.rtc_dict[in_comp_name].in_dict[in_name]
canvas.lineFrom = outp_obj.body
canvas.lineTo = inp_obj.body
line = GRtcLine(canvas,outp_obj)
line.setLine2port(canvas, dc)
line.g_outp.connect(line.idx, line.g_outp.subscription_type)
pos = []
pos_list = []
pos_list = string.splitfields(line_dict['pos'],',')
for num in range(len(pos_list)/2):
pos.append((string.atof(pos_list[num*2]),string.atof(pos_list[num*2+1])))
#line.move_child
line.childMove(dc, pos)
canvas.lineFrom = None
canvas.lineTo = None
canvas.Redraw(dc)
def MyAddBmp(self, shape, x, y, pen):
"""ビットマップ図形の登録
キャンバス、ダイアグラム、イベントとの関連付け
[引数]
shape -- ビットマップ図形を指定
x -- 表示するx座標
y -- 表示するy座標
pen -- ペン(色、太さ)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
"""
shape.SetDraggable(False, False)
shape.SetCanvas(self)
if pen: shape.SetPen(pen)
shape.SetX(x)
shape.SetY(y)
self.diagram.AddShape(shape)
evthandler = MyEvtHandlerBmp(self.log, self.frame)
evthandler.SetShape(shape)
evthandler.SetPreviousHandler(shape.GetEventHandler())
shape.SetEventHandler(evthandler)
shape.Show(True)
return shape
def MyAddOval(self, shape, x, y):
"""円図形の登録
キャンバス、ダイアグラム、イベントとの関連付け
[引数]
shape -- ビットマップ図形を指定
x -- 表示するx座標
y -- 表示するy座標
[戻り値]
shape -- wx.Shape 図形オブジェクト
"""
shape.SetDraggable(True, False)
shape.SetCanvas(self)
shape.SetX(x)
shape.SetY(y)
self.diagram.AddShape(shape)
evthandler = MyEvtHandlerOval(self.log, self.frame)
evthandler.SetShape(shape)
evthandler.SetPreviousHandler(shape.GetEventHandler())
shape.SetEventHandler(evthandler)
shape.Show(True)
return shape
def MyAddText(self, shape, x, y, pen, brush=None ):
"""テキストの登録
キャンバス、ダイアグラム、イベントとの関連付け
[引数]
shape -- ビットマップ図形を指定
x -- 表示するx座標
y -- 表示するy座標
pen -- ペン(色、太さ)を指定
burush -- ブラシ(色)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
"""
shape.SetDraggable(False, False)
shape.SetCanvas(self)
shape.SetX(x)
shape.SetY(y)
if pen: shape.SetPen(pen)
if brush: shape.SetBrush(brush)
self.diagram.AddShape(shape)
evthandler = MyEvtHandlerDummy(self.log, self.frame)
evthandler.SetShape(shape)
evthandler.SetPreviousHandler(shape.GetEventHandler())
shape.SetEventHandler(evthandler)
shape.Show(True)
return shape
def MyAddShape(self, shape, x, y, pen, brush, text, inoutPort=0):
"""コンポーネント図形、ポート図形の登録
キャンバス、ダイアグラム、イベントとの関連付け
[引数]
shape -- ビットマップ図形を指定
x -- 表示するx座標
y -- 表示するy座標
pen -- ペン(色、太さ)を指定
burush -- ブラシ(色)を指定
text -- 図形に表示する文字列を指定
inoutPort -- ポート指定フラグ
0:コンポーネント本体 / 1:Inpot,Outport
[戻り値]
shape -- wx.Shape 図形オブジェクト
"""
shape.SetDraggable(True, True)
shape.SetCanvas(self)
shape.SetX(x)
shape.SetY(y)
if pen: shape.SetPen(pen)
if brush: shape.SetBrush(brush)
if text: shape.AddText(text)
self.diagram.AddShape(shape)
shape.Show(True)
if inoutPort == 1: # make in/out port event handler
evthandler = MyPortEvtHandler(self.log, self.frame)
evthandler.SetShape(shape)
evthandler.SetPreviousHandler(shape.GetEventHandler())
shape.SetEventHandler(evthandler)
elif inoutPort == 0: # make body event handler
evthandler = MyEvtHandler(self.log, self.frame)
evthandler.SetShape(shape)
evthandler.SetPreviousHandler(shape.GetEventHandler())
shape.SetEventHandler(evthandler)
return shape
def OnDestroy(self, evt):
"""ウィンドウ削除イベントハンドラ
[引数]
evt -- イベント
[戻り値]
void
"""
# Do some cleanup
for shape in self.diagram.GetShapeList():
if shape.GetParent() == None:
shape.SetCanvas(None)
shape.Destroy()
self.diagram.Destroy()
def deleteShape(self,obj):
"""図形を削除する
[引数]
削除を行うShapeオブジェクト
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
obj.parent.removeWidget(dc)
if hasattr(obj, "parent") and obj.parent.tag == 'body':
rtc_name = obj.parent.fullpath
if rtc_name in self.rtc_list:
tmp = self.rtc_list.index(rtc_name)
del self.rtc_list[tmp]
del self.rtc_dict[rtc_name]
if hasattr(obj, "parent") and obj.parent.tag == 'line':
idx = obj.parent.idx
if idx in canvas.line.keys():
del canvas.line[idx]
del obj
def deleteAllShape(self):
"""すべての図形を削除する
[引数]
なし
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
for s in canvas.selected:
s.Select(False, dc)
s.parent.unselected(dc)
shapeList = canvas.GetDiagram().GetShapeList()
for obj in shapeList:
self.deleteShape(obj)
canvas.selected = []
canvas.line = {}
canvas.Redraw(dc)
def deleteSelectedShape(self):
"""選択中の図形を削除する
[引数]
なし
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
for obj in canvas.selected:
self.deleteShape(obj)
canvas.selected = []
bdc = getBufferedDC(canvas)
canvas.PrepareDC(dc)
canvas.Redraw(dc)
def OnKeyDown(self, evt):
"""キー押下時のイベントハンドラ
選択中の図形を削除する
[引数]
evt -- イベント
[戻り値]
void
"""
evtKey = evt.GetKeyCode()
# DELETE キーの時、選択されている図形を削除
if evtKey == wx.WXK_DELETE:
self.deleteSelectedShape()
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
bdc = getBufferedDC(canvas)
canvas.PrepareDC(bdc)
canvas.Redraw(bdc)
def OnPopupStart(self, evt):
"""コンポーネント本体のスタートを行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
pt = self.pt
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
tmpShape[0].parent.ref_start()
def OnPopupStop(self, evt):
"""コンポーネント本体のストップを行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
pt = self.pt
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
tmpShape[0].parent.ref_stop()
def OnPopupReset(self, evt):
pt = self.pt
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
tmpShape[0].parent.ref_reset()
def OnPopupExit(self, evt):
pt = self.pt
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
tmpShape[0].parent.ref_exit()
def OnPopupKill(self, evt):
pt = self.pt
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
tmpShape[0].parent.ref_kill()
def OnPopupDelete(self, evt):
"""コンポーネント本体の削除を行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
pt = self.pt
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
tmpShape[0].parent.removeWidget(dc)
# rtc_name = tmpShape[0].parent.rtc.ref_key
rtc_name = tmpShape[0].parent.fullpath
del self.rtc_dict[rtc_name]
tmp = self.rtc_list.index(rtc_name)
del self.rtc_list[tmp]
for obj in canvas.selected:
if obj == tmpShape[0]:
tmp = canvas.selected.index(tmpShape[0])
del canvas.selected[tmp]
bdc = getBufferedDC(canvas)
canvas.PrepareDC(bdc)
# canvas.Redraw(bdc)
canvas.Redraw(dc)
def OnPopupSub(self, evt):
"""サブメニューの実験用ダミーイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
print "OnPopupSub!!!"
def OnPopupDelSelectItem(self, evt):
"""選択されたアイテムの削除を行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
self.deleteSelectedShape()
def OnPopupLoadXML(self, evt):
"""XMLファイル(comp_data.xml)を読み込むイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
self.loadXML()
def OnPopupSaveDefaultXML(self, evt):
"""XMLファイル(アセンブリ)を書き込むイベントハンドラ
上書き保存
ファイル名:System?.xml ・・・ ? には画面番号が入る
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
filename = "System%d.xml" % self.frame.drawCurNum
self.saveXML(filename)
def OnPopupSaveXML(self, evt):
"""XMLファイル(アセンブリ)を書き込むイベントハンドラ
ファイル名変更で保存
ファイル名は、ダイアログでユーザ任意指定
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
self.saveAsXML()
def OnPopupRefresh(self, evt):
"""Refresh処理を行うイベントハンドラ
古い接続(コンポーネント上にだけsubuscribe情報がある。画面に線が表示されていない状態)が
あるときに、ok/cancelダイアログを表示し、再接続と最新のステータスで色を変更する
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
# yes/no dialog
val = self.DelOldConnectAskDialog()
if val != wx.ID_OK:
return
self.refresh()
self.reConnect()
def checkOtherConnect(self):
ret = False
for rtc_name in self.rtc_list:
ret = self.rtc_dict[rtc_name].checkOtherConnect()
if ret == True:
break
return ret
def askDialog(self, str):
"""ダイアログの表示機能
ok/cancel ダイアログを表示する
[引数]
str --- ダイアログに表示するメッセージ
[戻り値]
val --- ダイアログの戻り値(wx.ID_OK/wx.ID_CANCEL)
void
"""
# yes/no dialog
val = wx.ID_OK
dlg = RtmDialog(self, -1, str)
dlg.CenterOnParent()
val = dlg.ShowModal()
dlg.Destroy()
return val
def DelOldConnectAskDialog(self):
"""ダイアログの表示機能
古い接続(コンポーネント上にsubscribe情報があり画面上には線が表示されていない)があれば、
ok/cancel ダイアログを表示する
[引数]
なし
[戻り値]
val --- ダイアログの戻り値(wx.ID_OK/wx.ID_CANCEL)
古い情報がない時は、wx.ID_OKを返す
void
"""
# assembly dummy
# return wx.ID_OK
# assembly dummy
# yes/no dialog
val = wx.ID_OK
connect_flag = self.checkOtherConnect()
if connect_flag == True:
val = askDialog(strASKMESSAGE)
return val
def OnPopupConnectView(self, evt):
"""Connectメニューの処理を行うイベントハンドラ
アセンブリファイル読み込み後の接続(subscribe)処理
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
canvas = self.diagram.GetCanvas()
# yes/no dialog
val = self.DelOldConnectAskDialog()
if val != wx.ID_OK:
return
canvas.viewMode = False
self.refresh()
self.reConnect()
def OnPopupDeleteView(self, evt):
"""Deleteメニューの処理を行うイベントハンドラ
アセンブリファイル読み込み後の表示画像の全削除処理
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
"""
self.deleteAllShape()
canvas = self.diagram.GetCanvas()
canvas.viewMode = False
def makeBodyPopupMenu(self, evt):
"""コンポーネント上のポップアップメニュー(コンテキストメニュー)作成
コンポーネント図形本体のOn/Off、削除をメニュー表示
[引数]
evt -- イベント(wx.MouseEvent)を指定
[戻り値]
void
"""
# メニュー関連のイベントはCommandEventで、マウスカーソル座標を取得出来ない
# ここでは、座標をself.ptに格納し直後のメニューイベントで使用する
self.pt = evt.GetPosition()
if not hasattr(self, "popupID1"):
self.popupID1 = wx.NewId() # start menu
self.popupID2 = wx.NewId() # stop menu
self.popupID3 = wx.NewId() # delete menu
self.popupID4 = wx.NewId() # reset menu
self.popupID5 = wx.NewId() # exit menu
self.popupID6 = wx.NewId() # kill menu
self.Bind(wx.EVT_MENU, self.OnPopupStart, id = self.popupID1)
self.Bind(wx.EVT_MENU, self.OnPopupStop, id = self.popupID2)
self.Bind(wx.EVT_MENU, self.OnPopupDelete, id = self.popupID3)
self.Bind(wx.EVT_MENU, self.OnPopupReset, id = self.popupID4)
self.Bind(wx.EVT_MENU, self.OnPopupExit, id = self.popupID5)
self.Bind(wx.EVT_MENU, self.OnPopupKill, id = self.popupID6)
menu = wx.Menu()
menu.Append(self.popupID1, strSTART)
menu.Append(self.popupID2, strSTOP)
menu.Append(self.popupID4, strRESET)
menu.Append(self.popupID5, strEXIT)
menu.Append(self.popupID6, strKILL)
menu.AppendSeparator()
menu.Append(self.popupID3, strDELITEM)
self.PopupMenu(menu, evt.GetPosition())
menu.Destroy()
def makeBackgroundPopupMenu(self, evt ):
"""バックグランド上のポップアップメニュー(コンテキストメニュー)作成
削除、ロード、セーブのメニュー表示
[引数]
evt -- イベント(wx.MouseEvent)を指定
[戻り値]
void
"""
# メニュー関連のイベントはCommandEventで、マウスカーソル座標を取得出来ない
# ここでは、座標をself.ptに格納し直後のメニューイベントで使用する
self.pt = evt.GetPosition()
if not hasattr(self, "popupIDa"):
self.popupIDa = wx.NewId() # selected item delete menu
self.popupIDb = wx.NewId() # refresh menu
self.popupIDc = wx.NewId() # xml file load menu
self.popupIDd = wx.NewId() # xml file save menu
self.popupIDe = wx.NewId() # xml file save as menu
self.Bind(wx.EVT_MENU, self.OnPopupDelSelectItem,id = self.popupIDa)
self.Bind(wx.EVT_MENU, self.OnPopupRefresh, id = self.popupIDb)
self.Bind(wx.EVT_MENU, self.OnPopupLoadXML, id = self.popupIDc)
self.Bind(wx.EVT_MENU, self.OnPopupSaveDefaultXML, id = self.popupIDd)
self.Bind(wx.EVT_MENU, self.OnPopupSaveXML, id = self.popupIDe)
menu = wx.Menu()
menu.Append(self.popupIDa, strDEL_SELECT)
menu.AppendSeparator()
menu.Append(self.popupIDb, strREFRESH)
menu.AppendSeparator()
menu.Append(self.popupIDc, strOPEN)
menu.Append(self.popupIDd, strSAVE)
menu.Append(self.popupIDe, strSAVE_AS)
# assembly disable
# menu.FindItemById(self.popupIDc).Enable(False)
# menu.FindItemById(self.popupIDd).Enable(False)
# menu.FindItemById(self.popupIDe).Enable(False)
# assembly disable
self.PopupMenu(menu, evt.GetPosition())
menu.Destroy()
def makeViewModePopupMenu(self, evt ):
"""バックグランド上のポップアップメニュー(コンテキストメニュー)作成
Connect、Delete のメニュー表示
[引数]
evt -- イベント(wx.MouseEvent)を指定
[戻り値]
void
"""
# メニュー関連のイベントはCommandEventで、マウスカーソル座標を取得出来ない
# ここでは、座標をself.ptに格納し直後のメニューイベントで使用する
self.pt = evt.GetPosition()
if not hasattr(self, "popupID01"):
self.popupID01 = wx.NewId() # selected item delete menu
self.popupID02 = wx.NewId() # xml file load menu
self.Bind(wx.EVT_MENU, self.OnPopupConnectView,id = self.popupID01)
self.Bind(wx.EVT_MENU, self.OnPopupDeleteView, id = self.popupID02)
menu = wx.Menu()
menu.Append(self.popupID01, strASM_CONNECT)
menu.AppendSeparator()
menu.Append(self.popupID02, strASM_DELETE)
self.PopupMenu(menu, evt.GetPosition())
menu.Destroy()
def OnRightDown(self, evt):
"""右クリック・ダウンのイベントハンドラ
マウスカーソルがInport/Outport上だと、ツールチップ(バルーンヘルプ)の表示を行う
コンポーネント本体上では、ポップアップメニューの表示を行う
[引数]
evt -- イベント
[戻り値]
void
"""
self.log.write("OnRightDown")
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
pt = evt.GetPosition()
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0:
if hasattr(tmpShape[0], 'parent'):
# Inport/Outportの処理
if tmpShape[0].parent.tag == 'in' or tmpShape[0].parent.tag == 'out':
# ツールチップの作成
self.tooltip = makeToolTip(tmpShape[0].parent,pt,dc)
self.tooltip.body.SetCanvas(canvas)
self.diagram.AddShape(self.tooltip.body)
self.tooltip.body.Show(True)
# コンポーネント本体の処理
elif tmpShape[0].parent.tag == 'body' and canvas.viewMode == False:
self.makeBodyPopupMenu(evt)
else:
if canvas.viewMode == False:
self.makeBackgroundPopupMenu(evt)
else:
self.makeViewModePopupMenu(evt)
canvas.Redraw(dc)
evt.Skip()
def OnRightUp(self, evt):
"""右クリック・アップのイベントハンドラ
ツールチップ(バルーンヘルプ)の削除を行う
[引数]
evt -- イベント
[戻り値]
void
"""
self.log.write("OnRightUp")
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
pt = evt.GetPosition()
if self.tooltip != None:
# ツールチップの削除
self.tooltip.removeWidget(dc)
del self.tooltip
self.tooltip = None
canvas.Redraw(dc)
evt.Skip()
def OnLeftDown(self, evt):
"""左クリック・ダウンのイベントハンドラ
キャンバス上の図形がない空間で左クリックされたら図形選択を解除する
[引数]
evt -- イベント
[戻り値]
void
"""
pt = evt.GetPosition()
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape == 0:
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
for s in canvas.selected:
s.Select(False, dc)
s.parent.unselected(dc)
canvas.selected = []
canvas.Redraw(dc)
else:
evt.Skip()
def OnMiddleDown(self, evt):
"""マウス中ボタン・ダウンのイベントハンドラ
コンポーネント図形の本体上で押されたら、回転処理を行う
[引数]
evt -- イベント
[戻り値]
void
"""
pt = evt.GetPosition()
isShift = evt.ShiftDown()
canvas = self.diagram.GetCanvas()
dc = wx.ClientDC(self)
canvas.PrepareDC(dc)
for s in canvas.selected:
s.Select(False, dc)
s.parent.unselected(dc)
canvas.selected = []
canvas.Redraw(dc)
tmpShape = self.FindShape(pt[0],pt[1])
if tmpShape != 0 and tmpShape[0].parent.tag == 'body' and isShift != True: ## Middle Button
self.log.write("OnMiddleDown: " )
tmpShape[0].parent.reversesBody()
elif tmpShape != 0 and tmpShape[0].parent.tag == 'body' and isShift == True: ## Shift Key Down & Middle Button
self.log.write("OnMiddleDown + Shift Key: " )
tmpShape[0].parent.rotatesBody()
else:
evt.Skip()
canvas.Redraw(dc)
#----------------------------------------------------------------------
def runTest(frame, nb, log):
# This creates some pens and brushes that the OGL library uses.
# It should be called after the app object has been created, but
# before OGL is used.
ogl.OGLInitialize()
wx.lib.colourdb.updateColourDB()
win = TestWindow(nb, log, frame)
return win
#----------------------------------------------------------------------
# The OGL library holds some resources that need to be freed before
# the app shuts down.
class __Cleanup:
def __del__(self, cleanup=ogl.OGLCleanUp):
cleanup()
# When this module gets cleaned up by Python then __cu will be cleaned
# up and it's __dell__ is called, which will then call ogl.OGLCleanUp.
__cu = __Cleanup()
overview = """\
The Object Graphics Library is a library supporting the creation and
manipulation of simple and complex graphic images on a canvas.
"""
if __name__ == '__main__':
import sys,os
import run
run.main(['', os.path.basename(sys.argv[0])] + sys.argv[1:])
""" 2936 log -- ログ出力クラスのオブジェクト frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2937 frame -- ステータスバーのオブジェクト ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2938 ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
2943 ogl.ShapeEvtHandler.__init__(self)
2945 ogl.ShapeEvtHandler.__init__(self)
2950 """ドラッグ終了時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2951 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2956 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
2957 attachment -- アタッチメント(未使用)
[戻り値]
void
2965 """ドラッグ時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2966 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2971 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
2972 attachment -- アタッチメント(未使用)
[戻り値]
void
2980 """ドラッグ開始時に呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2981 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2986 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
2987 attachment -- アタッチメント(未使用)
[戻り値]
void
2995 """マウス左クリックに呼ばれるイベントハンドラ 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
2996 処理を未実装(passのみ)でイベントを登録し、デフォルトの動作を抑止
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3001 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3002 attachment -- アタッチメント(未使用)
[戻り値]
void
3011 class MyEvtHandlerLine(ogl.ShapeEvtHandler):
3022 ogl.ShapeEvtHandler.__init__(self)
3025 """マウス左クリック時に呼ばれるイベントハンドラ 線の選択/解除を行う
選択処理では、移動用の円も作成する
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3027 選択処理では、移動用の円も作成する
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3032 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3033 attachment -- アタッチメント(未使用)
[戻り値]
void
3038 shape = self.GetShape()
3040 canvas = shape.GetCanvas()
3041 dc = wx.ClientDC(canvas)
3042 canvas.PrepareDC(dc)
3044 if shape
in canvas.selected:
3046 for obj
in shape.parent.lines:
3047 obj.Select(
False, dc)
3048 shape.parent.unselected(dc)
3049 for obj
in canvas.selected:
3051 obj.parent.unselected(dc)
3052 idx = canvas.selected.index(obj)
3053 del canvas.selected[idx]
3058 shapeList = canvas.GetDiagram().GetShapeList()
3060 if canvas.selected
and keys != 1:
3061 for s
in canvas.selected:
3063 s.parent.unselected(dc)
3064 canvas.selected = []
3067 shape.parent.selected()
3069 for obj
in shape.parent.lines:
3070 canvas.selected.append(obj)
3074 if (line.coordT ==
None)
or (len(line.coordT) == 2):
3078 num = len(line.coordT)
3080 for oval_id
in range(1,num-2):
3081 line_pos_0 = line.coordT[oval_id]
3082 line_pos_1 = line.coordT[oval_id+1]
3083 if line_pos_0[0] == line_pos_1[0]
and line_pos_0[1] != line_pos_1[1]:
3084 hight = line_pos_0[1] - line_pos_1[1]
3085 pos_y = line_pos_1[1] + (hight/2)
3086 pos_x = line_pos_0[0]
3087 tag = (oval_id,
"oval_width_pos")
3088 elif line_pos_0[0] != line_pos_1[0]
and line_pos_0[1] == line_pos_1[1] :
3089 width = line_pos_0[0] - line_pos_1[0]
3090 pos_x = line_pos_1[0] + (width/2)
3091 pos_y = line_pos_1[1]
3092 tag = (oval_id,
"oval_length_pos")
3093 line.oval_dict[oval_id] =
GRectOval(line, tag, pos_x, pos_y)
3094 line.parent.parent.parent.MyAddOval(line.oval_dict[oval_id].body, pos_x, pos_y)
3101 """コンポーネント図形(四角形)本体のイベントクラス""" 3106 log -- ログ出力クラスのオブジェクト frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
3107 frame -- ステータスバーのオブジェクト ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
3108 ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
3113 ogl.ShapeEvtHandler.__init__(self)
3119 """ステータスバーへ表示する情報の更新 3122 shape -- 図形のオブジェクトを指定
[戻り値]
void
3127 x,y = shape.GetX(), shape.GetY()
3128 width, height = shape.GetBoundingBoxMax()
3129 self.statbarFrame.SetStatusText(
"Pos: (%d,%d) Size: (%d, %d)" %
3130 (x, y, width, height))
3134 """マウス左クリック時に呼ばれるイベントハンドラ 本体の選択/解除を行う
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3140 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3141 attachment -- アタッチメント(未使用)
[戻り値]
void
3146 shape = self.GetShape()
3148 canvas = shape.GetCanvas()
3149 dc = wx.ClientDC(canvas)
3150 canvas.PrepareDC(dc)
3153 ref = self.statbarFrame.myDict.GetObjRefToFullpath(shape.parent.fullpath)
3155 ref = ref._narrow(RTM.RTCBase)
3156 self.statbarFrame.profilepanel.RefreshProfile(ref._get_profile())
3161 if shape
in canvas.selected:
3164 canvas.lineFrom =
None 3165 shape.Select(
False, dc)
3166 shape.parent.unselected(dc)
3167 for obj
in canvas.selected:
3169 idx = canvas.selected.index(obj)
3170 del canvas.selected[idx]
3175 canvas.lineFrom =
None 3177 shapeList = canvas.GetDiagram().GetShapeList()
3179 shape.Select(
True, dc)
3180 shape.parent.selected()
3182 if canvas.selected
and keys != 1:
3183 for s
in canvas.selected:
3185 s.parent.unselected(dc)
3186 canvas.selected = []
3189 canvas.selected.append(shape)
3195 """ドラッグ終了時に呼ばれるイベントハンドラ 選択状態の全図形を移動
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3201 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3202 attachment -- アタッチメント(未使用)
[戻り値]
void
3208 shape = self.GetShape()
3211 canvas = shape.GetCanvas()
3212 dc = wx.ClientDC(canvas)
3213 canvas.PrepareDC(dc)
3215 movex = x - shape.lastx
3216 movey = y - shape.lasty
3218 for obj
in canvas.selected:
3221 obj.parent.dmove(dc,movex,movey)
3223 obj.lastx = obj.GetX()
3224 obj.lasty = obj.GetY()
3226 if obj.parent.tag !=
'line':
3227 obj.Select(
True, dc)
3235 """サイズ変更終了時に呼ばれるイベントハンドラ
[引数]
pt -- コントロールポイント
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3238 pt -- コントロールポイント x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3241 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3242 attachment -- アタッチメント(未使用)
[戻り値]
void
3248 self.base_OnSizingEndDragLeft(pt, x, y, keys, attch)
3250 shape = self.GetShape()
3251 canvas = shape.GetCanvas()
3252 dc = wx.ClientDC(canvas)
3253 canvas.PrepareDC(dc)
3255 width, height = shape.GetBoundingBoxMax()
3256 ratioW = width / shape.parent.lastBBoxWidth
3257 ratioH = height / shape.parent.lastBBoxHeight
3258 tmpx,tmpy = shape.GetX(), shape.GetY()
3260 shape.parent.updatePolygonSize(tmpx,tmpy,ratioW,ratioH)
3263 shape.parent.lastBBoxWidth, shape.parent.lastBBoxHeight = shape.GetBoundingBoxMax()
3266 """ドラッグ時に呼ばれるイベントハンドラ 選択状態の全図形を移動
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3272 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3273 attachment -- アタッチメント(未使用)
[戻り値]
void
3278 shape = self.GetShape()
3279 canvas = shape.GetCanvas()
3281 if shape
not in canvas.selected:
3284 width, height = shape.GetBoundingBoxMax()
3285 self.statbarFrame.SetStatusText(
"Pos: (%d,%d) Size: (%d, %d)" %
3286 (x, y, width, height))
3291 canvas.PrepareDC(dc)
3294 movex = x - shape.lastx
3295 movey = y - shape.lasty
3296 for obj
in canvas.selected:
3297 obj.DeleteControlPoints()
3299 obj.parent.dmove(dc,movex,movey)
3301 obj.lastx = obj.GetX()
3302 obj.lasty = obj.GetY()
3307 """ドラッグ開始時に呼ばれるイベントハンドラ
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3312 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3313 attachment -- アタッチメント(未使用)
[戻り値]
void
3318 shape = self.GetShape()
3319 canvas = shape.GetCanvas()
3320 dc = wx.ClientDC(canvas)
3321 canvas.PrepareDC(dc)
3322 if shape
not in canvas.selected:
3323 shape.DeleteControlPoints()
3325 if canvas.selected
and keys != 1:
3326 for s
in canvas.selected:
3328 s.parent.unselected(dc)
3329 canvas.selected = []
3332 shape.Select(
True, dc)
3333 shape.parent.selected()
3334 canvas.selected.append(shape)
3337 for s
in canvas.selected:
3338 if s.parent.tag ==
'line':
3340 s.parent.unselected(dc)
3341 idx = canvas.selected.index(s)
3342 del canvas.selected[idx]
3345 self.log.write(
"OnBeginDragLeft: %s, %s, %s\n" % (x, y, keys))
3357 log -- ログ出力クラスのオブジェクト frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
3358 frame -- ステータスバーのオブジェクト ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
3359 ※上記引数は、demoプログラムの名残:削除可
[戻り値]
void
3364 ogl.ShapeEvtHandler.__init__(self)
3370 """ステータスバーへ表示する情報の更新 3373 shape -- 図形のオブジェクトを指定
[戻り値]
void
3378 x,y = shape.GetX(), shape.GetY()
3379 width, height = shape.GetBoundingBoxMax()
3380 self.statbarFrame.SetStatusText(
"Pos: (%d,%d) Size: (%d, %d)" %
3381 (x, y, width, height))
3385 """マウス左クリック時に呼ばれるイベントハンドラ 線を引く為の、開始点or終了点を設定
終了点を設定後は、2点間で線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3386 線を引く為の、開始点or終了点を設定 終了点を設定後は、2点間で線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3392 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3393 attachment -- アタッチメント(未使用)
[戻り値]
void
3398 shape = self.GetShape()
3400 canvas = shape.GetCanvas()
3401 dc = wx.ClientDC(canvas)
3402 canvas.PrepareDC(dc)
3403 ref = shape.parent.ns_dict.GetObjRefToFullpath(shape.parent.fullpath)
3405 ref = ref._narrow(RTM.RTCBase)
3406 tmp = shape.parent.ns_dict.GetCompState(shape.parent.fullpath)
3407 if tmp >= RTM.RTComponent.RTC_ABORTING
or tmp == 0:
3416 if canvas.lineFrom ==
None:
3417 canvas.lineFrom = shape
3418 elif canvas.lineFrom != shape:
3419 if canvas.lineFrom.parent.tag ==
'in':
3423 if shape.parent.tag != checktag:
3425 if shape.parent.fullpath == canvas.lineFrom.parent.fullpath:
3428 canvas.lineTo = shape
3429 line =
GRtcLine(canvas,shape.parent)
3430 line.setLine2port(canvas, dc)
3431 line.g_outp.connect(line.idx, line.g_outp.subscription_type)
3433 canvas.lineFrom =
None 3434 canvas.lineTo =
None 3441 """ドラッグ終了時に呼ばれるイベントハンドラ ポート上にマウスカーソルがあれば線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3442 ポート上にマウスカーソルがあれば線を引く 3447 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3448 attachment -- アタッチメント(未使用)
[戻り値]
void
3453 shape = self.GetShape()
3454 ref = shape.parent.ns_dict.GetObjRefToFullpath(shape.parent.fullpath)
3456 ref = ref._narrow(RTM.RTCBase)
3457 tmp = shape.parent.ns_dict.GetCompState(shape.parent.fullpath)
3458 if tmp >= RTM.RTComponent.RTC_ABORTING
or tmp == 0:
3469 canvas = shape.GetCanvas()
3470 dc = wx.ClientDC(canvas)
3471 canvas.PrepareDC(dc)
3472 canvas.moveLine.removeWidget(dc)
3474 tmpShape = canvas.FindShape(x,y)
3475 if tmpShape == 0
or not hasattr(tmpShape[0],
"parent")
or not hasattr(tmpShape[0].parent,
"ns_dict"):
3477 ref = tmpShape[0].parent.ns_dict.GetObjRefToFullpath(tmpShape[0].parent.fullpath)
3479 ref = ref._narrow(RTM.RTCBase)
3480 tmp = tmpShape[0].parent.ns_dict.GetCompState(tmpShape[0].parent.fullpath)
3481 if tmp >= RTM.RTComponent.RTC_ABORTING
or tmp == 0:
3483 if shape.parent.fullpath == tmpShape[0].parent.fullpath:
3491 if canvas.lineFrom.parent.tag ==
'in':
3495 if tmpShape[0].parent.tag == checktag:
3496 canvas.lineTo = tmpShape[0]
3497 line =
GRtcLine(canvas,shape.parent)
3498 line.setLine2port(canvas, dc)
3499 line.g_outp.connect(line.idx, line.g_outp.subscription_type)
3501 canvas.lineFrom =
None 3502 canvas.lineTo =
None 3508 """ドラッグ時に呼ばれるイベントハンドラ マウスカーソルと始点間で線を引く
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3514 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3515 attachment -- アタッチメント(未使用)
[戻り値]
void
3520 shape = self.GetShape()
3522 canvas = shape.GetCanvas()
3524 canvas.PrepareDC(dc)
3527 canvas.moveLine.setPoints(shape.GetX(), shape.GetY(), x, y)
3528 canvas.moveLine.lines[0].SetPen(wx.Pen(SELECTED_COLOR, 1))
3529 canvas.moveLine.lines[0].Show(
True)
3535 """ドラッグ開始時に呼ばれるイベントハンドラ ドラッグによる線引き処理の開始(オブジェクトリファレンスが存在する場合)
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3536 ドラッグによる線引き処理の開始(オブジェクトリファレンスが存在する場合)
[引数]
x -- イベント時のx座標
y -- イベント時のy座標
keys -- キー押下状態(SHIFT、CTRL)
attachment -- アタッチメント(未使用)
[戻り値]
void
3541 keys -- キー押下状態(SHIFT、CTRL) attachment -- アタッチメント(未使用)
[戻り値]
void
3542 attachment -- アタッチメント(未使用)
[戻り値]
void
3547 self.log.write(
"OnBeginDragLeft: %s, %s, %s\n" % (x, y, keys))
3549 shape = self.GetShape()
3550 ref = shape.parent.ns_dict.GetObjRefToFullpath(shape.parent.fullpath)
3552 ref = ref._narrow(RTM.RTCBase)
3553 tmp = shape.parent.ns_dict.GetCompState(shape.parent.fullpath)
3554 if tmp >= RTM.RTComponent.RTC_ABORTING
or tmp == 0:
3560 canvas = shape.GetCanvas()
3561 dc = wx.ClientDC(canvas)
3562 canvas.PrepareDC(dc)
3563 canvas.lineFrom = shape
3565 canvas.moveLine =
GRtcLine(canvas, shape.parent)
3566 canvas.moveLine.setPoints(shape.GetX(), shape.GetY(), x, y)
3567 canvas.moveLine.lines[0].SetPen(wx.Pen(SELECTED_COLOR, 1))
3568 canvas.moveLine.lines[0].Show(
True)
3578 """図形描画用のキャンバス生成クラス""" 3583 log -- ログ出力クラスのオブジェクト frame -- ステータスバーのオブジェクト
※上記引数は、demoプログラムの名残:削除可
parent -- 親ウィンドウを指定
[戻り値]
void
3584 frame -- ステータスバーのオブジェクト ※上記引数は、demoプログラムの名残:削除可
parent -- 親ウィンドウを指定
[戻り値]
void
3585 ※上記引数は、demoプログラムの名残:削除可 parent -- 親ウィンドウを指定
[戻り値]
void
3586 parent -- 親ウィンドウを指定
[戻り値]
void
3591 ogl.ShapeCanvas.__init__(self, parent)
3601 self.SetBackgroundColour(wx.WHITE)
3605 self.diagram.SetCanvas(self)
3609 canvas = self.diagram.GetCanvas()
3610 canvas.lineFrom =
None 3611 canvas.lineTo =
None 3614 canvas.moveLine =
None 3615 canvas.selected = []
3616 canvas.viewMode =
False 3618 rRectBrush = wx.Brush(
"MEDIUM TURQUOISE", wx.SOLID)
3619 dsBrush = wx.Brush(
"WHITE", wx.SOLID)
3623 self.SetDropTarget(dt)
3626 self.Bind(wx.EVT_WINDOW_DESTROY, self.
OnDestroy)
3627 self.Bind(wx.EVT_KEY_DOWN, self.
OnKeyDown)
3631 self.Bind(wx.EVT_RIGHT_UP, self.
OnRightUp)
3634 """コンポーネント単体の色を変更(rtc_state()参照)
[引数]
fullname -- コンポーネントのフルパス名
[戻り値]
void
3637 fullname -- コンポーネントのフルパス名 3644 self.
rtc_dict[fullname].changeBodyColor(state)
3645 self.
rtc_dict[fullname].state = state
3648 """インポートの検索
[引数]
inp_ref -- インポートのオブジェクトリファレンス
[戻り値]
g_inp -- インポートのディクショナリー
3651 inp_ref -- インポートのオブジェクトリファレンス 3654 g_inp -- インポートのディクショナリー 3656 print "len rtc_list:",len(self.
rtc_list)
3659 ref = g_rtc.ns_dict.GetObjRefToFullpath(g_rtc.fullpath)
3661 print "len in_list:",len(g_rtc.in_list)
3662 for inp
in g_rtc.in_list :
3663 print "inp_ref:",inp_ref,
" == ", g_rtc.in_dict[inp[
'name']].inport[
'ref']
3664 if inp_ref._is_equivalent(g_rtc.in_dict[inp[
'name']].inport[
'ref']) :
3665 print "_is_equivalent is OK!!!" 3666 return g_rtc.in_dict[inp[
'name']]
3669 wildcard =
"*.xml |*.xml| *.* |*.*" 3670 dialog = wx.FileDialog( self, strOPEN_TITLE, defaultDir=os.getcwd(),
3671 defaultFile=
"", wildcard=wildcard, style=wx.OPEN)
3673 if dialog.ShowModal() != wx.ID_OK:
3676 openFileName = dialog.GetPath()
3687 print "open file is :",openFileName
3688 if openFileName ==
None:
3695 dict = rtxml.readXML(openFileName)
3697 canvas = self.diagram.GetCanvas()
3698 canvas.viewMode =
True 3702 wildcard =
"*.xml |*.xml| *.* |*.*" 3703 dialog = wx.FileDialog( self, strSAVE_AS_TITLE, defaultDir=os.getcwd(),
3704 defaultFile=
"", wildcard=wildcard, style=wx.SAVE)
3706 if dialog.ShowModal() != wx.ID_OK:
3709 saveFileName = dialog.GetPath()
3714 canvas = self.diagram.GetCanvas()
3723 x_size, y_size = comp.baseBox.GetBoundingBoxMin()
3724 if comp.lastRot ==
'TB':
3725 y_size, x_size = x_size, y_size
3727 x = comp.baseBox.GetX() - x_size/2
3728 y = comp.baseBox.GetY() - y_size/2
3730 dict[
'rtc'][name] = {}
3731 dict[
'rtc'][name][
'x'] = x
3732 dict[
'rtc'][name][
'y'] = y
3734 if comp.lastRot ==
'LR':
3735 if comp.revTogle == 1:
3736 dict[
'rtc'][name][
'rot'] =
'Right' 3738 dict[
'rtc'][name][
'rot'] =
'Left' 3740 if comp.rotTogle == 1:
3741 dict[
'rtc'][name][
'rot'] =
'Top' 3743 dict[
'rtc'][name][
'rot'] =
'Bottom' 3749 for line_idx
in canvas.line:
3750 out_obj = canvas.line[line_idx].g_outp
3751 in_obj = canvas.line[line_idx].g_inp
3755 tmp[
'pos'] = canvas.line[line_idx].coordT
3756 tmp[
'in-comp'] = in_obj.fullpath
3757 tmp[
'in-name'] = in_obj.inport[
'name']
3758 tmp[
'out-comp'] = out_obj.fullpath
3759 tmp[
'out-name'] = out_obj.outport[
'name']
3771 rtxml.writeXML(saveFileName, dict)
3775 if saveFileName ==
None:
3781 """リフレッシュ処理 コンポーネント及び、表示図形のリフレッシュを行う
[引数]
なし
[戻り値]
void
3782 コンポーネント及び、表示図形のリフレッシュを行う 3790 canvas = self.diagram.GetCanvas()
3791 dc = wx.ClientDC(canvas)
3792 canvas.PrepareDC(dc)
3793 for obj
in canvas.selected:
3794 obj.Select(
False, dc)
3795 obj.parent.unselected(dc)
3796 canvas.selected = []
3800 self.
rtc_dict[rtc_name].refresh_outp()
3803 """再接続処理 画面上のコンポーネントの再接続処理を呼び出す
[引数]
なし
[戻り値]
void
3804 画面上のコンポーネントの再接続処理を呼び出す 3816 self.
rtc_dict[rtc_name].reConnectLine()
3826 """ディクショナリーからコンポーネント図形を生成 3829 dict -- アセンブリのディクショナリー 3834 canvas = self.diagram.GetCanvas()
3835 dc = wx.ClientDC(canvas)
3836 canvas.PrepareDC(dc)
3838 rtc_list = dict[
'rtc'].
keys()
3843 for rtc_name
in rtc_list:
3847 ref = self.frame.myDict.GetObjRefToFullpath(rtc_name)
3849 print 'Component Create error!: %s'%rtc_name
3851 ref = ref._narrow(RTM.RTCBase)
3852 tmp = self.frame.myDict.GetCompState(rtc_name)
3856 err_mess =
'Component Create error:%s\n'%rtc_name
3860 new_list.append(rtc_name)
3862 pos_x = dict[
'rtc'][rtc_name][
'x']
3863 pos_y = dict[
'rtc'][rtc_name][
'y']
3864 comp =
GRtc(self, rtc_name, pos_x, pos_y)
3865 comp.changeBodyColor(
'virtual')
3868 if dict[
'rtc'][rtc_name][
'rot'] ==
'Left':
3870 elif dict[
'rtc'][rtc_name][
'rot'] ==
'Top':
3872 elif dict[
'rtc'][rtc_name][
'rot'] ==
'Bottom':
3878 if len(new_list) == 0:
3879 canvas.viewMode =
False 3884 for line_num
in range(len(dict[
'line'])):
3885 line_dict = dict[
'line'][line_num]
3886 out_comp_name = line_dict[
'out-comp']
3887 out_name = line_dict[
'out-name']
3889 in_comp_name = line_dict[
'in-comp']
3890 in_name = line_dict[
'in-name']
3893 if not self.rtc_dict.has_key(out_comp_name):
3894 print 'Assembly Check: Port Connection Error!:',out_comp_name
3896 if not self.
rtc_dict[out_comp_name].out_dict.has_key(out_name):
3897 print 'Assembly Check: Port Connection Error!: ',out_comp_name,
":",out_name
3899 if not self.rtc_dict.has_key(in_comp_name):
3900 print 'Assembly Check: Port Connection Error!:',in_comp_name
3902 if not self.
rtc_dict[in_comp_name].in_dict.has_key(in_name):
3903 print 'Assembly Check: Port Connection Error!: ',in_comp_name,
":",in_name
3906 outp_obj = self.
rtc_dict[out_comp_name].out_dict[out_name]
3907 inp_obj = self.
rtc_dict[in_comp_name].in_dict[in_name]
3909 canvas.lineFrom = outp_obj.body
3910 canvas.lineTo = inp_obj.body
3912 line.setLine2port(canvas, dc)
3913 line.g_outp.connect(line.idx, line.g_outp.subscription_type)
3917 pos_list = string.splitfields(line_dict[
'pos'],
',')
3918 for num
in range(len(pos_list)/2):
3919 pos.append((string.atof(pos_list[num*2]),string.atof(pos_list[num*2+1])))
3922 line.childMove(dc, pos)
3924 canvas.lineFrom =
None 3925 canvas.lineTo =
None 3930 キャンバス、ダイアグラム、イベントとの関連付け 3933 shape -- ビットマップ図形を指定 x -- 表示するx座標
y -- 表示するy座標
pen -- ペン(色、太さ)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
3936 pen -- ペン(色、太さ)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
3939 shape -- wx.Shape 図形オブジェクト 3941 shape.SetDraggable(
False,
False)
3942 shape.SetCanvas(self)
3943 if pen: shape.SetPen(pen)
3946 self.diagram.AddShape(shape)
3948 evthandler.SetShape(shape)
3949 evthandler.SetPreviousHandler(shape.GetEventHandler())
3950 shape.SetEventHandler(evthandler)
3957 キャンバス、ダイアグラム、イベントとの関連付け 3960 shape -- ビットマップ図形を指定 x -- 表示するx座標
y -- 表示するy座標
[戻り値]
shape -- wx.Shape 図形オブジェクト
3965 shape -- wx.Shape 図形オブジェクト 3967 shape.SetDraggable(
True,
False)
3968 shape.SetCanvas(self)
3971 self.diagram.AddShape(shape)
3973 evthandler.SetShape(shape)
3974 evthandler.SetPreviousHandler(shape.GetEventHandler())
3975 shape.SetEventHandler(evthandler)
3982 キャンバス、ダイアグラム、イベントとの関連付け 3985 shape -- ビットマップ図形を指定 x -- 表示するx座標
y -- 表示するy座標
pen -- ペン(色、太さ)を指定
burush -- ブラシ(色)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
3988 pen -- ペン(色、太さ)を指定 burush -- ブラシ(色)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
3989 burush -- ブラシ(色)を指定
[戻り値]
shape -- wx.Shape 図形オブジェクト
3992 shape -- wx.Shape 図形オブジェクト 3994 shape.SetDraggable(
False,
False)
3995 shape.SetCanvas(self)
3998 if pen: shape.SetPen(pen)
3999 if brush: shape.SetBrush(brush)
4000 self.diagram.AddShape(shape)
4002 evthandler.SetShape(shape)
4003 evthandler.SetPreviousHandler(shape.GetEventHandler())
4004 shape.SetEventHandler(evthandler)
4009 def MyAddShape(self, shape, x, y, pen, brush, text, inoutPort=0):
4010 """コンポーネント図形、ポート図形の登録 4011 キャンバス、ダイアグラム、イベントとの関連付け 4014 shape -- ビットマップ図形を指定 x -- 表示するx座標
y -- 表示するy座標
pen -- ペン(色、太さ)を指定
burush -- ブラシ(色)を指定
text -- 図形に表示する文字列を指定
inoutPort -- ポート指定フラグ
0:コンポーネント本体 / 1:Inpot,Outport
[戻り値]
shape -- wx.Shape 図形オブジェクト
4017 pen -- ペン(色、太さ)を指定 burush -- ブラシ(色)を指定
text -- 図形に表示する文字列を指定
inoutPort -- ポート指定フラグ
0:コンポーネント本体 / 1:Inpot,Outport
[戻り値]
shape -- wx.Shape 図形オブジェクト
4018 burush -- ブラシ(色)を指定 text -- 図形に表示する文字列を指定
inoutPort -- ポート指定フラグ
0:コンポーネント本体 / 1:Inpot,Outport
[戻り値]
shape -- wx.Shape 図形オブジェクト
4019 text -- 図形に表示する文字列を指定 inoutPort -- ポート指定フラグ
0:コンポーネント本体 / 1:Inpot,Outport
[戻り値]
shape -- wx.Shape 図形オブジェクト
4020 inoutPort -- ポート指定フラグ 4021 0:コンポーネント本体 / 1:Inpot,Outport 4024 shape -- wx.Shape 図形オブジェクト 4026 shape.SetDraggable(
True,
True)
4027 shape.SetCanvas(self)
4030 if pen: shape.SetPen(pen)
4031 if brush: shape.SetBrush(brush)
4032 if text: shape.AddText(text)
4033 self.diagram.AddShape(shape)
4038 evthandler.SetShape(shape)
4039 evthandler.SetPreviousHandler(shape.GetEventHandler())
4040 shape.SetEventHandler(evthandler)
4041 elif inoutPort == 0:
4043 evthandler.SetShape(shape)
4044 evthandler.SetPreviousHandler(shape.GetEventHandler())
4045 shape.SetEventHandler(evthandler)
4050 """ウィンドウ削除イベントハンドラ
[引数]
evt -- イベント
[戻り値]
void
4053 evt -- イベント
[戻り値]
void
4059 for shape
in self.diagram.GetShapeList():
4060 if shape.GetParent() ==
None:
4061 shape.SetCanvas(
None)
4064 self.diagram.Destroy()
4067 """図形を削除する
[引数]
削除を行うShapeオブジェクト
[戻り値]
void
4070 削除を行うShapeオブジェクト
[戻り値]
void
4075 canvas = self.diagram.GetCanvas()
4076 dc = wx.ClientDC(self)
4077 canvas.PrepareDC(dc)
4078 obj.parent.removeWidget(dc)
4080 if hasattr(obj,
"parent")
and obj.parent.tag ==
'body':
4081 rtc_name = obj.parent.fullpath
4083 tmp = self.rtc_list.index(rtc_name)
4086 if hasattr(obj,
"parent")
and obj.parent.tag ==
'line':
4087 idx = obj.parent.idx
4088 if idx
in canvas.line.keys():
4089 del canvas.line[idx]
4094 """すべての図形を削除する
[引数]
なし
[戻り値]
void
4102 canvas = self.diagram.GetCanvas()
4103 dc = wx.ClientDC(self)
4104 canvas.PrepareDC(dc)
4106 for s
in canvas.selected:
4108 s.parent.unselected(dc)
4110 shapeList = canvas.GetDiagram().GetShapeList()
4111 for obj
in shapeList:
4114 canvas.selected = []
4120 """選択中の図形を削除する
[引数]
なし
[戻り値]
void
4128 canvas = self.diagram.GetCanvas()
4129 dc = wx.ClientDC(self)
4130 canvas.PrepareDC(dc)
4131 for obj
in canvas.selected:
4134 canvas.selected = []
4136 canvas.PrepareDC(dc)
4141 """キー押下時のイベントハンドラ 選択中の図形を削除する
[引数]
evt -- イベント
[戻り値]
void
4142 選択中の図形を削除する
[引数]
evt -- イベント
[戻り値]
void
4145 evt -- イベント
[戻り値]
void
4150 evtKey = evt.GetKeyCode()
4152 if evtKey == wx.WXK_DELETE:
4155 canvas = self.diagram.GetCanvas()
4156 dc = wx.ClientDC(self)
4157 canvas.PrepareDC(dc)
4159 canvas.PrepareDC(bdc)
4163 """コンポーネント本体のスタートを行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4166 evt -- イベント(wx.CommandEvent) 4172 tmpShape = self.FindShape(pt[0],pt[1])
4174 tmpShape[0].parent.ref_start()
4177 """コンポーネント本体のストップを行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4180 evt -- イベント(wx.CommandEvent) 4186 tmpShape = self.FindShape(pt[0],pt[1])
4188 tmpShape[0].parent.ref_stop()
4192 tmpShape = self.FindShape(pt[0],pt[1])
4194 tmpShape[0].parent.ref_reset()
4198 tmpShape = self.FindShape(pt[0],pt[1])
4200 tmpShape[0].parent.ref_exit()
4204 tmpShape = self.FindShape(pt[0],pt[1])
4206 tmpShape[0].parent.ref_kill()
4209 """コンポーネント本体の削除を行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4212 evt -- イベント(wx.CommandEvent) 4217 canvas = self.diagram.GetCanvas()
4218 dc = wx.ClientDC(self)
4219 canvas.PrepareDC(dc)
4221 tmpShape = self.FindShape(pt[0],pt[1])
4223 tmpShape[0].parent.removeWidget(dc)
4226 rtc_name = tmpShape[0].parent.fullpath
4228 tmp = self.rtc_list.index(rtc_name)
4231 for obj
in canvas.selected:
4232 if obj == tmpShape[0]:
4233 tmp = canvas.selected.index(tmpShape[0])
4234 del canvas.selected[tmp]
4236 canvas.PrepareDC(bdc)
4241 """サブメニューの実験用ダミーイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4244 evt -- イベント(wx.CommandEvent) 4249 print "OnPopupSub!!!" 4252 """選択されたアイテムの削除を行うイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4255 evt -- イベント(wx.CommandEvent) 4263 """XMLファイル(comp_data.xml)を読み込むイベントハンドラ
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4266 evt -- イベント(wx.CommandEvent) 4274 """XMLファイル(アセンブリ)を書き込むイベントハンドラ 上書き保存
ファイル名:System?.xml ・・・ ? には画面番号が入る
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4276 ファイル名:System?.xml ・・・ ? には画面番号が入る
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4279 evt -- イベント(wx.CommandEvent) 4284 filename =
"System%d.xml" % self.frame.drawCurNum
4288 """XMLファイル(アセンブリ)を書き込むイベントハンドラ ファイル名変更で保存
ファイル名は、ダイアログでユーザ任意指定
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4290 ファイル名は、ダイアログでユーザ任意指定
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4293 evt -- イベント(wx.CommandEvent) 4301 """Refresh処理を行うイベントハンドラ 古い接続(コンポーネント上にだけsubuscribe情報がある。画面に線が表示されていない状態)が
あるときに、ok/cancelダイアログを表示し、再接続と最新のステータスで色を変更する
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4302 古い接続(コンポーネント上にだけsubuscribe情報がある。画面に線が表示されていない状態)が 4303 あるときに、ok/cancelダイアログを表示し、再接続と最新のステータスで色を変更する
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4306 evt -- イベント(wx.CommandEvent) 4311 canvas = self.diagram.GetCanvas()
4330 ok/cancel ダイアログを表示する
[引数]
str --- ダイアログに表示するメッセージ
[戻り値]
val --- ダイアログの戻り値(wx.ID_OK/wx.ID_CANCEL)
void
4333 str --- ダイアログに表示するメッセージ 4336 val --- ダイアログの戻り値(wx.ID_OK/wx.ID_CANCEL) 4343 dlg.CenterOnParent()
4344 val = dlg.ShowModal()
4351 古い接続(コンポーネント上にsubscribe情報があり画面上には線が表示されていない)があれば、 4352 ok/cancel ダイアログを表示する
[引数]
なし
[戻り値]
val --- ダイアログの戻り値(wx.ID_OK/wx.ID_CANCEL)
古い情報がない時は、wx.ID_OKを返す
void
4358 val --- ダイアログの戻り値(wx.ID_OK/wx.ID_CANCEL) 4359 古い情報がない時は、wx.ID_OKを返す 4368 if connect_flag ==
True:
4373 """Connectメニューの処理を行うイベントハンドラ アセンブリファイル読み込み後の接続(subscribe)処理
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4374 アセンブリファイル読み込み後の接続(subscribe)処理
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4377 evt -- イベント(wx.CommandEvent) 4382 canvas = self.diagram.GetCanvas()
4388 canvas.viewMode =
False 4393 """Deleteメニューの処理を行うイベントハンドラ アセンブリファイル読み込み後の表示画像の全削除処理
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4394 アセンブリファイル読み込み後の表示画像の全削除処理
[引数]
evt -- イベント(wx.CommandEvent)
[戻り値]
void
4397 evt -- イベント(wx.CommandEvent) 4403 canvas = self.diagram.GetCanvas()
4404 canvas.viewMode =
False 4407 """コンポーネント上のポップアップメニュー(コンテキストメニュー)作成 4408 コンポーネント図形本体のOn/Off、削除をメニュー表示 4411 evt -- イベント(wx.MouseEvent)を指定
[戻り値]
void
4418 self.
pt = evt.GetPosition()
4419 if not hasattr(self,
"popupID1"):
4436 menu.Append(self.
popupID1, strSTART)
4437 menu.Append(self.
popupID2, strSTOP)
4438 menu.Append(self.
popupID4, strRESET)
4439 menu.Append(self.
popupID5, strEXIT)
4440 menu.Append(self.
popupID6, strKILL)
4441 menu.AppendSeparator()
4442 menu.Append(self.
popupID3, strDELITEM)
4444 self.PopupMenu(menu, evt.GetPosition())
4448 """バックグランド上のポップアップメニュー(コンテキストメニュー)作成 4452 evt -- イベント(wx.MouseEvent)を指定
[戻り値]
void
4459 self.
pt = evt.GetPosition()
4460 if not hasattr(self,
"popupIDa"):
4474 menu.Append(self.
popupIDa, strDEL_SELECT)
4475 menu.AppendSeparator()
4476 menu.Append(self.
popupIDb, strREFRESH)
4477 menu.AppendSeparator()
4478 menu.Append(self.
popupIDc, strOPEN)
4479 menu.Append(self.
popupIDd, strSAVE)
4480 menu.Append(self.
popupIDe, strSAVE_AS)
4488 self.PopupMenu(menu, evt.GetPosition())
4492 """バックグランド上のポップアップメニュー(コンテキストメニュー)作成 4493 Connect、Delete のメニュー表示 4496 evt -- イベント(wx.MouseEvent)を指定
[戻り値]
void
4503 self.
pt = evt.GetPosition()
4504 if not hasattr(self,
"popupID01"):
4512 menu.Append(self.
popupID01, strASM_CONNECT)
4513 menu.AppendSeparator()
4514 menu.Append(self.
popupID02, strASM_DELETE)
4516 self.PopupMenu(menu, evt.GetPosition())
4520 """右クリック・ダウンのイベントハンドラ マウスカーソルがInport/Outport上だと、ツールチップ(バルーンヘルプ)の表示を行う
コンポーネント本体上では、ポップアップメニューの表示を行う
[引数]
evt -- イベント
[戻り値]
void
4521 マウスカーソルがInport/Outport上だと、ツールチップ(バルーンヘルプ)の表示を行う 4522 コンポーネント本体上では、ポップアップメニューの表示を行う 4525 evt -- イベント
[戻り値]
void
4530 self.log.write(
"OnRightDown")
4531 canvas = self.diagram.GetCanvas()
4532 dc = wx.ClientDC(self)
4533 canvas.PrepareDC(dc)
4534 pt = evt.GetPosition()
4535 tmpShape = self.FindShape(pt[0],pt[1])
4537 if hasattr(tmpShape[0],
'parent'):
4539 if tmpShape[0].parent.tag ==
'in' or tmpShape[0].parent.tag ==
'out':
4543 self.tooltip.body.SetCanvas(canvas)
4544 self.diagram.AddShape(self.tooltip.body)
4545 self.tooltip.body.Show(
True)
4547 elif tmpShape[0].parent.tag ==
'body' and canvas.viewMode ==
False:
4550 if canvas.viewMode ==
False:
4559 """右クリック・アップのイベントハンドラ ツールチップ(バルーンヘルプ)の削除を行う
[引数]
evt -- イベント
[戻り値]
void
4560 ツールチップ(バルーンヘルプ)の削除を行う 4563 evt -- イベント
[戻り値]
void
4568 self.log.write(
"OnRightUp")
4569 canvas = self.diagram.GetCanvas()
4570 dc = wx.ClientDC(self)
4571 canvas.PrepareDC(dc)
4572 pt = evt.GetPosition()
4575 self.tooltip.removeWidget(dc)
4582 """左クリック・ダウンのイベントハンドラ キャンバス上の図形がない空間で左クリックされたら図形選択を解除する
[引数]
evt -- イベント
[戻り値]
void
4583 キャンバス上の図形がない空間で左クリックされたら図形選択を解除する
[引数]
evt -- イベント
[戻り値]
void
4586 evt -- イベント
[戻り値]
void
4591 pt = evt.GetPosition()
4592 tmpShape = self.FindShape(pt[0],pt[1])
4594 canvas = self.diagram.GetCanvas()
4595 dc = wx.ClientDC(self)
4596 canvas.PrepareDC(dc)
4597 for s
in canvas.selected:
4599 s.parent.unselected(dc)
4600 canvas.selected = []
4606 """マウス中ボタン・ダウンのイベントハンドラ コンポーネント図形の本体上で押されたら、回転処理を行う
[引数]
evt -- イベント
[戻り値]
void
4607 コンポーネント図形の本体上で押されたら、回転処理を行う 4610 evt -- イベント
[戻り値]
void
4615 pt = evt.GetPosition()
4616 isShift = evt.ShiftDown()
4617 canvas = self.diagram.GetCanvas()
4618 dc = wx.ClientDC(self)
4619 canvas.PrepareDC(dc)
4620 for s
in canvas.selected:
4622 s.parent.unselected(dc)
4623 canvas.selected = []
4626 tmpShape = self.FindShape(pt[0],pt[1])
4627 if tmpShape != 0
and tmpShape[0].parent.tag ==
'body' and isShift !=
True:
4628 self.log.write(
"OnMiddleDown: " )
4629 tmpShape[0].parent.reversesBody()
4630 elif tmpShape != 0
and tmpShape[0].parent.tag ==
'body' and isShift ==
True:
4631 self.log.write(
"OnMiddleDown + Shift Key: " )
4632 tmpShape[0].parent.rotatesBody()
4645 wx.lib.colourdb.updateColourDB()
4646 win = TestWindow(nb, log, frame)
4664 The Object Graphics Library is a library supporting the creation and 4665 manipulation of simple and complex graphic images on a canvas. 4669 if __name__ ==
'__main__':
4672 run.main([
'', os.path.basename(sys.argv[0])] + sys.argv[1:])
def __init__(self, parent, points)
def OnPopupDelete(self, evt)
def __del__(self, cleanup=ogl.OGLCleanUp)
def OnPopupDelSelectItem(self, evt)
def OnSizingEndDragLeft(self, pt, x, y, keys, attch)
def OnDragLeft(self, draw, x, y, keys, attachment)
def disconnectToObjref(self, subscr_list)
def __init__(self, log, frame)
def removeWidget(self, dc, rot=0)
def OnPopupConnectView(self, evt)
def MyAddShape(self, shape, x, y, pen, brush, text, inoutPort=0)
def __init__(self, parent)
def delLineIdx(self, idx)
def deleteSelectedShape(self)
def dmove(self, dc, movex, movey)
def MyAddBmp(self, shape, x, y, pen)
def saveXML(self, saveFileName)
def OnBeginDragLeft(self, x, y, keys, attachment)
def disconnect(self, line_idx)
def removeWidget(self, dc)
def OnEndDragLeft(self, x, y, keys=0, attachment=0)
def createWidget(self, rot)
def OnMiddleDown(self, evt)
def connect2(self, line_idx, subscription_type)
def updateInportPolygon(self, points)
def runTest(frame, nb, log)
def OnPopupRefresh(self, evt)
def dmove(self, dc, d_x, d_y)
def setBodyColor(shape, colorFlag)
def __init__(self, parent, ns_dict, fullpath, inp, pos_x, pos_y)
def dmove(self, dc, movex, movey)
def OnEndDragLeft(self, x, y, keys=0, attachment=0)
def OnPopupReset(self, evt)
def UpdateStatusBar(self, shape)
def MyAddOval(self, shape, x, y)
def childMove(self, dc, pos_new)
def checkOtherConnect(self)
def dmove(self, dc, movex, movey)
def __init__(self, canvas, parent)
def getConfig(self, name)
def OnLeftClick(self, x, y, keys=0, attachment=0)
def __init__(self, log, frame)
def OnPopupLoadXML(self, evt)
def MyAddText(self, shape, x, y, pen, brush=None)
def setPoints(self, startX, startY, endX, endY)
def OnBeginDragLeft(self, x, y, keys=0, attachment=0)
def makeBackgroundPopupMenu(self, evt)
def OnBeginDragLeft(self, x, y, keys, attachment)
def __init__(self, parent, points)
def OnSizingEndDragLeft(self, pt, x, y, keys, attch)
def OnRightDown(self, evt)
def setLine2port(self, canvas, dc)
def __init__(self, parent, tag, pos_x, pos_y)
def __init__(self, log, frame)
def getConfig(self, name)
def __init__(self, log, frame)
def __init__(self, parent, log)
def OnDragOver(self, x, y, d)
def __init__(self, parent, width, height)
def __init__(self, parent, log, frame)
def updatePolygonSize(self, x, y, ratioW, ratioH)
def connect(self, line_idx, subscription_type)
def OnPopupKill(self, evt)
def UpdateStatusBar(self, shape)
def OnDropText(self, x, y, text)
def OnLeftClick(self, x, y, keys=0, attachment=0)
def __init__(self, parent, canvas)
def setEndPoint(self, dc, shape, movex, movey)
def makeBodyPopupMenu(self, evt)
def OnPopupSaveDefaultXML(self, evt)
void append(SDOPackage::NVList &dest, const SDOPackage::NVList &src)
Append an element to NVList.
def setPoints(self, startX, startY, endX, endY)
def OnLeftClick(self, x, y, keys=0, attachment=0)
def OnDragLeft(self, draw, x, y, keys, attachment)
def __init__(self, parent, pos_x, pos_y, width, height)
def updatePolygonSize(self, x, y, ratioW, ratioH)
def makeViewModePopupMenu(self, evt)
def OnPopupExit(self, evt)
def OnPopupSaveXML(self, evt)
def setStartPoint(self, dc, movex, movey)
def getBufferedDC(canvas)
def OnPopupDeleteView(self, evt)
def __init__(self, parent, ns_dict, fullpath, outp, pos_x, pos_y)
def updatePolygonSize(self, x, y, ratioW, ratioH)
def disconnect(self, line_idx)
def delLineIdx(self, idx)
def OnBeginDragLeft(self, x, y, keys, attachment)
def OnBeginDragLeft(self, x, y, keys, attachment)
def removeWidget(self, dc, rot=0)
def checkConnect(self, inp_obj, subscr_list)
def __init__(self, parent, fullpath, pos_x, pos_y)
def OnDragLeft(self, draw, x, y, keys, attachment)
def checkOtherConnect(self)
def search_g_inp(self, inp_ref)
def __init__(self, log, frame)
def removeWidget(self, dc)
def OnLeftClick(self, x, y, keys=0, attachment=0)
def changeCoordT(self, id, new_p1, new_p2)
def OnPopupSub(self, evt)
def changeCompColor(self, fullname, state)
def removeWidget(self, dc, rot=0)
def OnDragLeft(self, draw, x, y, keys=0, attachment=0)
def checkOtherConnect(self)
def OnLeftDown(self, evt)
def __init__(self, parent, width, height)
def createGRtc_from_dict(self, dict)
def OnPopupStop(self, evt)
def checkConnect2(self, line, subscr_list)
def OnLeftClick(self, x, y, keys=0, attachment=0)
def OnEndDragLeft(self, x, y, keys=0, attachment=0)
def connect(self, line_idx)
def DelOldConnectAskDialog(self)
def OnEndDragLeft(self, x, y, keys=0, attachment=0)
def changeBodyColor(self, state)
def remove(self, dc, canvas)
def updateOutportPolygon(self, points)
def dmove(self, dc, movex, movey)
def OnPopupStart(self, evt)
def deleteShape(self, obj)
def OnEndDragLeft(self, x, y, keys=0, attachment=0)