pipininhos na rotina devido aos CHs

[JoséQuintas]

Pra não ficar com opção vazia, que tal colocar alguma mensagem ?
O nome do módulo ?

[JoséQuintas]

Perto do resto.... isso é super fichinha....
Só troquei a action.

Código: Selecionar todos

         //MENUITEM aItem[1] ACTION { || Nil }
         MENUITEM aItem[1] ACTION { || MsgBox( aItem[1] ) }

Detalhe:
Durante os testes, aquele erro de faltar END WINDOW, acabei mexendo aí.
o correto, para o original é aItem[3]
O terceiro elemento do array é o codeblock a ser executado.

[JoséQuintas]

APENAS CURIOSIDADE, PRA SABER QUE É POSSÍVEL.
Na HWGUI usei esse esquema pra TAB/TABPAGE.
Mas acabei duplicando a rotina, não fiz com níveis ilimitados.
É o mesmo estilo.
Em minigui ainda não tentei pra tabpage.

Código: Selecionar todos

   @ 30, 60 TAB oTabLevel1 ITEMS {} SIZE 950, 650 OF oDlg

   FOR EACH aOption IN aMenuOptions

      BEGIN PAGE aOption[ 1 ] OF oTabLevel1

      // without sub-level
      IF Len( aOption[ 2 ] ) == 0
         IF ValType( aOption[ 3 ] ) == "C"   // can't run on tabpage use button
            @ 30, 50 BUTTON "Dlg " + aOption[ 3 ] ;
               SIZE 200, 24 ;
               ON CLICK aOption[ 4 ]
         ELSE
            Eval( aOption[ 3 ], oTabLevel1 ) // ok display sample
         ENDIF
      ELSE
         // with sub-level, all again
         FOR EACH oTabLevel2 IN { Nil }

            @ 30, 30 TAB oTabLevel2 ITEMS {} SIZE 800, 600 OF oTabLevel1

            FOR EACH aOption2 IN aOption[ 2 ]

               BEGIN PAGE aOption2[ 1 ] OF oTabLevel2

               IF ValType( aOption2[ 3 ] ) == "C" // can't run on tabpage use button
                  @ 30, 50 BUTTON "Dlg " + aOption2[ 3 ] ;
                     SIZE 200, 24 ;
                     ON CLICK aOption2[ 4 ]
               ELSE
                  Eval( aOption2[ 3 ], oTabLevel2 ) // ok display sample
               ENDIF

               END PAGE OF oTabLevel2

            NEXT
         NEXT
      ENDIF

      END PAGE OF oTabLevel1

   NEXT

Nesse daí não se trata apenas de criar as tabpages.
Os exemplos, ao invés de rodarem dentro da dialog, estão rodando dentro de cada tabpage.
Durante a criação de cada tabpage, eu executo o exemplo correspondente.
O ACTION é instantâneo, na criação, e não pra clicar depois.

Já fiz isso em HWGUI e FIVEWIN.
MINIGUI ainda não.

É como cada aba da tabpage ser uma dialog diferente.

Mas usei o mesmo esquema de criar um array com tudo, igual o menu que postei aqui.

[JoséQuintas]

Sei lá...
Fui fazer o mesmo com minigui....
Não aceita TAB dentro de TAB.

[JoséQuintas]

Quase lá............

O programa do início do post, com pequena alteração sobre criar dialog ou não.

Código: Selecionar todos

/*
test codeblock
*/

#include "minigui.ch"

// don't initialize values here
STATIC  nRowPos, nColPos

