home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Misc / DC-POS24.LZX / pOS / pOS_RKRM.lzx / pOS_RKRM / _Txt / Gadget.txt < prev    next >
Encoding:
Text File  |  1997-03-18  |  32.0 KB  |  1,042 lines
  1. 30.06.96: Holger Burkarth
  2. 12.09.96: Holger Burkarth
  3. 17.10.96: Holger Burkarth
  4.  
  5. Gadgets unter pOS:
  6. ------------------
  7. pOS ist ein objekt-orientiertes Betriebsystem und bildet die grafischen
  8. Eingabeelemente als Objekte ab. In pOS werden diese Objekt als Gadget
  9. bezeichnet und sind immer vom Grundaufbau pOS_Gadget-kompatibel.
  10. Das erste Gadget-Objekt, die Root, wird als "gadget.class" bezeichnet und
  11. stellt alle Grundeigenschaften bereit.
  12. Ein Gadget kann von pOS autom. nachgeladen werden. Hierbei dient eine Library
  13. als Grundaufhänger für die dynamische Verwaltung. (siehe p:pCom/_Extern/FindGad.c)
  14.  
  15.  
  16.  
  17. struct pOS_Gadget:
  18. ------------------
  19.  
  20. struct pOS_Gadget
  21. {
  22.  
  23. Die Gadget werden in Listen eingereiht verwaltet. Alle direkt im Window
  24. eingereihten Gadgets befinden sich, nach pOS_AddGadget/pOS_AddGadgets,
  25. in win_GadList. Jedoch werden die Member-Gadgets von Gruppen in privaten
  26. Listen verwaltet. Die Liste win_GadList wird durch pOS_LockIntuiGadget()
  27. geschützt.
  28.  
  29.   pOS_Node      gad_Node;
  30.  
  31. Koordinaten des Gadgets zur Anzeige und zum Event-Handling.
  32. Wird das zugehörige Bit in gad_Flags (GFLG_RelBottom, GFLG_RelRight,
  33. GFLG_RelWidth, GFLG_RelHeight) gesetzt, werden die Koordinaten relativ
  34. zur Window-Größe berechnet. Die Funktion pOS_CalcGadgetBox() berechnet
  35. die absoluten window-bezogenen Gadget-Koordinaten.
  36.  
  37.   SWORD         gad_LeftEdge;
  38.   SWORD         gad_TopEdge;
  39.   SWORD         gad_Width;
  40.   SWORD         gad_Height;
  41.  
  42.  
  43.  
  44.  
  45. GFLG_NoSelect:
  46. Bei gesetztem Bit wird das Gadget nie 'GFLG_Selected' selektiert. Die zugehörige
  47. IDCMP-Message wird dennoch erzeugt.
  48.  
  49.  
  50. GFLG_RelBottom, GFLG_RelRight,GFLG_RelWidth, GFLG_RelHeight:
  51. Die Gadget-Koordinaten werden relativ zur Window-Größe berechnet.
  52.  
  53.  
  54. GFLG_Selected:
  55. Dieses Bit zeigt an, daß das Gadget selektiert (nicht aktiviert) ist.
  56. Je nach Gadget-Type wird das Selected-Bit anderst interpretiert.
  57. Das pOS modifiziert dieses Bit nie, sondern überläßt dies dem Gadget bzw.
  58. der Root-Class (gadget.class).
  59.  
  60. GFLG_Disabled:
  61. Falls das Disabled-Bit gesetzt ist, wird keine IDCMP-Message erzeugt und
  62. das Gadget erhält durch die Root-Class ein Ghost-Raster. (siehe GFLG_PrivateDisable)
  63.  
  64. GFLG_PrivateDisable:
  65. Wünscht das Gadget kein Ghost-Rast durch die Root-Class, so besteht die
  66. Möglichkeit, daß das Gadget eine eigene Disable-Darstellung verwenden kann.
  67.  
  68. GFLG_OSLable:
  69. Befindet sich in gad_Lable ein Lable, das nicht in die Gadget-Reflexbox einbezogen
  70. werden soll, kann das OSLable-Bit den Layouter anweisen, den Lable nicht zu
  71. berücksichtigen.
  72.  
  73. GFLG_Alternate:
  74. Damit Update nicht auf alle Gadget angewendet wird, prüft pOS_RefreshGadgetsMd mit
  75. Mode GCLMTHRE_Update das Alternate-Bit und zeichnet nur diese Gadgets.
  76.  
  77. GFLG_FixSize:
  78. Der Layouter wird angewiesen, dem Gadget nur seine Nominal-Größe zuzuweisen
  79. (imth_GetIBox.imgb_MinIBox). Jede dynamische Platzaufteilung wird nicht angewendet.
  80.  
  81. GFLG_UseMthAddRem:
  82. Muß das Gadget informiert sein, ob es ein Window besitzt und somit gezeichnet
  83. werden darf, werden durch Setzen von GFLG_UseMthAddRem zusätzliche
  84. Nachrichten (GCLMTH_Add/GCLMTH_Rem) erzeugt.
  85.  
  86. GFLG_UseMthLayout:
  87. Das Gadget unterstüzt den pOS-Gadget-Layouter.
  88.  
  89. GFLG_IgnoreIE:
  90. Wird das IgnoreIE-Bit gesetzt, erzeugt pOS nie eine IDCMP-Message.
  91.  
  92. GFLG_DropSelected:
  93. Die Root-Class setzt GFLG_DropSelected, falls ein Drag-Objekt im Gadget
  94. abgelegt werden kann. (siehe GFLG_HighlightDropBox)
  95.  
  96. GFLG_HighlightDropBox:
  97. Weist die Root-Class an, selbständig den GFLG_DropSelected-Mechanismus zu
  98. handhaben.
  99.  
  100.  
  101.   ULONG         gad_Flags;       /* enum pOS_GadgetFlags */
  102.  
  103.  
  104. Immer wenn eine gadget-bezogene IDCMP-Message erzeugt wird, befindet sich
  105. in im_Code die Gadget-ID (gad_ID).
  106.  
  107.   ULONG         gad_ID;          /* user-definable ID field */
  108.  
  109.  
  110. Zur freien Verfügung für den Anwender (nicht für das Gadget).
  111.   ULONG         gad_UserData[2];
  112.  
  113.  
  114. Bei jedem Neuzeichnen wird abhängig vom GFLG_Selected-Flag entschieden,
  115. welches Grafikobjekt gezeichnet werden soll. Ist gad_Select genullt,
  116. so wird gad_Render als selektiert gezeichnet.
  117. Siehe p:pIntui/OClass.h und (enum pOS_IObjectDrawMode),
  118.  
  119.   pOS_IntuiObj *gad_Render;
  120.   pOS_IntuiObj *gad_Select;
  121.  
  122. Gadget-Lable für Titel oder Überschrieften....
  123.   pOS_IntuiObj *gad_Lable;
  124.  
  125.  
  126.  
  127. GACT_RelVerify:
  128. Erzeugt IDCMP_GadgetUp. Zusätzlich wird geprüft, ob die Maustaste über dem
  129. Gadget lösgelassen wird.
  130.  
  131. GACT_Immediate:
  132. Erzeugt IDCMP_GadgetDown. Generiert sofort beim Mausklick eine Message.
  133.  
  134. GACT_UpdateGadget:
  135. Erzeugt IDCMP_UpdateGadget.
  136.  
  137. GACT_RightBorder, GACT_LeftBorder, GACT_TopBorder, GACT_BottomBorder:
  138. Einbeten des Gadgets in den Window-Rahmen.
  139.  
  140. GACT_ToggleSelect:
  141. Toggle schließt GFLG_NoSelect aus.
  142. Ist GACT_Immediate gesetzt, dann wird beim Mausklick sofort das
  143. GFLG_Selected-Bit gewechselt.
  144.  
  145. GACT_ActiveGadget:
  146. Immer wenn das Gadget den Eingabefokus erhält wird diesen Bit gesetzt.
  147. Dieser Mechanismus wird von pOS kontrolliert und darf nicht von außen
  148. verändert werden.
  149.  
  150. GACT_StandardDrop:
  151. GACT_StandardDrag:
  152. Die Root-Class wendet das Standard-Verfahren an.
  153.  
  154. GACT_FixFocus:
  155. Bei gesetztem Bit wird pOS angewiesen, den Eingabefokus vom Gadget zu festigen.
  156. Der Aufruf von pOS_ActivateGadget() auf ein anderes Gadget wird bewirken, daß
  157. 'wir' den Eingabefokus behalten. Das String-Gadget verwendet dieses Bit, um
  158. zu verhindern, daß während der Eingabe der Fokus abgezogen wird. Nur der
  159. User kann mit der Maus den Fokus verändern.
  160.  
  161.  
  162.   ULONG         gad_Activation;  /* enum pOS_GadgetActivate */
  163.  
  164.  
  165.   ULONG         gad_Type;        /* enum pOS_GadgetTypes */
  166.  
  167.  
  168. Gadget-Type bezogener Zeiger auf eine weitere Datenstruktur.
  169.  
  170.   APTR          gad_SpecialInfo;
  171.  
  172. Durch gezieltes Setzen eines Layers, wird das Gadget vom Window-Layer auf den
  173. neuen Layer verschoben.
  174.  
  175.   pOS_Layer    *gad_Layer;
  176.  
  177. Die folgenden zwei Variablen werden von pOS nach GCLMTH_GoActive bzw. GCLMTH_HandleInput
  178. als Notify-Mechanismus eingesetzt. Ausgeschaltet wird der Mechanismus mit
  179. gad_Map=NULL.
  180.  
  181.   APTR          gad_Target;
  182.   const pOS_TagItem *gad_Map;
  183.  
  184.  
  185. Falls das Gadget ein Member-Gadget einer Gruppe ist, befindet sich in
  186. gad_Parent die Gruppe.
  187.  
  188.   pOS_Gadget   *gad_Parent;
  189.  
  190.   const CHAR   *gad_HelpID;
  191.  
  192.  
  193. Einige Gadgets stellen einen Callback bereit, um Events zu filter bzw.
  194. zu modifizieren. Die Root-Class und pOS lesen gad_Callback nur aus, wenn
  195. das GFLG_StdCallback gesetzt ist.
  196.  
  197.   pOS_Callback *gad_Callback;
  198.  
  199. Die Root-Class (gadget.class) stellt einige Border-Typen bereit, die
  200. beim Neuzeichen autom. angezeigt werden. Der Bordertype darf nie
  201. direkt gesetzt werden. Immer die Tags verwenden, sonst könnten
  202. gad_BorXXX-Daten falsch gesetzt sein und das Gadget-Layout ist fehlerhaft.
  203.  
  204.   UBYTE         gad_BorderType;  /* enum pOS_GadgetBorderTypes */
  205.  
  206. Keybord-Support für das Gadget.
  207.   UBYTE         gad_ShortKey;
  208.  
  209. Damit der Gadget-Border als solcher verrechnet werden kann, wird
  210. der Border als Zeichenbereich ausgeblendet.
  211. pOS_CalcGadgetBox() berechnet die gesamte Gadget-Abmaße, wogegen
  212. pOS_CalcGadgetInnerBox() den Border (gad_BorTop,gad_BorLeft,gad_BorRight,gad_BorBottom)
  213. herausrechnet. Alle abgeleiteten Gadgets sollten immer pOS_CalcGadgetInnerBox()
  214. verwendet, so wird gewährleistet, daß die Root-Class den Border-Type richtig
  215. einzeichnen kann.
  216.  
  217.   UBYTE         gad_BorTop,gad_BorLeft,gad_BorRight,gad_BorBottom;
  218.  
  219. Der pOS-Gadget-Layouter bzw. 'grpgad.class' unterstützen Gewichte zur
  220. dynamischen Gadgetanpassung an ein Window. Desto höher das Gewicht, desto
  221. mehr Raum wird dem Gadget zugewiesen. Ein Null-Gewicht hat zur Folge, daß
  222. das Gadget nur die Nominalgröße einnimmt.
  223.  
  224.   UBYTE         gad_Gwk;     /* Layout-Gewicht */
  225.  
  226. Beschreibt die Ausrichtung der Grafikelemente.
  227.  
  228.   UBYTE         gad_LableLay;   /* (enum pOS_IObjectClassLayout) */
  229.   UBYTE         gad_RenderLay;  /* (enum pOS_IObjectClassLayout) */
  230.  
  231. Vom Root-Class-Gadget werden diese Vars autom. berechnet und als
  232. Quick-Referenzen verwendet.
  233.  
  234.   UWORD         gad_LableWidth;  /* wird vom Gadget autom. berechnet */
  235.   UWORD         gad_LableHeight;
  236.  
  237.  
  238. Durch setzen von gad_MutualExclude!=0, wird der Mechanismus eingeschaltet.
  239. Die 'gadget.class' übernimmt sämtliche Kontrollmaßnahmen. Ist ein Bit
  240. gesetzt, bedeutet dies, daß das korrospondierende Gadget de-selected wird.
  241.   UBYTE         gad_MutualExclude;
  242.  
  243.  
  244.  
  245.  
  246.  
  247. ----------------------------------------------------------------------------
  248. pOS tauscht sich mittels der (struct pOS_GadgetMethod) - Datenstruktur mit
  249. den Gadgets aus. Dazu stehen folge Kommandos (Methoden) zur Verfügung.
  250. (enum pOS_IntuiClassMethods)
  251. (enum pOS_GadgetClassMethods)
  252.  
  253. ICLMTH_New:
  254.  Das Gadget wird erzeugt.
  255.  
  256. ICLMTH_Dispose:
  257.  Das Gadget wird gelöscht.
  258.  
  259. ICLMTH_Set:
  260.  Daten ans Gadget übermitteln.
  261.  
  262. ICLMTH_Get:
  263.  Daten vom Gadget lesen.
  264.  
  265. ICLMTH_Update:
  266.  Wie ICLMTH_Set, wird jedoch von pOS intern verwendet.
  267.  
  268. GCLMTH_HitTest:
  269.  Prüfen, ob ein Mauseklick zum Gadget (innerhalb) gehört.
  270.  
  271. GCLMTH_Render:
  272.  Gadget zeichnen.
  273.  
  274. GCLMTH_GoActive:
  275.  Gadget erhält den Eingabefokus und alle Inputevents werden an den Dispatcher
  276.  gesendet.
  277.  
  278. GCLMTH_HandleInput:
  279.  Inputevents auswerten.
  280.  
  281. GCLMTH_GoInactive:
  282.  Gadget verliert den Eingabefokus.
  283.  
  284. GCLMTH_Help:
  285.  Help-Path wird gebildet.
  286.  
  287. GCLMTH_Abort:
  288.  Das Gadget wird abgebrochen (ESC bzw. Right-Mouse).
  289.  
  290. GCLMTH_Add:
  291.  Das Gadget wird ins Window eingehängt und kann jetzt grafische Funktionen
  292.  aufrufen.
  293.  
  294. GCLMTH_Rem:
  295.  Dem Gadget wird das Window entzogen. Es dürfen keine grafische Funktionen
  296.  aufgerufen werden.
  297.  
  298. GCLMTH_Layout:
  299.  Gadget-Layouter.
  300.  
  301. GCLMTH_GetIBox:
  302.  Berechnung der Gadget-Abmaße.
  303.  
  304. GCLMTH_Msg:
  305.  Bearbeitung von IDCMP-Messages in der pOS_SysIMessage-Funktion.
  306.  
  307. GCLMTH_BeginDrag:
  308.  Das Gadget muß ein Drag-Objekt erzeugen.
  309.  
  310. GCLMTH_EndDrag:
  311.  Der Drag-Vorgang ist beendet und das mittels GCLMTH_BeginDrag erzeugte Objekt
  312.  muß wieder gelöscht werden. Root-Class erledigt dies normalerweise.
  313.  
  314. GCLMTH_DropTest:
  315.  Es wird geprüft, ob ein Drag-Objekt an dieser Position abgelegt werden kann.
  316.  
  317. GCLMTH_ActiveDrop
  318.  Das Drop-Gadget bekommt diese Nachricht immer, wenn GCLMTH_DropTest TRUE war.
  319.  
  320. GCLMTH_HandleDrop:
  321.  Ein Gadget, das bei GCLMTH_DropTest sein Ok gab, bekommt solage InputEvents
  322.  bis das Drag bendet oder herausgefahren wird.
  323.  
  324. GCLMTH_InactiveDrop:
  325.  Dem Drop-Gadget wird mitgeteilt, daß ab sofort kein Drop mehr möglich ist.
  326.  
  327. GCLMTH_AbortDrop:
  328.  Drop-Vorgang wurde abgebrochen (rechte Maustaste)
  329.  
  330. GCLMTH_GetQuickDropObject:
  331. GCLMTH_GetDropObject:
  332.  GCLMTH_GetQuickDropObject wird im input.task ans Drag-Gadget geschickt,
  333.  um ein DataType-Objekt zu erzeugen. Meldet das Gadget FALSE, so wird
  334.  GCLMTH_GetDropObject aus dem Anwender-Prozeß heraus aufgerufen.
  335.  Dieser Mechanismus erlaugt es schnell Objekte zu erzeugen bzw. komplexe
  336.  Objekte im Umfeld vom Anwender-Prozeß mit DOS oder anderen Komponenten
  337.  zu Verknüpfen.
  338.  
  339. GCLMTH_SetDropObject:
  340.  Das Drop-Gadget bekommt ein DataType-Objekt übermittelt.
  341.  Wird immer aus dem Anwender-Prozeß aufgerufen.
  342.  
  343.  
  344.  
  345.  
  346. struct pOS_GadgetMethod
  347. {
  348.  
  349. (enum pOS_IntuiClassMethods) bzw. (enum pOS_GadgetClassMethods).
  350. Je nach Method ist eine andere struct der union imth_U zu verwenden.
  351.  
  352.   ULONG  imth_Method;
  353.  
  354.   union {
  355.  
  356.  
  357.  
  358.  
  359. Bei jedem Mauseklick links prüft pOS für jedes Gadget, ob der Mausklick zu einem
  360. Gadget gehört. Dabei befindet sich in imht_RMouse die relative Mausposition zur
  361. linken oberen Gadget-Ecke. imht_AMouse enthält die Koordinaten im Window.
  362. Liegt der Klick innerhalb des Gadgets und das Gadget darf den Eingabefokus
  363. erhalten, dann muß der Dispatcher imht_HitGadget setzen und GCLMTHR_GadgetHit
  364. zurückgeben.
  365.  
  366.     struct { /* GCLMTH_HitTest */
  367.       const pOS_IClassInfo *imht_Info;
  368.             ULONG           imht_Pad;      // damit Mouse mit GoActive... übereinstimmt
  369.       const pOS_Point      *imht_RMouse;   // relativ zum Gadget
  370.       const pOS_Point      *imht_AMouse;   // absolut
  371.             pOS_Gadget     *imht_HitGadget;
  372.     } imth_HitTest;
  373.  
  374.  
  375.  
  376.  
  377. In pOS kann ein Gadget auf mehrere Arten gezeichnet werden. Der imre_Type
  378. beschreibt, wie gezeichnet werden muß.
  379.  
  380. GCLMTHRE_Update:
  381.  Nur die Veränderung zeichnen. Z.B. Slider-Balken beim Prop-Gadget oder
  382.  Textstring beim String-Gadget.
  383.  
  384. GCLMTHRE_Redraw:
  385.  Alle Grafikelemente Zeichen. Die Root-Class zeichnet nur bei GCLMTHRE_Redraw
  386.  den Gadget-Border.
  387.  
  388. GCLMTHRE_Toggle:
  389.  Gadget wechselt GFLG_Selected - Zustand.
  390.  
  391. GCLMTHRE_TickFrame:
  392.  Animations-Teil zeichnen.
  393.  
  394. Ist imre_NewTick==0 und imre_OldTick==0, dann wird das Objekt als Single-Frame
  395. gezeichnet.
  396.  
  397.  
  398.     struct { /* GCLMTH_Render */
  399.       const pOS_IClassInfo *imre_Info;
  400.             ULONG           imre_Type;     /* enum pOS_GadgetClassRender */
  401.             ULONG           imre_NewTick;  /* wird bei GCLMTHRE_TickFrame verwendet */
  402.             ULONG           imre_OldTick;  /* Anzahl der IntuiTicks*100 => 1/1000 sec. */
  403.     } imth_Render;
  404.  
  405.  
  406.  
  407. Immer wenn pOS dem Gadget den Eingabefokus zuteilt, wird ein GCLMTH_GoActive
  408. erzeugt. Dies kann durch Klicken mit der Maus oder durch pOS_ActivateGadget()
  409. geschehen. Nur wenn der Auslöser ein Inputevent ist, ist imac_IE gesetzt.
  410. (imac_RMouse und imac_AMouse wie bei GCLMTH_HitTest)
  411. Will das Gadget den Eingabefokus annehmen, muß GCLMTHR_Activate zurückgegeben
  412. werden. Hat der User dem Gadget GACT_Immediate gesetzt, so wird imac_ResCode als
  413. IDCMP-Code interpretiert. Um zu verhindern, daß ein IE mehrere Aktionen auslöst,
  414. kann mit GCLMTHR_AbortIE explizit der IE als abgeschlossen/bearbeitet
  415. gekennzeichnet werden.
  416.  
  417.     struct { /* GCLMTH_GoActive */
  418.       const pOS_IClassInfo *imac_Info;
  419.       const pOS_InputEvent *imac_IE;     /* NULL => imac_RMouse/imac_AMouse sind nicht gültig */
  420.       const pOS_Point      *imac_RMouse;
  421.       const pOS_Point      *imac_AMouse;
  422.             ULONG           imac_ResCode;  /* => im_Code  */
  423.             pOS_Gadget     *imac_NextActGad; /* zu aktivierendes Gadget */
  424.     } imth_GoActive;
  425.  
  426.  
  427.  
  428.  
  429. Siehe GCLMTH_GoActive. Dem aktuellen Gadget (Eingabefokus) werden alle InputEvents
  430. zur Bearbeitung vorgelegt. Gibt das Gad GCLMTHR_InputDone zurück, signalisiert
  431. dies, daß die Eingabe abgeschlossen ist, das Gadget den Eingabefokus abgibt und
  432. gegebenenfalls ein IDCMP_GadgetUp erzeugt wird. pOS ruft nachträglich NICHT
  433. GCLMTH_GoInactive auf. Damit keine Unstimmigkeit in der Bearbeitung entsteht, muß
  434. GCLMTHR_Activate zurückgegeben werden.
  435.  
  436.     struct { /* GCLMTH_HandleInput */
  437.       const pOS_IClassInfo *imhi_Info;
  438.       const pOS_InputEvent *imhi_IE;
  439.       const pOS_Point      *imhi_RMouse;
  440.       const pOS_Point      *imhi_AMouse;
  441.             ULONG           imhi_ResCode;  /* => im_Code  */
  442.             pOS_Gadget     *imhi_NextActGad;
  443.     } imth_HandleInput;
  444.  
  445.  
  446.  
  447.  
  448. Von außen wird dem Gadget der Eingabefokus entzogen.
  449. Dies geschieht durch Deaktivieren des Windows oder durch Anklicken eines
  450. anderen Gadgets.
  451.  
  452.     struct { /* GCLMTH_GoInactive */
  453.       const pOS_IClassInfo *imia_Info;
  454.             UBYTE           imia_Pad[12];
  455.             ULONG           imia_ResCode;  /* => im_Code  */
  456.     } imth_GoInactive;
  457.  
  458.  
  459.  
  460.  
  461. Wie GCLMTH_GoInactive, jedoch durch explizites Abbruch-Kommando.
  462. (Right-Mouse)
  463.     struct { /* GCLMTH_Abort */
  464.       const pOS_IClassInfo *imab_Info;
  465.             UBYTE           imab_Pad[12];
  466.             ULONG           imab_ResCode;  /* => im_Code  */
  467.             pOS_Gadget     *imab_NextActGad;
  468.     } imth_Abort;
  469.  
  470.  
  471.  
  472. Dem Gadget wird mitgeteilt, auf welchem Window es gezeichnet wird.
  473. In GCLMTH_Add kann imad_Info->ici_Window ausgelesen werden.
  474. Wichtig, diese zwei Methoden werden nur verschickt, wenn das
  475. GFLG_UseMthAddRem-Bit getzt ist. Nach GCLMTH_Rem darf nicht mehr auf das
  476. Window zugegriffen werden.
  477.  
  478.     struct { /* GCLMTH_Add */
  479.       const pOS_IClassInfo *imad_Info;
  480.     } imth_Add;
  481.  
  482.     struct { /* GCLMTH_Rem */
  483.       const pOS_IClassInfo *imrm_Info;
  484.     } imth_Rem;
  485.  
  486.  
  487.  
  488. Der Layouter teilt dem Gadget imly_IBox als Gadget-Abmessung zu.
  489. Über die imly_LD-Daten kann das unschöne Blitzen bzw. doppelte Löschen von
  490. Grafikbereichen durch Region-Technik verhindert werden.
  491. Nur wenn das GFLG_UseMthLayout-Bit gesetzt ist, wird GCLMTH_Layout verwendet.
  492. Die Ausnahme ist, daß alle Member-Gadget (gehören einer Gruppe) immer vom
  493. Layouter bearbeitet werden.
  494.  
  495.     struct { /* GCLMTH_Layout */
  496.       const pOS_IClassInfo   *imly_Info;
  497.             ULONG             imly_Flags;   /* (enum pOS_GadgetLayoutFlags) */
  498.       const pOS_IBox         *imly_IBox;
  499.             pOS_LayoutDamage *imly_LD;
  500.     } imth_Layout;
  501.  
  502.  
  503.  
  504.  
  505. Ermitteln der Gadget-Größe im Window. Die GCLMTH_GetIBox-Methode kann jedoch
  506. ohne vorhandensein vom Window aufgerufen werden. Damit dies ermöglicht wird,
  507. sind imgb_DrawInfo und imgb_RastPort definiert. Das Gadget muß in
  508. imgb_MinIBox und imgb_MaxIBox,  Width und Height setzen.
  509.  
  510.     struct { /* GCLMTH_GetIBox */
  511.       const pOS_DrawInfo  *imgb_DrawInfo;
  512.             pOS_RastPort  *imgb_RastPort;
  513.             pOS_IBox      *imgb_MinIBox;
  514.             pOS_IBox      *imgb_MaxIBox;
  515.     } imth_GetIBox;
  516.  
  517.  
  518.  
  519.  
  520.  
  521. Immer wenn pOS den Help-Mechanismus startet, wird über die aktuelle
  522. Maus-Koordinate das darunterliegende Gadget ermittelt, das den Help-Path
  523. (imhp_String) zusammenbauen kann. Mit folgender Sequenz baut die Root-Class
  524. den Helppath auf:
  525.  
  526.  ret=pOS_AddLinkGadHelpAll(gb_GadgetBase,gad,mth);
  527.  if(ret==0) {
  528.    pOS_AddLinkGadHelpID(gb_GadgetBase,mth,gad->gad_HelpID);
  529.    if((gad->gad_Flags & GFLG_Disabled) && ret!=pOS_CLASSERR)
  530.        pOS_AddLinkGadHelpID(gb_GadgetBase,mth,"DISABLED");
  531.  }
  532.  else ret=pOS_CLASSERR;
  533.  
  534. pOS_AddLinkGadHelpAll() kreiert den Pfad von Root bis zum äußersten Gadget. War
  535. der Help-Level==0 (erster Versuch einen Help zu erzeugen), wird an den Help-Path
  536. noch unsere eigene Help-ID angehängt. Falls das Gadget disabled ist, wird dies
  537. ebenfalls eingebaut.
  538. Z.B.
  539. Window-Help-ID "WIN"
  540. Gad-Gruppe     "Grp"
  541. PropGadget     "PropGad"
  542. OkGadget       "OK"
  543.  
  544. HelpPath:
  545.  
  546. "WIN:Grp/PropGad" oder
  547. "WIN:Grp/OkGad" oder
  548. "WIN:Grp/PropGad/DISABLED" ...
  549.  
  550.  
  551.     struct { /* GCLMTH_Help */
  552.       const pOS_IClassInfo *imhp_Info;
  553.             CHAR           *imhp_String;
  554.       const pOS_Point      *imhp_RMouse;
  555.       const pOS_Point      *imhp_AMouse;
  556.             UWORD           imhp_StringSize;
  557.             UWORD           imhp_Level;      /* 0,1,2... */
  558.     } imth_Help;
  559.  
  560.  
  561.  
  562.  
  563. Durch pOS_SysIMessage() kann eine IDCMP-Message vom Gadget selbst bearbeitet werden.
  564. pOS verwendet diesen Mechanismus für Short-Keys. Der Dispatcher reagiert nicht
  565. auf Keybord-Events. Das pOS erzeugt somit einen normalen IDCMP_VanillaKey und
  566. leitet über pOS_SysIMessage() die zweite, nicht eingabefokus-orientierte
  567. Bearbeitung ein. Wird GCLMTHR_DoneMsg zurückgegeben, dann ist die immg_Msg
  568. bearbeitet und wird nicht weitergereicht. Hat eine IDCMP-Message ihr Ziel
  569. erreicht, wurde aber nicht benötigt, so kann mittels GCLMTHR_NoUsed signalisiert
  570. werden, daß das Anwenderprogramm die Msg auswerten kann
  571. (=>pOS_SysIMessage liefert NULL).
  572.  
  573.     struct { /* GCLMTH_Msg */
  574.       const pOS_IClassInfo   *immg_Info;
  575.             pOS_IntuiMessage *immg_Msg;
  576.     } imth_Msg;
  577.  
  578.   } imth_U;
  579. };
  580.  
  581. ------------------------------------------------------------------------------
  582.  
  583.  
  584.  
  585.  
  586.  
  587.  
  588.  
  589.  
  590.  
  591.  
  592.  
  593.  
  594. Erzeugen einer neuen Gadget-Class:
  595. ----------------------------------
  596.  
  597. {
  598.   pOS_NClass *MyClass;
  599.  
  600.  
  601. /*\
  602. *** Eine neue Class wird von der "gadget.class" abgeleitet.
  603. *** Die neue Klasse wird über den Dispatcher 'MyDispatcher_Func'
  604. *** versorgt und besitzt eigene private Daten (struct MyGadData),
  605. \*/
  606.   MyClass=pOS_CreateClass("MyGad.class","gadget.class",NULL,
  607.                      (APTR)MyDispatcher_Func,
  608.                      sizeof(struct MyGadData),0);
  609.   if(MyClass) {
  610.     ...
  611.  
  612.     pOS_DeleteClass(MyClass);
  613.   }
  614.  
  615. }
  616.  
  617.  
  618.  
  619. /*----------------------------------
  620. -----------------------------------*/
  621. VOID pOSp_SetLayoutIBox(pOS_Gadget *gad,const pOS_IBox* iBox)
  622. {
  623.   gad->gad_LeftEdge=iBox->Left;
  624.   gad->gad_TopEdge =iBox->Top;
  625.   gad->gad_Width   =iBox->Width;
  626.   gad->gad_Height  =iBox->Height;
  627. }
  628.  
  629.  
  630.  
  631.  
  632. Beispiel eines Button-Gadgets:
  633. ------------------------------
  634.  
  635. struct pOS_ButtonGadInfo
  636. {
  637.   UWORD bgi_Width,bgi_Height;
  638.   SWORD bgi_AddWidth,bgi_AddHeight;
  639. };
  640.  
  641.  
  642. VOID ButtonSetTags(pOS_ButtonGadInfo* bgi,const pOS_TagItem* tags)
  643. {
  644.   pOS_TagItem* Tag;
  645.   pOS_Gadget*  Gad;
  646.  
  647.   Gad=(pOS_Gadget*)pOS_GetObjectRootAdr(cl,bgi);
  648.  
  649.   while(Tag=pOS_NextTagItem(&tags)) {
  650.     switch(Tag->ti_Tag) {
  651.       case ICLTAG_AddWidth:    bgi->bgi_AddWidth=Tag->ti_Data;     break;
  652.       case ICLTAG_AddHeight:   bgi->bgi_AddHeight=Tag->ti_Data;     break;
  653.  
  654.       default:
  655.         if(Gad->gad_Render) {
  656.           pOS_SetObjectData(Gad->gad_Render,
  657.             Tag->ti_Tag, Tag->ti_Data,
  658.             TAG_DONE);
  659.         }
  660.         break;
  661.     }
  662. }
  663.  
  664.  
  665. ULONG ButtonGadDispatcher(_R_LB pOS_ExecBase* exec,_R_A0 const pOS_Class* cl,
  666.                           _R_A1 pOS_ButtonGadInfo* bgi,_R_A2 pOS_GadgetMethod* mth)
  667. {
  668.   pOS_Gadget *Gad;
  669.   pOS_Rectangle     Rect;
  670.   pOS_IBox          IBox;
  671.   ULONG ret=0;
  672.  
  673.   Gad=(pOS_Gadget*)pOS_GetObjectRootAdr(cl,bgi);
  674.  
  675.   switch(mth->imth_Method) {
  676. // -----
  677.     case ICLMTH_New:
  678.       {
  679.         const pOS_DrawInfo *DRI=(pOS_DrawInfo*)
  680.               pOS_FindTagData(ICLTAG_DrawInfo,mth->imth_U.imth_New.imnw_Tags,0);
  681.  
  682.         bgi->bgi_AddWidth=8; bgi->bgi_AddHeight=8;
  683.         ret=pOS_DoAbsMethodA(cl,bgi,(pOS_Method*)mth);
  684.         ButtonSetTags(bgi,mth->imth_U.imth_New.imnw_Tags);
  685.         Gad->gad_Type |= GTYP_BoolGadget;
  686.         if(!Gad->gad_Render) {
  687.           Gad->gad_Render=(pOS_IntuiObj*)pOS_NewGObject(NULL,"itext2.class",0,
  688.               TAG_MORE, (ULONG)mth->imth_U.imth_New.imnw_Tags,
  689.               TAG_END);
  690.         }
  691.         if(Gad->gad_Render) { // *** Objekt-Maße gleich berechnen und vermerken
  692.           pOS_IObjectMethod Mth;
  693.           UWORD Ak;
  694.           Gad->gad_Render->iobj_LeftEdge=Gad->gad_Render->iobj_TopEdge=0;
  695.           Mth.imth_Method=IOBMTH_GetIBox;
  696.           Mth.imth_U.imth_GetIBox.imgb_DrawInfo=DRI;
  697.           Mth.imth_U.imth_GetIBox.imgb_RastPort=DRI->dri_Screen->scr_IntuiRP;
  698.           Mth.imth_U.imth_GetIBox.imgb_IBox=&IBox;
  699.           pOS_DoIMethodA(Gad->gad_Render,(pOS_Method*)&Mth);
  700.           Ak=Gad->gad_BorLeft+Gad->gad_BorRight;
  701.           Gad->gad_Width =IBox.Width+Ak+bgi->bgi_AddWidth;
  702.           IBox.Width+=Ak;
  703.           Ak=Gad->gad_BorTop+Gad->gad_BorBottom;
  704.           Gad->gad_Height=IBox.Height+Ak+bgi->bgi_AddHeight;
  705.           IBox.Height+=Ak;
  706.           bgi->bgi_Width=IBox.Width; bgi->bgi_Height=IBox.Height;
  707.         }
  708.         else ret=pOS_CLASSERR;
  709.       }
  710.       break;
  711.  
  712. // -----
  713.     case ICLMTH_Update:
  714.     case ICLMTH_Set:
  715.       pOS_DoAbsMethodA(cl,bgi,(pOS_Method*)mth);
  716.       ButtonSetTags(bgi,mth->imth_U.imth_New.imnw_Tags);
  717.       ret=1;
  718.       break;
  719.  
  720. // -----
  721.     case GCLMTH_GetIBox:
  722.       if(Gad->gad_Lable)
  723.           pOS_DoAbsMethodA(cl,bgi,(pOS_Method*)mth); // *** Grunddaten berechnen
  724.       if(Gad->gad_Render) {
  725.         mth->imth_U.imth_GetIBox.imgb_MinIBox->Width =bgi->bgi_Width + bgi->bgi_AddWidth;
  726.         mth->imth_U.imth_GetIBox.imgb_MinIBox->Height=bgi->bgi_Height+ bgi->bgi_AddHeight;
  727.         mth->imth_U.imth_GetIBox.imgb_MaxIBox->Width =32000; // *** maximal
  728.         mth->imth_U.imth_GetIBox.imgb_MaxIBox->Height=mth->imth_U.imth_GetIBox.imgb_MinIBox->Height;
  729.       }
  730.       break;
  731.  
  732. // -----
  733.     case GCLMTH_Layout:
  734.       if(mth->imth_U.imth_Layout.imly_Flags & GCLMTHLYF_LD) {
  735.         pOS_CalcGadgetBox(mth->imth_U.imth_Layout.imly_Info->ici_Window,Gad,&Rect);
  736.         pOS_OrRectRegion(&mth->imth_U.imth_Layout.imly_LD->lyd_DamLst,&Rect);
  737.       }
  738.       pOSp_SetLayoutIBox(Gad,mth->imth_U.imth_Layout.imly_IBox);
  739.       if(mth->imth_U.imth_Layout.imly_Flags & GCLMTHLYF_LD) {
  740.         pOS_CalcGadgetBox(mth->imth_U.imth_Layout.imly_Info->ici_Window,Gad,&Rect);
  741.         pOS_OrRectRegion(&mth->imth_U.imth_Layout.imly_LD->lyd_NoErase,&Rect);
  742.       }
  743.       break;
  744.  
  745.     default: ret=pOS_DoAbsMethodA(cl,bgi,(pOS_Method*)mth);
  746.   }
  747.   return(ret);
  748. }
  749.  
  750.  
  751.  
  752.  
  753.  
  754. Beispiel eines erweiterten Gadgets:
  755. -------------------------------------
  756.  
  757.  
  758. ULONG PropGadDispatcher(_R_LB pOS_ExecBase* exec,_R_A0 const pOS_Class* cl,
  759.                         _R_A1 pOS_PropGadInfo* pgi,_R_A2 pOS_GadgetMethod* mth)
  760. {
  761.   static pOS_Point RefPoint;
  762.   static UWORD     RefHorizBor,RefVertBor;
  763.  
  764.   pOS_Gadget *Gad;
  765.   pOS_GadgetMethod GMth;
  766.   pOS_Rectangle Rect;
  767.   ULONG ret;
  768.  
  769.   Gad=(pOS_Gadget*)pOS_GetObjectRootAdr(cl,pgi);
  770.  
  771.   switch(mth->imth_Method) {
  772. // -----
  773.     case ICLMTH_New:
  774.       if(!Gad->gad_HelpID) Gad->gad_HelpID="PropGad";
  775.       Gad->gad_SpecialInfo=(APTR)pgi;
  776.       Gad->gad_Type  |= GTYP_PropGadget;
  777.       Gad->gad_Flags |= GFLG_PrivateDisable;
  778.       if(pgi->pg_Total==0) {
  779.         pgi->pg_HorizBody=pgi->pg_VertBody =PRGADCON_MaxBody/2;
  780.         pgi->pg_HPotRes=pgi->pg_VPotRes=PRGADCON_MaxPot/2;
  781.         pgi->pg_Total=0xffff;  pgi->pg_Visible=0x8000;
  782.       }
  783.       ret=pOS_DoAbsMethodA(cl,pgi,(pOS_Method*)mth);
  784.       if(ret!=pOS_CLASSERR) {
  785.         ret=pOSp_PropSetTags(pgi,mth->imth_U.imth_New.imnw_Tags,NULL);
  786.       }
  787.       break;
  788.  
  789. // -----
  790.     case ICLMTH_Update:
  791.     case ICLMTH_Set:
  792.       pOS_DoAbsMethodA(cl,pgi,(pOS_Method*)mth);
  793.       pOSp_PropSetTags(pgi,mth->imth_U.imth_Set.imst_Tags,mth->imth_U.imth_Set.imst_Info);
  794.       ret=1;
  795.       break;
  796.  
  797. // -----
  798.     case ICLMTH_Get:
  799.       if(!(ret=pOS_DoAbsMethodA(cl,pgi,(pOS_Method*)mth)))
  800.         ret=pOSp_GetPropTags(pgi,mth->imth_U.imth_Get.imgt_ID,
  801.                              mth->imth_U.imth_Get.imgt_Variable);
  802.       break;
  803.  
  804.  
  805. // -----
  806.     case GCLMTH_Render:
  807.       {
  808.         pOS_RastPort *RP;
  809.         const pOS_IClassInfo *const GI=mth->imth_U.imth_Render.imre_Info;
  810.  
  811.         if(RP=pOS_ObtainGRastPort(Gad,GI)) {
  812.           pOS_CalcGadgetBox(GI->ici_Window,Gad,&Rect);
  813.           pOSp_PropDraw(pgi,&Rect,GI,RP);
  814.           if(mth->imth_U.imth_Render.imre_Type==GCLMTHRE_Redraw)
  815.                        pOS_DoAbsMethodA(cl,pgi,(pOS_Method*)mth);
  816.           pOS_ReleaseGRastPort(GI,RP);
  817.         }
  818.         ret=1;
  819.       }
  820.       break;
  821.  
  822.  
  823. // -----
  824.     case GCLMTH_GoActive:
  825.       if(mth->imth_U.imth_HandleInput.imhi_IE) {
  826.         ret=GCLMTHR_Activate | GCLMTHR_AbortIE;
  827.         RefPoint=*mth->imth_U.imth_GoActive.imac_RMouse;
  828.         RefHorizBor=pgi->pg_LeftBorder;  RefVertBor=pgi->pg_TopBorder;
  829.         GMth=*mth; GMth.imth_Method=GCLMTH_Render;
  830.         if(RefPoint.X>pgi->pg_LeftBorder && RefPoint.Y>pgi->pg_TopBorder
  831.            && RefPoint.X<=pgi->pg_LeftBorder+pgi->pg_CWidth+
  832.                           Gad->gad_BorLeft+Gad->gad_BorRight
  833.            && RefPoint.Y<=pgi->pg_TopBorder+pgi->pg_CHeight+
  834.                           Gad->gad_BorTop+Gad->gad_BorBottom) {
  835.           Gad->gad_Flags |= GFLG_Selected;
  836.           pgi->pg_Flags |= PRGADF_KnobHit;
  837.           GMth.imth_U.imth_Render.imre_Type=GCLMTHRE_Toggle;
  838.         }
  839.         else {
  840.           ret |= GCLMTHR_InputDone;
  841.           if(pgi->pg_Flags & PRGADF_FreeHoriz) {
  842.             if(RefPoint.X<=pgi->pg_LeftBorder) {
  843.               if(pgi->pg_HorizPot>pgi->pg_HPotRes) pgi->pg_HorizPot-=pgi->pg_HPotRes;
  844.               else                                 pgi->pg_HorizPot=0;
  845.             }
  846.             else pgi->pg_HorizPot=MIN(PRGADCON_MaxPot,pgi->pg_HorizPot+pgi->pg_HPotRes);
  847.           }
  848.           if(pgi->pg_Flags & PRGADF_FreeVert) {
  849.             if(RefPoint.Y<=pgi->pg_TopBorder) {
  850.               if(pgi->pg_VertPot>pgi->pg_VPotRes) pgi->pg_VertPot-=pgi->pg_VPotRes;
  851.               else                                pgi->pg_VertPot=0;
  852.             }
  853.             else pgi->pg_VertPot=MIN(PRGADCON_MaxPot,pgi->pg_VertPot+pgi->pg_VPotRes);
  854.           }
  855.           GMth.imth_U.imth_Render.imre_Type=GCLMTHRE_Update;
  856.         }
  857.         pOS_DoVirMethodA(cl,pgi,(pOS_Method*)&GMth);
  858.       }
  859.       break;
  860.  
  861.  
  862. // -----
  863.     case GCLMTH_HandleInput:
  864.       {
  865.         const pOS_Point *const Pt=mth->imth_U.imth_HandleInput.imhi_RMouse;
  866.         const pOS_InputEvent *const IE=mth->imth_U.imth_HandleInput.imhi_IE;
  867.         GMth=*mth;
  868.  
  869.         ret=GCLMTHR_Activate;
  870.         if(IE->ie_Class == IECLASS_RAWMOUSE) {
  871.           const pOS_IClassInfo *const GI=mth->imth_U.imth_Render.imre_Info;
  872.           UWORD Width,Height;
  873.  
  874.           pOS_CalcGadgetInnerBox(GI->ici_Window,Gad,&Rect);
  875.           Width =Rect.MaxX-Rect.MinX+1 -2;
  876.           Height=Rect.MaxY-Rect.MinY+1 -2;
  877.           if(IE->ie_Code == (IECODE_LBUTTON | IECODE_UP_PREFIX)) {
  878.             Gad->gad_Flags &= ~GFLG_Selected;
  879.             GMth.imth_Method=GCLMTH_Render;
  880.             GMth.imth_U.imth_Render.imre_Type=GCLMTHRE_Toggle;
  881.             pOS_DoVirMethodA(cl,pgi,(pOS_Method*)&GMth);
  882.             ret|=GCLMTHR_InputDone | GCLMTHR_AbortIE;
  883.           }
  884.           else if(IE->ie_Code == IECODE_NOBUTTON) {
  885.             SWORD Dx=Pt->X-RefPoint.X;
  886.             SWORD Dy=Pt->Y-RefPoint.Y;
  887.             ULONG NN=0;
  888.             UWORD Pot,NPot;
  889.  
  890.             if(Dx && (pgi->pg_Flags & PRGADF_FreeHoriz)) {
  891.               Dx=RefHorizBor+Dx; Dx=MAX(0,Dx);
  892.               NN=Dx*PRGADCON_MaxPot/(Width-pgi->pg_CWidth+1);
  893.               NN=FELD(NN,0,PRGADCON_MaxPot);
  894.               Pot=pgi->pg_HorizPot;
  895.               pgi->pg_HorizPot=NN;
  896.               NPot=pgi->pg_HorizPot;
  897.             }
  898.             if(Dy && (pgi->pg_Flags & PRGADF_FreeVert)) {
  899.               Dy=RefVertBor+Dy; Dy=MAX(0,Dy);
  900.               NN=Dy*PRGADCON_MaxPot/(Height-pgi->pg_CHeight+1);
  901.               NN=FELD(NN,0,PRGADCON_MaxPot);
  902.               Pot=pgi->pg_VertPot;
  903.               pgi->pg_VertPot=NN;
  904.               NPot=pgi->pg_VertPot;
  905.             }
  906.             if(Pot!=NPot) {
  907.               GMth.imth_Method=GCLMTH_Render;
  908.               GMth.imth_U.imth_Render.imre_Type=GCLMTHRE_Update;
  909.               pOS_DoVirMethodA(cl,pgi,(pOS_Method*)&GMth);
  910.               ret |= GCLMTHR_UpdateGadget;
  911.             }
  912.           }
  913.         }
  914.       }
  915.       break;
  916.  
  917. // -----
  918.     case GCLMTH_Abort:
  919.       GMth=*mth;
  920.       Gad->gad_Flags &= ~GFLG_Selected;
  921.       pgi->pg_Flags &= ~PRGADF_KnobHit;
  922.       GMth.imth_Method=GCLMTH_Render;
  923.       GMth.imth_U.imth_Render.imre_Type=GCLMTHRE_Toggle;
  924.       pOS_DoVirMethodA(cl,pgi,(pOS_Method*)&GMth);
  925.       ret=GCLMTHR_AbortIE;
  926.       break;
  927.  
  928. // -----
  929.     case GCLMTH_GoInactive:
  930.       pgi->pg_Flags &= ~PRGADF_KnobHit;
  931.       ret=0;
  932.       break;
  933.  
  934. // -----
  935.     case GCLMTH_Layout:
  936.       if(mth->imth_U.imth_Layout.imly_Flags & GCLMTHLYF_LD) {
  937.         pOS_CalcGadgetBox(mth->imth_U.imth_Layout.imly_Info->ici_Window,Gad,&Rect);
  938.         pOS_OrRectRegion(&mth->imth_U.imth_Layout.imly_LD->lyd_DamLst,&Rect);
  939.       }
  940.       pOSp_SetLayoutIBox(Gad,mth->imth_U.imth_Layout.imly_IBox);
  941.       if(mth->imth_U.imth_Layout.imly_Flags & GCLMTHLYF_LD) {
  942.         pOS_CalcGadgetBox(mth->imth_U.imth_Layout.imly_Info->ici_Window,Gad,&Rect);
  943.         pOS_OrRectRegion(&mth->imth_U.imth_Layout.imly_LD->lyd_NoErase,&Rect);
  944.       }
  945.       break;
  946.  
  947.  
  948.     default: ret=pOS_DoAbsMethodA(cl,pgi,(pOS_Method*)mth);
  949.   }
  950.  
  951.   return(ret);
  952. }
  953.  
  954.  
  955.  
  956.  
  957.  
  958. Drag & Drop
  959. ------------
  960.  
  961. Auszug aus einem String-Gadget-Dispatcher:
  962.  
  963. ...
  964. ...
  965. // -----  Erzeugen vom Drag-Objekt, das als Anzeige-Objekt dient.
  966.     case GCLMTH_BeginDrag:
  967.       {
  968.         const pOS_IClassInfo *const GI=mth->imth_U.imth_BDrag.imbd_Info;
  969.         const UWORD *const Pens=GI->ici_DrawInfo->dri_Pens;
  970.         SWORD Dis=GI->ici_DrawInfo->dri_Font->tf_YSize;
  971.  
  972.         sgi->sg_Buffer[sgi->sg_NumChars]='\0'; // *** sicherstellen
  973.         mth->imth_U.imth_BDrag.imbd_Result=pOS_CreateDrag(
  974.            DRAGTAG_LeftEdge, (ULONG)mth->imth_U.imth_BDrag.imbd_AMouse->X-Dis,
  975.            DRAGTAG_TopEdge,  (ULONG)mth->imth_U.imth_BDrag.imbd_AMouse->Y-Dis-6,
  976.            DRAGTAG_GadDrag,  (ULONG)Gad->gad_Drag,
  977.            DRAGTAG_DeleteRender, TRUE,
  978.            DRAGTAG_Render,   (ULONG)pOS_NewGObject(NULL,"itext2.class",0,
  979.               ICLTAG_DrawInfo,      (ULONG)GI->ici_DrawInfo,
  980.               IOBJTAG_DrMd,         DRMD_Jam2,
  981.               IOBJTAG_BGPen,        Pens[SCRPEN_IsSelected],
  982.               IOBJTAG_BGSelPen,     Pens[SCRPEN_SelectAble],
  983.               IOBJTAG_FGPen,        Pens[SCRPEN_Text],
  984.               IOBJTAG_FGSelPen,     Pens[SCRPEN_Text],
  985.               IOBJTAG_StaticString, (ULONG)sgi->sg_Buffer,
  986.               0),
  987.            0);
  988.  
  989.         if(mth->imth_U.imth_BDrag.imbd_Result) {
  990.         }
  991.       }
  992.       ret=1;
  993.       break;
  994.  
  995.  
  996. // ----- Nach dem erfolgreichen Drop wird ein Datenpacket angefordert.
  997.     case GCLMTH_GetQuickDropObject:
  998.     case GCLMTH_GetDropObject:
  999.       {
  1000.         pOS_DtTypeAscii DT;
  1001.         pOS_DClassInfo  DC={pOS_DTFORM_ASCII,NULL,NULL,&DT};
  1002.         DT.dtasc_Buffer =sgi->sg_Buffer;
  1003.         DT.dtasc_BufSize=sgi->sg_NumChars;
  1004.         mth->imth_U.imth_GetQObj.imgqo_Result=
  1005.             pOS_CreateDTObjectA(NULL,pOS_DTNAME_ASCII,0,&DC,DCLMTH_Save,NULL);
  1006.         ret=1;
  1007.       }
  1008.       break;
  1009.  
  1010.  
  1011. // -----  Diesem Gadget wird ein Datenpacket gesendet.
  1012.     case GCLMTH_SetDropObject:
  1013.       {
  1014.         pOS_DtTypeAscii DT;
  1015.         pOS_DClassInfo  DC={pOS_DTFORM_ASCII,NULL,NULL,&DT};
  1016.         DT.dtasc_Buffer =sgi->sg_Buffer;
  1017.         DT.dtasc_BufSize=sgi->sg_MaxChars;
  1018.         pOS_LoadDTObjectA(mth->imth_U.imth_SetObj.imso_Object,&DC,NULL);
  1019.         sgi->sg_NumChars=DC.dci_Result;
  1020.         pOSp_StrUpdateData(sgi);
  1021.         pOSp_StrGadRefresh(cl,sgi,mth->imth_U.imth_SetObj.imso_Info);
  1022.         ret=GCLMTHR_InputDone;
  1023.       }
  1024.       break;
  1025. ...
  1026. ...
  1027.  
  1028.  
  1029.  
  1030.  
  1031.  
  1032.  
  1033.  
  1034.  
  1035.  
  1036.  
  1037.  
  1038.  
  1039.  
  1040.  
  1041. ©proDAD
  1042.