FUNCTION DemoButton( lWithDialog, xDlg )

   LOCAL aList := {}, nCont, nMesa, xButton, bCode

   hb_Default( @lWithDialog, .T. )

   nColPos := -1
   nRowPos := -1

   FOR nCont = 1 TO 35
      AAdd( aList, nCont + 50 )
   NEXT
   IF lWithDialog
      DEFINE WINDOW ( xDlg := "DLGANY" ) ;
         AT 0,0 ;
         WIDTH 1000 ;
         HEIGHT 500 ;
         MAIN;
         TITLE 'Teste de Mesa' ;
         NOSIZE ;
         NOMAXIMIZE
      END WINDOW
   ENDIF

   FOR nCont := 1 TO Len( aList )

      // two variables uniques
      FOR EACH nMesa, xButton IN ;
         { aList[ nCont ] }, ;
         { "Mesa" + StrZero( nCont,2 ) }

         RowPos( xDlg )
         @ nRowPos, nColPos BUTTONEX ( xButton ) ;
            OF ( xDlg ) ;
            CAPTION "Mesa N." + CRLF + StrZero( nMesa, 2 ) ;
            PICTURE "button.bmp" ;
            BACKCOLOR GREEN GRADIENTFILL { { 1, GREEN,GREEN } } ;
            WIDTH 120 ;
            HEIGHT 60

         bCode := { || MostraMesa( xDlg, nMesa, xButton ) }
         SetProperty( xDlg, xButton, "ACTION", bCode )
      NEXT
   NEXT

   IF lWithDialog
      CENTER WINDOW ( xDlg )
      ACTIVATE WINDOW ( xDlg )
   ENDIF

RETURN Nil

STATIC FUNCTION RowPos( xDlg )

   IF nColPos == -1
      nRowPos := 35
      nColPos := 5
   ELSE
      nColPos += 125
      IF nColPos > GetProperty( xDlg, "width" ) - 200
         nRowPos += 65
         nColPos := 5
      ENDIF
   ENDIF

   RETURN nRowPos

STATIC FUNCTION MostraMesa( xDlg, nMesa, xButton )

   MsgInfo( "Mesa " + StrZero( nMesa, 2 ) + " selecionada" )
   SetProperty( xDlg, xButton, "BACKCOLOR", RED )
   SetProperty( xDlg, xButton, "GRADIENTFILL", { { 1, RED, RED } } )

RETURN Nil

Ok ?
Mesmo exemplo, compila sozinho, executa sozinho, mostra imagem.

Agora fiz outro..... com tab/tagpage e níveis de tab/tabpage

Código: Selecionar todos

#include "minigui.ch"

STATIC aMenuOptions := {}, nMenuLevel := 0

PROCEDURE Demo

   LOCAL xDlg, aList, aInitList := {}

   aList := ze_CreateMenu()

   DEFINE WINDOW ( xDlg := ze_Name( "DLG" ) ) ;
      AT 0, 0 ;
      WIDTH 1024 ;
      HEIGHT 768 ;
      MAIN;
      TITLE "demoall.prg" ;
      ON INIT { || ze_ListEval( aInitList ) }

   END WINDOW

   demo_BuildPages( xDlg, aList, 1, aInitList )

   DoMethod( xDlg, "CENTER" )
   DoMethod( xDlg, "ACTIVATE" )

   RETURN

Aqui cria os níveis de tabs/tabpages

Código: Selecionar todos

STATIC FUNCTION Ze_CreateMenu()

   MenuOption( "Button",                            { |o| DemoButton( .F., o ) } )
   MenuOption( "Browse" )
      MenuDrop()
      MenuOption( "1.Brw.ADO",                      { || Nil } )
      MenuOption( "2.Brw.Array",                    { |o| DemoButton( .F., o ) } )
      MenuOption( "3.Brw.DBF",                      { || Nil } )
      MenuOption( "5.Brw.BMP",                      { |o| DemoButton( .F., o ) } )
      MenuUnDrop()
   MenuOption( "Choice" )
      MenuDrop()
      MenuOption( "1.OwnerButton",                  { || Nil } )
      MenuOption( "1.Checkbox",                     { |o| DemoButton( .F., o ) } )
      MenuOption( "2.Combobox",                     { || Nil } )
      MenuUnDrop()
   MenuOption( "1.General" )
      MenuDrop()
      MenuOption( "2.Night",                        { || Nil } )
      MenuOption( "3.Back image",                   { |o| DemoButton( .F., o ) } )
      MenuUnDrop()
   MenuOption( "Edit" )
   MenuDrop()
      MenuOption( "1.DemoGet2",                     { || Nil } )
      MenuOption( "2.Editbox",                      { || Nil } )
      MenuOption( "4.Datepicker",                   { |o| DemoButton( .F., o ) } )
      MenuUnDrop()
   MenuOption( "1.HTrack",                          { || Nil } )
   MenuOption( "1.Tree",                            { |o| DemoButton( .F., o ) } )
   MenuOption( "1.AppData",                         { || Nil } )

   RETURN aMenuOptions

Não é impressão não, na montagem das tabpages, está chamando o primeiro fonte, o demobutton.prg
Está passando pra NÃO CRIAR DIALOG, e aonde ficará o exemplo em "o".

Está selecionada a tabpage "browse"
dentro dela tem a tab, e está selecionada a tabpage "brw.dbf"
E dentro dessa tabpage, o exemplo demobutton.prg

Está com falha na atualização das abas.
Clica na aba de cima, as de baixo estão vazias, até que se clique em alguma, aí aparece o nome.
Acho que precisa alguma rotina a mais no clique da aba.
NÃO É TAB, é um BROWSE simulando as tabs, e WINDOW PANEL simulando as tabpages.
Está tudo funcionando, exceto essa falha de atualização.

demo.zip

(3.96 KiB) Baixado 50 vezes

Sem usar OOP, sem usar MACRO, sem usar variável PUBLIC, na maior parte só variável LOCAL.

É entender o princípio básico de variáveis/valores, seja sozinho, em array, em codeblock, em function, local, private, etc.

Tem programador que até hoje não entende o que é função, e porque a função não pode depender de variável externa.

Esses desafios são legais, pra treinar ao máximo o conhecimento de variáveis.
A lógica... é a mesma de sempre... só mudam as variáveis...

[JoséQuintas]

Detalhe interessante, talvez:

Código: Selecionar todos

@ 100, 100 BUTTON ( xButton := ze_Name( "BUTTON" ) ) ;

Qual vai ser o nome usado por minigui ?
Sei lá, não me importa.
Eu vou chamar de xButton.

Código: Selecionar todos

   DEFINE WINDOW ( xDlg := ze_Name( "DLG" ) ) ;
      AT 0, 0 ;
      WIDTH 1024 ;
      HEIGHT 768 ;

Qual o nome da dialog usado por minigui ?
Sei lá, não me importa.
Eu vou chamar de xDlg.

Código: Selecionar todos

GetProperty( xDlg, "Width" )
SetProperty( xDlg, "Width", 100 )
DoMethod( xDlg, "Activate" )
GetProperty( xDlg, xButton, "Width" )

Não é simples ?
Pra que complicar ?
Se mesmo assim quiser outro nome, coloca lá no início.... xDlg := "form1_clientes"

[JoséQuintas]

Alterei parcial o browse10.prg
É muita OOP fake pra ajustar, então alterei parcial, o mínimo possível.

Só que esse daí tinha opentables() e closetables() na dialog init e dialog release.
E aí ? como mudar isso pra dialog principal, sem ficar mexendo muito nas coisas ?

Simplesmente simples....
Variáveis na principal, array com codeblocks, porque tudo que é exemplo pode ter isso.

Código: Selecionar todos

PROCEDURE Demo

   LOCAL xDlg, aList, aInitList := {}, aEndList := {}

dialog init/release na principal

Código: Selecionar todos

      ON INIT Eval( { || ze_ListEval( aInitList ) } ) ;
      ON RELEASE Eval( { || ze_ListEval( aEndList ) } ) ;

Na chamada do exemplo, passo como parâmetro

Código: Selecionar todos

      MenuOption( "1.Browse10",                       { |o| DemoBrowse10( .F., o, aInitList, aEndList ) } )

O exemplo precisa simplesmente adicionar na lista

Código: Selecionar todos

   IF lWithDialog
	   DEFINE WINDOW (xDlg := "form_1") ;
		   AT 0,0 ;
		   WIDTH 640 HEIGHT 480 ;
		   TITLE 'Browse Demo' ;
		   MAIN NOMAXIMIZE ;
		   ON INIT OpenTables() ;
		   ON RELEASE CloseTables()
      END WINDOW

      ELSE
         AAdd( aInitList, { || OpenTables() } )
         AAdd( aEndList,  { || CloseTables() } )
      ENDIF

Pronto.
Abriu o que tem tudo junto, vai abrir DBFs, e no final vai fechar.

O que tem isso de complicação ?
Nada.
É simples variável array, e adicionar elementos.

Lógico
- Entrou SET EXCLUSIVE OFF, pra poder abrir arquivos compartilhados.
- Se tiver mais exemplos com mesmo ALIAS, precisaria usar alias diferente.
- O ZAP deu erro, lógico, é compartilhado, ZAP precisa ser em arquivo exclusivo, bloqueei o ZAP
- O exemplo usa a fake OOP, chamando form_1 em trocentos lugares, bloqueei todos, seriam horas pra mudar tudo pra DoMethod(), SetProperty() ou GetProperty()
- Apenas deixei o necessário.

A idéia é legal, ver todos os exemplos de uma vez.
Mas dá trabalho, conforme o jeito de ter sido feito o fonte.

É super interessante isso: a falsa OOP só complica.
O jeito tradicional é muito mais flexível, usando as coisas entre parêntesis.


Ah.... ficou mais curioso ainda.

São tabs... na tabpage da outra tab.... na tabpage da outra tab.

[JoséQuintas]

Faltou dizer....

O principal chama a carga de MenuOption()

Código: Selecionar todos

   aList := ze_CreateMenu( aInitList, aEndList )

E depois chama o automático, que é o que realmente chama os exemplos

Código: Selecionar todos

   demo_BuildPages( xDlg, aList, 1, aInitList, aEndList )

O que mudou ?
Nada.
São as mesmas variáveis array, passando pra lá e pra cá, e sendo atualizadas.

Acho que faltou mostrar a "execução" do sample:

Código: Selecionar todos

            Eval( aOption[ 3 ], xWPage, aInitList, aEndList )

Variável pra lá, variável pra cá, são só as variáveis de início e fim.
É o básico da programação, variável.
A variável pode ir recebendo mais elementos, conforme vai passando pelas rotinas.
SEMPRE LOCAL.
Não precisei criar uma PUBLIC, ou multithread, ou qualquer outra coisa.
É uma variável array e vai fazendo AAdd()

Array por default é por referência, é sempre a mesma do começo ao fim.
Se colocar mais elementos, vai ficar com mais elementos.

E se o exemplo for rodar sozinho..... coloquei lá o default de array vazio.
Seria o único erro possível, vir NIL, e no Aadd() dar erro.

Pois é......
Basta tratar variáveis do jeito que elas funcionam.
Tudo fica mais simples.
Nenhuma rotina monstruosa pra isso.
Mesmo que adicione 1.000 exemplos, vai continuar do mesmo jeito.

Também seria interessante abrir os módulos do aplicativo em abas, conforme for abrindo módulos...
Mas isso já é outra história.
O ideal seria multithread mesmo.

Em HWGUI e FIVEWIN teve a vantagem de OOP e tab dentro de tab, com restrição pra DIALOG.
Em HMG teve a vantagem de WINDOW PANEL, que aceita qualquer coisa.
Qual é melhor ? sei lá... todas fizeram o que era pra ser feito.

O detalhe de atualização da minigui é pesquisar como fazer.
Pouca gente usa browse pra UMA TAB, e ninguém deve usar pra multitabs, só esse teste mesmo.
A partir daí podem aparecer mais recursos !!!!

Pois é... esses testes multiplicam possibilidades, coisas que um dia poderiam aparecer nos aplicativos.
É forçar a LIB a fazer coisas que a LIB nunca pensou, usando os exemplos simples que a lib já tem.

[JoséQuintas]

demo.zip

(5.68 KiB) Baixado 55 vezes

Pra quem quiser brincar.

Vai dar muito trabalho mexer, vou parar por aqui.
Se um dia o oficial ficar no github, poderia ir mais em frente.

[JoséQuintas]

browse funcionando.

browse na tabpage da tab, que está dentro da tabpage da tab, que está dentro da tabpage da tab.

Lembrando: HMGE não aceita tab dentro de tab.
Os outros níveis são simulados com TSBROWSE (exemplo em advanced, tab in tab )
.